根据JLS(15.28 Constant Expressions) An expression containing only:

i)Literals of primitive type and literals of type String (§3.10.1, §3.10.2, §3.10.3,
§3.10.4, §3.10.5)
or
ii)Simple names (§6.5.6.1) that refer to constant variables (§4.12.4).
or
iii)...

是常量表达式。

现在 String s1="a"+"b"; 是一个常量表达式，将在编译时计算为 "ab"。

所以 s1="ab";

[1] 我说的对吗，根据上面的说法，字符串池中现在有三个对象:-"a","b","ab"???

现在，

final String s="a";
final String s1="b";
String s2=s+s1;  // is also constant expression and get evaluated at compile time.

以上代码编译后会被转为s2="a"+"b";

所以s2="ab";会自动存储到字符串池中。

但是，

// note there is no final now.
String s="a";
String s1="b";
String s2="a"+"b";  // constant expression.
String s3=s+s1;  // is NOT a constant expression and get evaluated at RUN TIME.

对于 String s3=s+s1; ，代码将被翻译成:

s3=new StringBuilder(String.valueOf(s)).append(s1).toString();

并将创建一个新的 String 对象。

因此，s2==s3 将是错误的；

这是否意味着在运行时使用 StringBuilder 评估的字符串连接结果不会存储在字符串池中，而是进入堆(池外)？

最佳答案

来自 JLS §15.18.1:

15.18.1. String Concatenation Operator +

If only one operand expression is of type String, then string conversion (§5.1.11) is performed on the other operand to produce a string at run-time.

The result of string concatenation is a reference to a String object that is the concatenation of the two operand strings. The characters of the left-hand operand precede the characters of the right-hand operand in the newly created string.

The String object is newly created (§12.5) unless the expression is a compile-time constant expression (§15.28).

An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression.

For primitive types, an implementation may also optimize away the creation of a wrapper object by converting directly from a primitive type to a string.

所以，

1. 常量池中有一个对象(“ab”)。临时对象不保存。
2. 同样，常量池中只会有“ab”。
3. 新字符串是一个新的 String 对象，除非明确驻留，否则不会在池中。

查看一些字节码很有启发性:

String sa1 = "a"+ "b";

final String sb1 = "a";
final String sb2 = "b";
String sb3 = sb1 + sb2;

String sc1 = "a";
String sc2 = "b";
String sc3 = "a" + "b";
String sc4 = sc1 + sc2;

成为

  Code:
   0:   ldc #2; //String ab
   2:   astore_0
   3:   ldc #2; //String ab
   5:   astore_3
   6:   ldc #3; //String a
   8:   astore  4
   10:  ldc #4; //String b
   12:  astore  5
   14:  ldc #2; //String ab
   16:  astore  6
   18:  new #5; //class java/lang/StringBuilder
   21:  dup
   22:  invokespecial   #6; //Method java/lang/StringBuilder."<init>":()V
   25:  aload   4
   27:  invokevirtual   #7; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   30:  aload   5
   32:  invokevirtual   #7; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   35:  invokevirtual   #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   38:  astore  7
   40:  return

可以看到，在前两种情况下，“ab”是直接从常量池中加载的。在第三个 block 中，我们得到翻译 sc4 = new StringBuilder().append(sc1).append(sc2).toString()，它创建了一个新对象。

关于java - 运行时字符串连接评估，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12883730/