连接char literal('x')vs单字符串字符串文字("x")

除了剖析这个,我们还有另一种可能获得一些见解的可能性.我想关注可能的速度差异,而不是关注再次移除它们的东西.

所以让我们从这个Test类开始:

public class Test {

    // Do not optimize this
    public static volatile String A = "A String";

    public static void main( String [] args ) throws Exception {

        String a1 = A + "B";

        String a2 = A + 'B';

        a1.equals( a2 );

    }

}

我用javac Test.java编译了这个(使用javac -v:javac 1.7.0_55)

使用javap -c Test.class我们得到:

Compiled from "Test.java"
public class Test {
  public static volatile java.lang.String A;

  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]) throws java.lang.Exception;
    Code:
       0: new           #2                  // class java/lang/StringBuilder
       3: dup
       4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
       7: getstatic     #4                  // Field A:Ljava/lang/String;
      10: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      13: ldc           #6                  // String B
      15: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      18: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      21: astore_1
      22: new           #2                  // class java/lang/StringBuilder
      25: dup
      26: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
      29: getstatic     #4                  // Field A:Ljava/lang/String;
      32: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      35: bipush        66
      37: invokevirtual #8                  // Method java/lang/StringBuilder.append:(C)Ljava/lang/StringBuilder;
      40: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      43: astore_2
      44: aload_1
      45: aload_2
      46: invokevirtual #9                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      49: pop
      50: return

  static {};
    Code:
       0: ldc           #10                 // String A String
       2: putstatic     #4                  // Field A:Ljava/lang/String;
       5: return
}

我们可以看到,涉及两个StringBuilders(第4,22行).所以我们发现的第一件事是,使用+concat Strings实际上与使用StringBuilder相同.

我们在这里可以看到的第二件事是StringBuilders都被调用了两次.首先附加volatile变量(第10,32行),第二次附加常量部分(第15,37行)

在A + "B" append使用Ljava/lang/String(一个字符串)参数调用的情况下,A + 'B'如果使用C(a char)参数调用它.

因此编译不会将String转换为char,而是将其保留为*.

现在查看AbstractStringBuilder包含我们使用的方法:

public AbstractStringBuilder append(char c) {
    ensureCapacityInternal(count + 1);
    value[count++] = c;
    return this;
}

和

public AbstractStringBuilder append(String str) {
    if (str == null) str = "null";
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

作为实际调用的方法.

这里最昂贵的操作当然ensureCapacity只是在达到限制的情况下(它将旧的StringBuffers char []的数组副本转换为新的).所以两者都是如此,并没有真正的区别.

正如人们所看到的那样,还有许多其他的操作已经完成,但真正的区别在于value[count++] = c;和之间str.getChars(0, len, value, count);

如果我们查看getChars,我们会看到,这一切都归结为一个System.arrayCopy用于将String复制到Buffer的数组中的一个加上一些检查和其他方法调用与一个单一数组访问.

所以,我要说在理论上使用A + "B"是慢得多比使用A + 'B'.

我认为在实际执行中它也会变慢.但要确定这一点我们需要进行基准测试.

编辑:原因是这一切都在JIT之前完成它的魔力.请参阅Stephen C的答案.

EDIT2:我一直在研究eclipse编译器生成的字节码,它几乎完全相同.所以至少这两个编译器的结果没有区别.

编辑2: 现在有趣的部分

基准.通过在预热后运行循环0..100M a+'B'和a+"B"几次生成此结果:

a+"B": 5096 ms
a+'B': 4569 ms
a+'B': 4384 ms
a+"B": 5502 ms
a+"B": 5395 ms
a+'B': 4833 ms
a+'B': 4601 ms
a+"B": 5090 ms
a+"B": 4766 ms
a+'B': 4362 ms
a+'B': 4249 ms
a+"B": 5142 ms
a+"B": 5022 ms
a+'B': 4643 ms
a+'B': 5222 ms
a+"B": 5322 ms

平均为:

a+'B': 4608ms
a+"B": 5167ms

因此,即使在真正的基准知识(hehe)基准世界中,a+'B'也比... 快10%左右a+"B".

...至少(免责声明)在我的系统上使用我的编译器和我的cpu,它在现实世界的程序中真的没有区别/不明显.除了因为你有一段代码,你经常运行,你的所有应用程序性能取决于那.但是,你可能会首先做一些与众不同的事情.

EDIT4:

考虑此事.这是用于基准测试的循环:

    start = System.currentTimeMillis();
    for( int i=0; i<RUNS; i++ ){
        a1 = a + 'B';
    }
    end = System.currentTimeMillis();
    System.out.println( "a+'B': " + (end-start) + " ms" );

所以我们真的不仅仅是对我们关心的事情进行基准测试,而且还有java循环性能,对象创建性能以及对变量性能的赋值.所以真正的速度差异甚至可能更大一些.