使用 + 符号连接字符串

Question

今天在看Antonio's Blog about toString() performance有一段话：

昨天被认为是邪恶的（“不要用 + 连接字符串！！！”），现在变得很酷和高效！ 今天，JVM 将 + 符号编译为字符串构建器（在大多数情况下）。所以，不要犹豫，使用它。

现在我很困惑，因为他说 今天 JVM 将 + 符号编译为字符串生成器（在大多数情况下），但我以前从未听说过或见过（代码）这样​​的东西.

有人可以举个例子JVM在哪里这样做以及在什么条件下发生？

Answer 1

规则

“不要用 + 连接字符串！！！”

是错误的，因为它不完整，因此具有误导性。

规则是

不要在循环中用 + 连接字符串

并且这条规则仍然有效。最初的规则绝不是要在循环之外应用的！

一个简单的循环

String s = "";
for (int i = 0; i < 10000; i++) { s += i; }
System.out.println(s);

仍然比

慢很多

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) { sb.append(i); }
System.out.println(sb.toString());

因为 Java 编译器必须将第一个循环翻译成

String s = "";
for (int i = 0; i < 1000; i++) { s = new StringBuilder(s).append(i).toString(); }
System.out.println(s);

还有主张

今天，JVM 将 + 符号编译为字符串构建器（在大多数情况下）。

至少是误导性的，因为这种翻译已经用 Java 1.0 完成了（好吧，不是用 StringBuilder 而是用 StringBuffer，因为 StringBuilder 只是用 Java5 添加的）。

---

人们也可以争辩说这种说法

今天，JVM 将 + 符号编译为字符串构建器（在大多数情况下）。

完全是错误的，因为编译不是由 JVM 完成的。它由 Java 编译器完成。

---

问题是：Java 编译器什么时候使用StringBuilder.append()，什么时候使用其他机制？

Java 编译器（1.8 版）的源代码包含两个处理通过+ 运算符进行字符串连接的地方。

• 首先是字符串常量折叠（http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8u40-b25/com/sun/tools/javac/comp/ConstFold.java?av=f#314）。在这种情况下，编译器可以计算结果字符串并使用结果字符串。
• 第二个位置是编译器为赋值操作创建代码的位置 (http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8u40-b25/com/sun/tools/javac/jvm/Gen.java?av=f#2056)。在这种情况下，编译器总是发出代码来创建一个StringBuilder

结论是，对于来自 OpenJDK 的 Java 编译器（即由 Oracle 分发的编译器），短语在大多数情况下表示始终。 （虽然这可能会随着 Java 9 而改变，或者可能是另一个 Java 编译器，比如 Eclipse 中包含的编译器使用了其他一些机制）。

Answer 2

Holger 的评论是正确的，在 java-9 中，+ 中的字符串连接将从 StringBuilder 变为 JRE 选择的策略，通过 invokedynamic。 jdk-9中String concatenation有6种可能的策略：

  private enum Strategy {
    /**
     * Bytecode generator, calling into {@link java.lang.StringBuilder}.
     */
    BC_SB,

    /**
     * Bytecode generator, calling into {@link java.lang.StringBuilder};
     * but trying to estimate the required storage.
     */
    BC_SB_SIZED,

    /**
     * Bytecode generator, calling into {@link java.lang.StringBuilder};
     * but computing the required storage exactly.
     */
    BC_SB_SIZED_EXACT,

    /**
     * MethodHandle-based generator, that in the end calls into {@link java.lang.StringBuilder}.
     * This strategy also tries to estimate the required storage.
     */
    MH_SB_SIZED,

    /**
     * MethodHandle-based generator, that in the end calls into {@link java.lang.StringBuilder}.
     * This strategy also estimate the required storage exactly.
     */
    MH_SB_SIZED_EXACT,

    /**
     * MethodHandle-based generator, that constructs its own byte[] array from
     * the arguments. It computes the required storage exactly.
     */
    MH_INLINE_SIZED_EXACT
}

而默认的不是使用StringBuilder，它是MH_INLINE_SIZED_EXACT。实现的工作方式实际上非常疯狂，并且正在尝试进行高度优化。

所以，据我所知，那里没有任何建议是不好的。顺便说一句，这是 jdk 由 Aleksey Shipilev 投入的主要努力。他还在 jdk-9 中对 String 内部进行了重大更改，因为它们现在由 byte[] 支持，而不是 char[]。这是必需的，因为ISO_LATIN_1 字符串可以编码为单个字节（一个字符 - 一个字节），因此空间更少。

Answer 3

这种确切形式的陈述是错误的，它符合链接博客继续写废话的情况，就像你必须用Objects.toString(…)包装引用来处理null，例如"att1='" + Objects.toString(att1) + '\'' 而不仅仅是 "att1='" + att1 + '\''。没有必要这样做，显然，作者从未重新检查这些声明。

JVM 不负责编译+ 运算符，因为该运算符只是一个源代码工件。它是编译器，例如javac 负责，虽然不能保证编译后的形式，但鼓励编译器使用Java Language Specification 的构建器：

实现可以选择在一个步骤中执行转换和连接，以避免创建然后丢弃中间字符串对象。为了提高重复字符串连接的性能，Java 编译器可以使用 StringBuffer 类或类似技术来减少通过计算表达式创建的中间字符串对象的数量。

请注意，即使编译器不执行此优化，在字节码级别上仍然没有+ 运算符之类的东西，因此编译器必须选择一个 JVM 可以理解的操作，例如使用String.concat，在您只是连接两个字符串的情况下，这可能比使用StringBuilder 更快。

即使假设字符串连接的最差编译策略（仍然在规范内），说永远不要用+ 连接字符串是错误的，因为在定义编译时间常量时，使用+ 是唯一的选择，当然，编译时常量通常比在运行时使用 StringBuilder 更有效。

实际上，应用于非常量字符串的 + 运算符在 Java 5 之前被编译为 StringBuffer 用法，在 Java 5 到 Java 8 中被编译为 StringBuilder 用法。当编译的代码与手册相同时分别使用StringBuffer。 StringBuilder，不可能有性能差异。

十多年前过渡到 Java 5 是第一次，通过 + 进行字符串连接明显胜过手动使用 StringBuffer，因为只需重新编译连接代码就可以使用可能更快StringBuilder 内部，而手动处理StringBuffer 的代码需要重写以使用该版本中引入的StringBuilder。

同样，Java 9 将使用 invokedynamic 指令编译字符串连接，从而允许 JRE 将其绑定到执行操作的实际代码，包括普通 Java 代码中无法实现的优化。所以只需要重新编译串串代码就可以得到这个特性，而没有等效的手动用法。

也就是说，虽然前提是错误的，即字符串连接从未被认为是邪恶的，但建议是正确的，请不要犹豫。

只有在少数情况下，您确实可以通过手动处理缓冲区来提高性能，即当您需要较大的初始容量或在循环中连接很多时并且该代码已被确定为实际的性能瓶颈通过分析工具…

Answer 4

当您使用 + 运算符连接字符串时，编译器会将连接代码转换为使用 StringBuffer 以获得更好的性能。为了提高性能StringBuffer是更好的选择。

使用 + 运算符连接两个字符串的最快方法。

String str = "Java";
str = str + "Tutorial";

编译器将此代码翻译为：

String s1 = "Java";
StringBuffer sb = new StringBuffer(s1);
sb.append("Tutorial");
s1 = sb.toString();

所以最好使用StringBuffer或String.format进行连接

使用String.format

String s = String.format("%s %s", "Java", "Tutorial");