连接char literal（'x'）vs单字符串字符串文字（“x”）

Question

当我有一个字符串，我需要将一个字符串连接到它的结尾时，我应该更喜欢s = .... + ']'不是s = .... + "]"出于任何性能原因？

我知道数组字符串连接和字符串构建器，我不是要求有关如何连接字符串的建议。

我也知道有些人会有向我解释过早优化的冲动，而且总的来说我不应该为这些小问题烦恼，请不要......

我问，因为从编码风格偏好我更喜欢使用后者，但我觉得第一个应该稍微好一点，因为知道所附加的只是一个字符，不需要任何内部循环复制单个字符串时可能会出现这个单个字符串。

更新

正如@Scheintod写的那样，这确实是一个理论上的问题，并且我希望能够更好地理解java如何工作，而不是任何现实生活“让我们节省另一个微秒”的场景...也许我应该更清楚地说出来。

我喜欢理解“幕后”的工作方式我发现它可以帮助我创建更好的代码...

事实 - 我根本没有考虑编译器优化......

我不希望JIT为我使用StringBuilder而不是String ...因为我（可能错误地）认为String构建器“更重”然后一方面是字符串，但是在构建和修改字符串时更快另一方面。 所以我假设在某些情况下使用StringBuilder的效率甚至比使用stings更低......（如果不是这样的话那么整个String类应该将其实现更改为类似于StringBuilder并使用实际不可变字符串的一些内部表示...... - 或者是JIT有点做什么？ - 假设对于一般情况，最好不要让开发人员选择......）

如果它确实将我的代码更改到这样的程度，那么也许我的Q应该​​处于该级别，询问它是否适合JIT做这样的事情，如果使用它会更好。

也许我应该开始查看已编译的字节码... [我将需要学习如何在java中执行此操作...]

作为一个旁注和我为什么会考虑查看字节码的例子 - 看看我的一篇关于优化Actionscript 2.0的相当古老的博客文章- 一个字节码透视图 - 第一部分它表明知道你的代码编译成确实可以帮助你写了更好的代码。

Answer 1

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

所以让我们从这个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行）。 所以我们发现的第一件事是，使用+来连接Strings实际上与使用StringBuilder相同。

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

在A + "B"情况下，使用Ljava/lang/String （String）参数调用append ，而在A + 'B'情况下，使用C （char）参数调用append 。

因此编译不会将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'比a+"B" 快约10％ ......

...至少（免责声明）在我的系统上使用我的编译器和我的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循环性能，对象创建性能以及对变量性能的赋值。 所以真正的速度差异甚至可能更大一些。

Answer 2

当我有一个字符串，我需要将一个字符串连接到它的结尾时，我应该更喜欢s = .... +']'而不是s = .... +“]”出于任何性能原因？

这里实际上有两个问题：

Q1：有性能差异吗？

答：这取决于......

• 在某些情况下，可能是，取决于JVM和/或字节码编译器。 如果字节码编译器生成对StringBuilder.append(char)的调用而不是StringBuilder.append(String)那么您会期望前者更快。 但JIT编译器可以将这些方法视为“内在函数”，并优化对append(String)调用，使用一个字符（文字）字符串。

  简而言之，您需要在您的平台上对此进行基准测试才能确定。

• 在其他情况下，肯定没有区别。 例如，这两个调用将编译相同的字节码序列，因为串联是一个常量表达式 。

    System.out.println("234" + "]"); System.out.println("234" + ']'); 

  这是由JLS保证的。

Q2：你喜欢一个版本而不是另一个版本。

回答：

• 从一般意义上讲，这可能是一个不成熟的优化。 如果您在应用程序级别分析了代码并确定代码段对性能有可测量的影响，那么出于性能原因，您应该只选择一种形式而不是另一种形式。

• 如果您已对代码进行了分析，请使用Q1的答案作为指导。

  如果值得尝试优化代码片段，那么在优化后重新运行基准测试/分析是至关重要的，看它是否有任何区别。 你对什么是最快的直觉......以及你在互联网上的一篇旧文章中所读到的内容......可能是非常错误的。

Answer 3

没有！ 那是不成熟的优化，完全浪费你的时间。 喜欢你喜欢的任何一种，并使用任何一种作品。 有时']'不会自动提升为“]”。 我希望JIT能够优化你认为你衡量的任何性能差异。 在它工作的情况下，它起作用，因为']'被转换为“]”（在你的例子中）。 现在，直接使用StringBuilder并append(char)可能会稍快一些......但同样，这种差异在任何实际应用程序中都没有意义。

编辑

我能给你的关于性能的最佳建议是：

1. 在开始进行代码更改之前进行基准测试（并尝试通过真正的关键路径识别将自己限制在可能产生影响的区域）和
2. 如果可以，可以流式传输结果，而不是在可能的情况下构建临时字符串（这有时会在内存使用和性能方面产生巨大的回报）。