在java中最快的将整数转换为字符串的方法

Question

每次我必须将int转换为String时，我选择""+a或Integer.toString(a)。现在我想知道哪种方式更快，所以我写了一个简单的基准测试，它调用function_1、function_2和function_3 10000000次，并打印处理这些函数所需的时间。下面是函数:

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;
}

输出为:

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!

我认为function_2是如此之快，因为它被编译为

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

因此，为了避免这种情况，我使用函数getOne()代替。但这里是有趣的部分(对我来说):function_3必须在不使用Object的原始toString方法的情况下进行编译(在本例中是Integer.toString(1)，因为int是原始的)。我的问题是:编译器实际上是如何威胁""+1的，所以它比调用Integer.toString(1)慢?

Answer 1

""和1在编译时是已知的。这就是为什么在function_2中"" + 1在转换为字节码时真正被"1"取代的原因。

getOne()结果在编译时是未知的，因此将在运行时进行连接。但是因为连接(+)不是有效的，编译器很可能会将其更改为基于StringBuilder.append()的实现。

不相信我?试试:javap -c ClassName.class，你会看到这样的内容:

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()只有一个字符串"1"，而function_3有所有这些方法调用与额外的StringBuilder内部:)

请记住，一些优化可能发生在运行时，但这种行为是JVM和它的配置依赖。

Answer 2

我在10,000,000次迭代中测试了以下函数:

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();
}

我结果:

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

不调用函数和调用函数之间的区别实际上可以忽略不计，因此在"" + 1的情况下，它确实在进行一些编译时常数计算。有趣的是，如果没有函数，有时会花费更少的时间……

Answer 3

2和3之间的差异可能是由于必须调用一个方法来获取整数。当您调用一个方法时，它会创建一个新的激活记录，这会使调用堆栈变得复杂，因此这里有更多的事情要做，除非JVM的JIT能够将静态函数调用内联到单个返回值(几乎可以肯定这里不会发生)。