String对象真的可以用==比较吗？_string类型可以用==来比较吗-优快云博客

本文通过多个实例详细解析了Java中String对象的比较方法，包括使用==和equals的区别，以及String常量池的工作原理。深入探讨了如何利用String的intern方法进行有效比较。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前一阵子用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.