class Test {
public static void main(String...args) {
String s1 = "Good";
s1 = s1 + "morning";
System.out.println(s1.intern());
String s2 = "Goodmorning";
if (s1 == s2) {
System.out.println("both are equal");
}
}
}
这段代码在Java 6和Java 7中产生不同的输出结果。在Java 6中，s1==s2条件返回false，而在Java 7中，s1==s2返回true。为什么？
String b2 =...行的位置。下面的代码也不会输出消息：class Test {
public static void main(String... args) {
String s1 = "Good";
s1 = s1 + "morning";
String s2 = "Goodmorning";
System.out.println(s1.intern()); //just changed here s1.intern() and the if condition runs true
if(s1 == s2) {
System.out.println("both are equal");
} //now it works.
}
}
intern在其字符串池中找不到该字符串时，将实际的实例s1插入到池中。JVM在创建s2时使用该池，因此它会返回与s1相同的引用。另一方面，如果首先创建s2，则该引用将存储到池中。在JDK 7中解决的重要RFE中找到。
在JDK 7中，国际化字符串不再分配在Java堆的永久代中，而是与应用程序创建的其他对象一起分配在Java堆的主要部分（称为年轻代和老年代）中。这种变化将导致更多的数据驻留在主要的Java堆中，较少的数据驻留在永久代中，因此可能需要调整堆大小。大多数应用程序由于此更改而在堆使用方面只会看到相对较小的差异，但是加载许多类或大量使用String.intern()方法的较大应用程序将看到更显着的差异。
不确定这是否是错误以及来自哪个版本... JLS 3.10.5说明：
明确地合并计算字符串的结果是与具有相同内容的任何预先存在的文字字符串相同的字符串。
因此问题是如何解释"预先存在"，是编译时还是执行时："Goodmorning"是否预先存在？
我更喜欢在7之前实现的方式...
class Test {
public static void main(String... args) {
String s1 = "Good";
s1 = s1 + "morning";
System.out.println(s1 == s1.intern()); // Prints true for jdk7, false - for jdk6.
}
}
==用于比较引用。intern方法确保具有相同值的字符串具有相同的引用。
String.intern方法的javadoc解释如下：
public String intern()
返回字符串对象的规范表示。
由String类私有地维护一个最初为空的字符串池。
当调用intern方法时，如果池已经包含与此String对象相等（根据equals(Object)方法确定）的字符串，则返回池中的字符串。否则，将此String对象添加到池中，并返回对此String对象的引用。
因此，对于任何两个字符串s和t，当且仅当s.equals(t)为true时，s.intern() == t.intern()为true。
所有文字字符串和字符串值常量表达式都会被缓存。Java语言规范第3.10.5节定义了字符串字面量。
返回：具有与此字符串相同内容但保证来自唯一字符串池的字符串。==比较的是引用，而且我已经将它们设置为相同。但是第一个程序呢？s1和s2不是都有相同的引用吗？或者第二个程序呢，当我写System.out.println(s1.intern());时，现在两者都有相同的引用，为什么？ - Mohammad Faisalclass Test{ public static void main(String... args){ String s1="hi"; String s2="hi"; if(s1==s2){ System.out.println("equal");//and it works } } }
现在这些字符串（s1和s2）怎么可能相等呢？ - Mohammad FaisalString s1="Good";时，在常量池中创建了一个String类型的对象。当我说s1=s1+"morning";时，另一个String对象被创建为Goodmorning，并将其引用分配给s1。现在，当我说String s2="Goodmorning";时，它会检查常量池中是否有Goodmorning？如果找到，则将先前的Goodmorning的引用分配给s2，这意味着s1==s2，但在第一个程序中它不起作用，在第二个程序中它起作用。为什么？ - Mohammad FaisalString s1="Good"; 在常量池中创建了一个String对象"Good"。
s1=s1+"morning"; 在常量池中创建了另一个String对象"morning"，但是这一次JVM实际上执行了：s1=new StringBuffer().append(s1).append("morning").toString();。
现在由于new运算符在堆中创建一个对象，因此s1的引用指向堆而不是常量池，而String s2="Goodmorning";在常量池中创建了一个String对象"Goodmorning"，其引用存储在s2中。
因此，if(s1==s2)条件为false。
那么在jdk7中会发生什么呢？
第一个案例：
在第一个代码片段中，您实际上将三个字符串添加到字符串池中。
1. s1 = "Good"
2. s1 = "Goodmorning" (连接后)
3. s2 = "Goodmorning"
执行 if(s1==s2) 时，对象相同但引用不同，因此为 false。
第二个案例：
在这种情况下，您使用了 s1.intern()，这意味着，如果池中已经包含与该 String 对象相等的字符串（由 equals(Object) 方法确定），则返回池中的字符串。否则，将该 String 对象添加到池中，并返回对该 String 对象的引用。
s1 == s2返回false，因为intern()显然在池中存储了一个不同的实例/引用（相同的字符）。 - user85421s1.equals(s2)。使用 == 与 String 对象比较的是对象引用本身。if 语句中没有错误地写成了 s1==s1 吗？或者在 if 之前写成了 s1=s2？ - Datajamclass Test{
public static void main(String... args){
String s1="hi";
String s2="hi";
if(s1==s2){
System.out.println("equal");//and it works
}
}
} - Mohammad Faisal.equals()，但这不是问题的重点。由于String对象是不可变的，在内存中对同一组字符的不同引用可能会指向不同的实例。关于这种情况何时发生，这取决于JVM优化，因此没有确切的定义。该问题指出了Java 6和Java 7之间的实现变化，并且想知道为什么会有这种变化。 - dimo414主要有四种方法来比较字符串：
==，而应该使用 equals()，因为您正在比较对象而不是引用：string1.equals(string2);
class Test {
public static void main(String... args) {
String s1 = "Good";
s1 = s1 + "morning";
System.out.println(s1 == s1.intern()); // Prints true for jdk7, false - for jdk6.
}
}
class Test {
public static void main(String... args) {
String s = "GoodMorning";
String s1 = "Good";
s1 = s1 + "morning";
System.out.println(s1 == s1.intern()); // Prints false for both jdk7 and jdk6.
}
}
原因是 ' ldc #N '（从常量池加载字符串）和 String.intern() 都会在 Hotspot JVM 中使用 StringTable。详情请参考我撰写的一篇英文文章：http://aprilsoft.cn/blog/post/307.html
s == s1.intern()而不是s1 == s1.intern()吗？ - t0r0X
s1 = s1.intern()或者是if (s1.intern() == s2)吗？仅仅调用intern()不应该改变s1。 - user85421