String对象真的可以用==比较吗？

前一阵子用findbug插件寻找bug，发现了一个很奇怪的bug，内容如下：

subTargetNode.addText( (null == subTarget || "" == subTarget.trim() ) ? "_blank" : subTarget  );

[ES] Comparison of String objects using == or != [ES_COMPARING_STRINGS_WITH_EQ] This code compares java.lang.String objects for reference equality using the == or != operators. Unless both strings are either constants in a source file, or have been interned using the String.intern() method, the same string value may be represented by two different String objects. Consider using the equals(Object) method instead.

String不是immutable的类吗？而且还有String Pool，在JVM中相同内容的String对象不是只有一个吗？为什么不可以用==比较相等？东东在网上搜索了一篇文章又查了一下Java Language Specification，有点明白了，

那篇文章如下：

看例子：例子A：   String str1 = "java";   String str2 = "java";   System.out.print(str1==str2);地球上有点Java基础的人都知道会输出false，因为==比较的是引用，equals比较的是内容。不是我忽悠大家，你们可以在自己的机子上运行一 下，结果是true！原因很简单，String对象被放进常量池里了，再次出现“java”字符串的时候，JVM很兴奋地把str2的引用也指向了 “java”对象，它认为自己节省了内存开销。不难理解吧 呵呵例子B：   String str1 = new String("java");   String str2 = new String("java");   System.out.print(str1==str2);看过上例的都学聪明了，这次肯定会输出true！很不幸，JVM并没有这么做，结果是false。原因很简单，例子A中那种声明的方式确实是在 String常量池创建“java”对象，但是一旦看到new关键字，JVM会在堆中为String分配空间。两者声明方式貌合神离，这也是我把“如何创 建字符串对象”放到后面来讲的原因。大家要沉住气，还有一个例子。例子C：   String str1 = "java";   String str2 = "blog";   String s = str1+str2;   System.out.print(s=="javablog");再看这个例子，很多同志不敢妄言是true还是false了吧。爱玩脑筋急转弯的人会说是false吧……恭喜你，你会抢答了！把那个“吧”字去掉你就完 全正确。原因很简单，JVM确实会对型如String str1 = "java"; 的String对象放在字符串常量池里，但是它是在编译时刻那么做的，而String s = str1+str2; 是在运行时刻才能知道（我们当然一眼就看穿了，可是Java必须在运行时才知道的，人脑和电脑的结构不同），也就是说str1+str2是在堆里创建的， s引用当然不可能指向字符串常量池里的对象。没崩溃的人继续看例子D。例子D：   String s1 = "java";   String s2 = new String("java");   System.out.print(s1.intern()==s2.intern());intern()是什么东东？反正结果是true。如果没用过这个方法，而且训练有素的程序员会去看JDK文档了。简单点说就是用intern()方法就 可以用“==”比较字符串的内容了。在我看到intern()方法到底有什么用之前，我认为它太多余了。其实我写的这一条也很多余，intern()方法 还存在诸多的问题，如效率、实现上的不统一……例子E：   String str1 = "java";   String str2 = new String("java");   System.out.print(str1.equals(str2));无论在常量池还是堆中的对象，用equals()方法比较的就是内容，就这么简单！

——————东东加注

下面是东东从Java Language Specification中找到的说明，请大家结合前面的文章思考

package testPackage;class Test {public static void main(String[] args) {String hello = "Hello", lo = "lo";System.out.print((hello == "Hello") + " ");System.out.print((Other.hello == hello) + " ");System.out.print((other.Other.hello == hello) + " ");System.out.print((hello == ("Hel"+"lo")) + " ");System.out.print((hello == ("Hel"+lo)) + " ");System.out.println(hello == ("Hel"+lo).intern());}}class Other { static String hello = "Hello"; }and the compilation unit:package other;public class Other { static String hello = "Hello"; }

produces the output:

 

true true true true false true

This example illustrates six points:

 

• Literal strings within the same class (§8) in the same package (§7) represent references to the same String object (§4.3.1).
• Literal strings within different classes in the same package represent references to the same String object.
• Literal strings within different classes in different packages likewise represent references to the same String object.
• Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.
• Strings computed at run time are newly created and therefore distinct.
• The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

同时附上

JDK文档中String intern方法：

public String intern()

Returns a canonical representation for the string object.

A pool of strings, initially empty, is maintained privately by the class String.

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

All literal strings and string-valued constant expressions are interned. String literals are defined in §3.10.5 of the Java Language Specification

Returns:

a string that has the same contents as this string, but is guaranteed to be from a pool of unique strings.