将字符串与==进行比较,这些字符串在Java中声明为final

Question

我有一个关于Java中的字符串的简单问题.以下简单代码段仅连接两个字符串,然后将它们与之进行比较==.

String str1="str";
String str2="ing";
String concat=str1+str2;

System.out.println(concat=="string");

比较表达式concat=="string"返回false那么明显(I明白之间的差值equals()和==).

---

当这两个字符串被声明时final,

final String str1="str";
final String str2="ing";
String concat=str1+str2;

System.out.println(concat=="string");

比较表达式concat=="string",在这种情况下返回true.为什么会final有所作为？它是否必须与实习生池做某事或我只是被误导？

Answer 1

当您声明一个String(它是不可变的)变量final,并使用编译时常量表达式对其进行初始化时,它也会成为编译时常量表达式,并且其值由编译器在其中使用.因此,在第二个代码示例中,在内联值之后,编译器将字符串连接转换为:

String concat = "str" + "ing";  // which then becomes `String concat = "string";`

在比较"string"时会给你true,因为字符串文字被实习.

来自JLS§4.12.4 - final变量:

原始类型或类型的变量String,即final,用一个编译时间常量表达式(§15.28)初始化,被称为恒定变量.

同样来自JLS§15.28 - 常量表达式:

类型的编译时常量表达式String总是"实例化",以便使用该方法共享唯一实例String#intern().

在您的第一个代码示例中并非如此,其中String变量不是final.因此,它们不是编译时常量表达式.连接操作将延迟到运行时,从而导致创建新String对象.您可以通过比较两个代码的字节代码来验证这一点.

第一个代码示例(非final版本)编译为以下字节代码:

  Code:
   0:   ldc     #2; //String str
   2:   astore_1
   3:   ldc     #3; //String ing
   5:   astore_2
   6:   new     #4; //class java/lang/StringBuilder
   9:   dup
   10:  invokespecial   #5; //Method java/lang/StringBuilder."<init>":()V
   13:  aload_1
   14:  invokevirtual   #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   17:  aload_2
   18:  invokevirtual   #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   21:  invokevirtual   #7; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   24:  astore_3
   25:  getstatic       #8; //Field java/lang/System.out:Ljava/io/PrintStream;
   28:  aload_3
   29:  ldc     #9; //String string
   31:  if_acmpne       38
   34:  iconst_1
   35:  goto    39
   38:  iconst_0
   39:  invokevirtual   #10; //Method java/io/PrintStream.println:(Z)V
   42:  return

显然它存储str并存储ing在两个单独的变量中,并StringBuilder用于执行串联操作.

然而,您的第二个代码示例(final版本)如下所示:

  Code:
   0:   ldc     #2; //String string
   2:   astore_3
   3:   getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;
   6:   aload_3
   7:   ldc     #2; //String string
   9:   if_acmpne       16
   12:  iconst_1
   13:  goto    17
   16:  iconst_0
   17:  invokevirtual   #4; //Method java/io/PrintStream.println:(Z)V
   20:  return

因此它直接内联最终变量以string在编译时创建String ,该变量由ldc步骤中的操作加载0.然后通过ldc步骤中的操作加载第二个字符串文字7.它不涉及String在运行时创建任何新对象.String在编译时已知,并且它们是实例化的.

Answer 2

根据我的研究,所有的final String都是用Java实习的.来自其中一篇博文:

所以,如果你真的需要使用==或!=比较两个String,请确保在进行比较之前调用String.intern()方法.否则,总是更喜欢String.equals(String)进行字符串比较.

所以这意味着如果你打电话,String.intern()你可以使用==operator 比较两个字符串.但这里String.intern()没有必要,因为在Java final String内部实习.

您可以在String.intern()方法中找到更多信息使用==运算符和Javadoc进行字符串比较.

有关更多信息,请参阅此Stackoverflow帖子.

Answer 3

如果你看看这个方法

public void noFinal() {
    String str1 = "str";
    String str2 = "ing";
    String concat = str1 + str2;

    System.out.println(concat == "string");
}

public void withFinal() {
    final String str1 = "str";
    final String str2 = "ing";
    String concat = str1 + str2;

    System.out.println(concat == "string");
}

并使用javap -c ClassWithTheseMethods 您将看到的版本进行反编译

  public void noFinal();
    Code:
       0: ldc           #15                 // String str
       2: astore_1      
       3: ldc           #17                 // String ing
       5: astore_2      
       6: new           #19                 // class java/lang/StringBuilder
       9: dup           
      10: aload_1       
      11: invokestatic  #21                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
      14: invokespecial #27                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
      17: aload_2       
      18: invokevirtual #30                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: invokevirtual #34                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      ...

和

  public void withFinal();
    Code:
       0: ldc           #15                 // String str
       2: astore_1      
       3: ldc           #17                 // String ing
       5: astore_2      
       6: ldc           #44                 // String string
       8: astore_3      
       ...

所以,如果串不是最终的编译器将不得不使用StringBuilder来连接str1和str2使

String concat=str1+str2;

将被编译为

String concat = new StringBuilder(str1).append(str2).toString();

这意味着concat将在运行时创建,因此不会来自String池.

此外,如果字符串是最终的,那么编译器可以假设它们永远不会改变,所以而不是使用StringBuilder它可以安全地连接它的值

String concat = str1 + str2;

可以改为

String concat = "str" + "ing";

并连接成

String concat = "string";

这意味着concate将成为sting文字,它将被固定在字符串池中,然后与if语句中该池中的相同字符串文字进行比较.

Answer 4

堆栈和字符串conts池概念