用Java将final声明为==的字符串进行比较

220

我有一个关于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有所作为？它与实习生池有关系吗？还是我被误导了？

java  string  final 
— 小
source
22
我总是觉得很傻，等于是检查相等内容的默认方法，而不是让==这样做，而只是使用referenceEquals或类似的方法来检查指针是否相同。
— 达维奥（Davio）2013年
25
这与“如何比较Java中的字符串？” 不是重复的。以任何方式。OP了解字符串之间equals()和==字符串上下文之间的区别，并提出了一个更有意义的问题。
— arshajii
@Davio但是如果不在上课，那将如何工作String？我认为通过进行内容比较是很合乎逻辑的，不是很愚蠢的，equals可以重写该方法以告诉我们何时认为两个对象相等，并且通过进行标识比较是很逻辑的==。如果内容比较是通过==我们做的，那么我们不能覆盖它来定义“相等内容”是什么意思，equals而==仅对Strings 具有和颠倒的含义将是愚蠢的。另外，无论如何，进行==内容比较而不是都看不出任何优势equals。
— SantiBailors，2017年
@SantiBailors您是正确的，这就是它在Java中的工作方式，我还使用了C＃，其中==重载以实现内容相等。使用==的另一个好处是它是null安全的：（null ==“ something”）返回false。如果对2个对象使用equals，则必须知道其中一个是否可以为null，否则可能会引发NullPointerException。
— Davio

Answers:

232

当您将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始终是“ interned”的，以便使用方法共享唯一的实例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 ，该变量由ldcstep中的操作加载0。然后ldc在步骤，通过操作加载第二个字符串文字7。它不涉及String在运行时创建任何新对象。String在编译时就已为人所知，并且已被嵌入。

— 罗希特·贾恩（Rohit Jain）
source
2
没有什么可以阻止其他Java编译器实现不对最终String进行实习，对吗？
— 艾文（Alvin）2013年
13
@Alvin JLS要求插入编译时常量字符串表达式。任何符合标准的实现都必须在这里做同样的事情。
— 塔维安·巴恩斯
相反，JLS是否要求编译器不得在第一个非最终版本中优化连接？是否禁止编译器生成代码，将比较结果评估为true？
— phant0m
1
@ phant0m服用的现有措辞说明书，“ 该String对象是新创建（§12.5），除非表达为常量表达式（§15.28）。从字面上看，不允许在非最终版本中应用优化，因为“新创建的”字符串必须具有不同的对象标识。我不知道这是否是故意的。毕竟，当前的编译策略是委派给一个运行时工具，该工具没有记录这些限制。
— Holger
31

根据我的研究，所有对象final String都使用Java进行了实习。从一篇博客文章中：

因此，如果您确实需要使用==或！=比较两个String，请确保在进行比较之前调用String.intern（）方法。否则，始终希望使用String.equals（String）进行字符串比较。

因此，这意味着如果调用，String.intern()您可以使用==运算符比较两个字符串。但是这里String.intern()没有必要，因为在Java中final String是内部实习的。

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

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

— Pradeep Simha
source
3
intern（）字符串不是垃圾收集的，而是存储在容量较低的permgen空间中，因此，如果使用不当，则会遇到内存不足错误等麻烦。
— Ajeesh
@Ajeesh-可以对垃圾回收的字符串进行垃圾收集。在某些情况下，甚至由常量表达式产生的内部字符串都可能被垃圾回收。
— 斯蒂芬·C
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它将在运行时创建，因此不会来自字符串池。

另外，如果字符串为final，则编译器可以假定它们永远不会更改，因此StringBuilder可以安全地串联其值，而不是使用它，因此

String concat = str1 + str2;

可以更改为

String concat = "str" + "ing";

并串联成

String concat = "string";

这意味着concate它将成为字符串文字，将被插入字符串池中，然后与if语句中该池中的相同字符串文字进行比较。

— 普什莫
source
15

堆栈和字符串续集池概念 在此处输入图片说明

— 普纳森
source
6
什么？我不明白这是如何投票的。你能澄清你的答案吗？
— 2013年
我认为预期的答案是，因为str1 + str2并未针对内部字符串进行优化，所以与字符串池中的字符串进行比较将导致错误的情况。
— viki.omega9，2013年
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:和2:，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。

— Sotirios Delimanolis
source
0

但是，当您使用Java的String文字表示法创建时，如果该对象尚未存在于池中，它会自动调用intern（）方法将该对象放入String池中。

为什么最终会有所作为？

编译器知道最终变量永远不会改变，当我们添加这些最终变量时，输出也将到达字符串池，因为str1 + str2表达式输出也永远不会改变，因此最终编译器在上述两个最终变量输出之后调用inter方法。如果是非最终变量，则编译器不要调用intern方法。

— Premraj
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.