223

我对 Java 中的字符串有一个简单的问题。下面的简单代码段只是连接两个字符串，然后将它们与==.

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

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

比较表达式concat=="string"返回很明显（我理解和false之间的区别）。equals()==

当这两个字符串这样声明final时，

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

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

比较表达式concat=="string"，在这种情况下返回true。为什么会final有所作为？它与实习生池有关还是我被误导了？

4

6 回答 6

234

当您将一个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所以它在编译时直接内联final变量来创建String ，由ldcstep中的操作加载0。ldc然后通过step中的操作加载第二个字符串文字7。它不涉及String在运行时创建任何新对象。字符串在编译时就已经知道了，它们是被实习的。

于 2013-10-17T04:49:10.997 回答
31

根据我的研究，所有这些final String都是在 Java 中实习的。来自其中一篇博文：

因此，如果您确实需要使用 == 或 != 比较两个字符串，请确保在进行比较之前调用 String.intern() 方法。否则，总是更喜欢 String.equals(String) 进行字符串比较。

所以这意味着如果你打电话String.intern()，你可以使用运算符比较两个字符串==。但是这里String.intern()没有必要，因为在 Javafinal String中是内部实习的。

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

另请参阅此Stackoverflow帖子以获取更多信息。

于 2013-10-17T04:52:23.090 回答
21

如果你看看这个方法

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它将在运行时创建，因此不会来自字符串池。

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

String concat = str1 + str2;

可以改为

String concat = "str" + "ing";

并连接成

String concat = "string";

这意味着concate它将成为字符串字面量，将在字符串池中实习，然后在if语句中与该池中的相同字符串字面量进行比较。

于 2013-10-17T04:52:36.627 回答
15

堆栈和字符串 conts 池概念 在此处输入图像描述

于 2013-10-17T06:33:14.330 回答
3

让我们看看这个final例子的一些字节码

Compiled from "Main.java"
public class Main {
  public Main();
    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: 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
}

在0:and2:处，String "string"被压入堆栈（从常量池中）并直接存储到局部变量concat中。您可以推断出编译器在编译String "string"时正在创建（连接）自身。

非final字节码

Compiled from "Main2.java"
public class Main2 {
  public Main2();
    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: 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/Stri
ngBuilder;
      17: aload_2
      18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/Stri
ngBuilder;
      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
}

这里有两个String常量，"str"需要"ing"在运行时与StringBuilder.

于 2013-10-17T05:03:56.543 回答
0

但是，当您使用 Java 的字符串文字表示法创建时，它会自动调用 intern() 方法将该对象放入字符串池中，前提是该对象尚未出现在池中。

为什么 final 会有所不同？

编译器知道最终变量永远不会改变，当我们添加这些最终变量时，输出会进入字符串池，因为str1 + str2表达式输出也永远不会改变，所以最后编译器在输出上述两个最终变量后调用 inter 方法。在非最终变量编译器的情况下，不要调用实习方法。

于 2016-01-11T07:21:40.210 回答