Java String 在此片段中创建了多少个对象

Question

我正在阅读一些有关 Java 11 认证的书，这段代码确实引起了我的注意。

public class StringCreations {
    public static void main(String[] args) {
        String hello = "hello";/*A STRING CREATED HERE*/
        for(int i=0;i<5;i++){
            hello = hello + i;/*I THINK THAT A STRING IS CREATED IN EACH ITERATION.*/
        }
        System.out.println(hello);/*6 or 11 objects created at this time?? i think is 6*/
    }    
}

书上说这个片段每次迭代创建了 11 个对象 2？它是否正确？ 我认为每次迭代创建 1 个对象，总共创建 6 个对象。

Answer 1

从根本上来说，这并不是一个真正有用的问题(我的意思是，这本书的问题，不是你的问题)，因为它涉及 Java 编译器和各种 JDK 方法的内部细节。但是...

这本书可能指的是 Java 8 或更早版本(尽管它是用于 Java 11 认证 - 我猜测他们没有更新此示例)。在 Java 8 及更早版本中，该代码创建六个字符串(其中一个 - 一开始分配给 hello 的字符串 - 在类加载时创建，然后动态创建五个)。但它也会创建并丢弃 StringBuilder 对象，每次循环迭代一个对象。由于有五次循环迭代，因此有五个 StringBuilder 对象。

6 + 5 = 11。:-)

那就是 no longer true in Java 9 and above ，谢天谢地。更多内容请参见下文。

如果您编译该类(使用 JDK 8 或更早版本)，则可以看到 StringBuilder，然后使用 javap -c StringCreations 查看字节码的呈现:

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String hello
       2: astore_1
       3: iconst_0
       4: istore_2
       5: iload_2
       6: iconst_5
       7: if_icmpge     35
      10: new           #3                  // class java/lang/StringBuilder
      13: dup
      14: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      17: aload_1
      18: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: iload_2
      22: invokevirtual #6                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      25: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      28: astore_1
      29: iinc          2, 1
      32: goto          5
      35: getstatic     #8                  // Field java/lang/System.out:Ljava/io/PrintStream;
      38: aload_1
      39: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      42: return

循环的偏移量为 5 到 32。在偏移量 14 处，您可以看到正在创建一个 StringBuilder，然后在偏移量 25 处调用其 toString(创建一个新字符串) ;循环。

第一个字符串实际上并不是由该​​代码创建的，它是通过加载类(及其常量池)创建的，但循环中的五个字符串是由该代码创建的，当然还有五个 StringBuilder在循环中。

将其与 Java 13 生成的字节码进行比较:

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #7                  // String hello
       2: astore_1
       3: iconst_0
       4: istore_2
       5: iload_2
       6: iconst_5
       7: if_icmpge     24
      10: aload_1
      11: iload_2
      12: invokedynamic #9,  0              // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;I)Ljava/lang/String;
      17: astore_1
      18: iinc          2, 1
      21: goto          5
      24: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
      27: aload_1
      28: invokevirtual #19                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

循环从偏移量 5 到偏移量 21，但看不到 StringBuilder 了；相反，会调用 makeConcatWithConstants 。因此，您最终只得到六个字符串(来自常量池的一个，然后是通过 makeConcatWithConstants 动态创建的五个)。

正如 kaya3 在评论中指出的那样，我们不知道(在这两种情况下)StringBuilder.append 或 makeConcatWithConstants 是否会转换 i 在返回新字符串之前在其实现中将其转换为字符串。这意味着在 Java 8 中它将有 16 个对象(11 个字符串和 5 个 StringBuilders)，而在 Java 9+ 中将有 11 个字符串。但考虑到 makeConcatWithConstants 的目的是“...创建优化的字符串连接方法...”，我认为我们可以假设它不会为 创建字符串i 与创建将作为其结果的新字符串分开。但实际上现在我们已经深入了解了 Java 编译器、JVM 及其 JIT 等的详细信息。