Fastest way of converting integer to string in java

Question

Everytime I had to convert an intinto a String I picked either ""+aor Integer.toString(a). Now I wondered which way is faster, so I wrote a simple benchmark that calls function_1, function_2 and function_3 10000000 times and prints how long it takes to process the functions. Here are the functions:

public static String i="";
public static String j="";
public static String k="";

public static void function_1()
{
    i=Integer.toString(getOne());
}

public static void function_2()
{
    j=""+1;
}

public static void function_3()
{
    j=""+getOne();
}

public static int getOne()
{
    return 1;
}

the output is:

Benchmarking starting...
Executing function_1 10000000 time(s)...
Done executing function_1 in 476 ms.
Executing function_2 10000000 time(s)...
Done executing function_2 in 8 ms.
Executing function_3 10000000 time(s)...
Done executing function_3 in 634 ms.
Benchmarking complete!

I think function_2 is so fast, because it is compiled as

public static void function_2()
{
    j="1";
}

so to avoid that, I used the function getOne() instead. But here is the interesting part(for me): function_3 must be compiled without using the original toString method of Object(in this case Integer.toString(1) because int is primitive). My question is: How does the compiler actually threat ""+1 so it is slower then calling Integer.toString(1)?

Have you considered looking at the bytecode? Also, micro-benchmarks are, in general, useless. Things could be happening at the JIT level as well. — Dave Newton
– Dave Newton, Commented Mar 27, 2013 at 20:47
If you look at the bytecode you'll probably find that function_3 uses a StringBuilder while function_1 doesn't. And internally, the StringBuilder will call String.valueOf(). — parsifal
– parsifal, Commented Mar 27, 2013 at 20:56
@D180 - according to your numbers, function_3 is slower than function_1. If you're wondering why it's "faster," stop wondering :-) — parsifal
– parsifal, Commented Mar 27, 2013 at 20:57
The fastest way to convert an integer to a string is probably to use Integer.toString(int). (Though a clever programmer could probably do considerably better.) — Hot Licks
– Hot Licks, Commented Mar 27, 2013 at 21:09

msi · Accepted Answer · 2013-03-27 21:05:31Z

"" and 1 are known at compile time. This is why in function_2 "" + 1 is really replaced by "1" while convertion to bytecode.

getOne() result is unknown at the compilation time so the concatenation will be done in runtime. BUT because concatenation (+) is not efficient it is likely that compiler will change this to StringBuilder.append() based implementation.

Don't believe me? Try: javap -c ClassName.class and you will see something like this:

public static void function_2();
Code:
   0: ldc           #39                 // String 1
   2: putstatic     #16                 // Field j:Ljava/lang/String;
   5: return        


public static void function_3();
Code:
   0: new           #42                 // class java/lang/StringBuilder
   3: dup           
   4: invokespecial #44                 // Method java/lang/StringBuilder."<init>":()V
   7: invokestatic  #28                 // Method getOne:()I
  10: invokevirtual #45                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
  13: invokevirtual #49                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
  16: putstatic     #16                 // Field j:Ljava/lang/String;
  19: return

function_2() have only one String "1", while function_3 have all these method calls with additional StringBuilder inside :)

Keep in mind that some optimization may occur at runtime, but this behavior is JVM and it's configuration dependent.

Claudiu · Accepted Answer · 2013-03-27 21:02:32Z

1

I tested the following functions on 10,000,000 iterations:

public static void no_func_maybe_constant()
{
    j= "" + 1;
}

public static void no_func_no_constant()
{
    j = "";
    j = j + 1;
}

public static void yes_func_maybe_constant()
{
    j = "" + getOne();
}

public static void yes_func_no_constant()
{
    j = "";
    j = j + getOne();
}

My results:

no_func_maybe_constant Took 0.028058674s
no_func_no_constant Took 1.449465242s
yes_func_maybe_constant Took 1.275561897s
yes_func_no_constant Took 1.263362257s

The difference between not calling the function and calling the function was indeed negligible, so it seems in the case of "" + 1 it was indeed doing some compile-time constant calculation. Interesting that without a function it sometimes took less time...

edited Mar 27, 2013 at 21:02

answered Mar 27, 2013 at 20:47

Claudiu

231k174 gold badges507 silver badges701 bronze badges

9 Comments

D180 Over a year ago

so calling a function takes so much time?

Claudiu Over a year ago

@D180: Yea, it takes way longer to call a function than to simply have a constant already there.

Tushar Over a year ago

@Claudiu why doesn't the compiler in-line function_3?

Mysticial Over a year ago

@D180 Nah. I think your guess in your question is correct. It's being optimized to "1". So no conversion is actually needed. The conversion would probably be much more expensive than the function call.

Andrew Bissell Over a year ago

@D180 The compiler can optimize away empty functions as no-ops. In general setting up micro-benchmarks in the dynamically-compiled environment of the JVM is very complicated and it's not easy to correctly guess what the compiler is actually doing under the hood. ibm.com/developerworks/java/library/j-benchmark1/index.html

|

Mike Thomsen · Accepted Answer · 2013-03-27 20:50:37Z

0

The difference between 2 and 3 is likely due to having to call a method to get the integer. When you call a method, it creates a new activation record which complicates the call stack so there is more going on here unless the JVM's JIT is capable of inlining that static function call to just the single return value (almost certainly not happening here).

answered Mar 27, 2013 at 20:50

Mike Thomsen

37.7k11 gold badges63 silver badges86 bronze badges

1 Comment

Hot Licks Over a year ago

I would expect the JITC to inline that call. Quite possibly the JITC is not being activated for some reason (which makes the whole exercise bogus, since the interpreter overhead swamps everything else).

Collectives™ on Stack Overflow

Fastest way of converting integer to string in java

3 Answers 3

Comments

9 Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

9 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related