Java String 相等性判断：深入解析与面试攻略

这是一道经典的 Java String 面试题，旨在考察开发者对 String 对象在内存中的创建方式、String Constant Pool、== 操作符的行为以及编译器优化（特别是常量折叠）的理解。

问题描述

请分析下面这段 Java 代码的输出结果：

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Main {
    public static void main(String[] args) {
        String a = "xiaoming2";
        final String b = "xiaoming";
        String d = "xiaoming";
        String c = b + 2;
        String e = d + 2;
        System.out.println(a == c);
        System.out.println(a == e);
    }
}

预期输出

1
2

true
false

面试应对策略与详细解析

在面试中遇到这类问题时，一个好的回答应该结构清晰，层层递进，不仅给出答案，更能深入解释背后的原理。

1. 确认问题并给出输出

首先，清晰地向面试官确认理解了问题，并直接给出代码的运行结果。

面试官，您好。这段代码的输出结果是：

1 2	true false

2. 解释原因：核心概念

接下来，详细阐述导致这一结果的关键 Java 概念。这是回答中最核心的部分。

• String Constant Pool (字符串常量池): 这是 Java 堆内存中的一块特殊区域，用于存储字符串字面量。当使用字面量（如 "abc"）创建 String 对象时，JVM 会优先在常量池中查找是否有内容相等的字符串。如果找到，则直接返回该对象的引用；如果找不到，则在常量池中创建新的 String 对象并返回引用。
• == 操作符: 对于对象类型，== 比较的是两个引用变量是否指向内存中的同一个对象（即比较对象的内存地址）。
• equals() 方法: String 类重写了 Object 类的 equals() 方法，用于比较两个字符串对象的内容是否相等。在实际开发中，比较字符串内容时务必使用 equals()。
• String Concatenation (+): 字符串拼接操作。在 Java 中，使用 + 进行字符串拼接时，如果操作数不是编译时常量，通常会在运行时通过 StringBuilder（或 StringBuffer）来实现，生成新的 String 对象。
• Constant Folding (常量折叠): 这是 Java 编译器的一项重要优化技术。如果一个表达式的结果在编译时就可以完全确定（即表达式只包含字面量或被 final 修饰且初始化为常量的变量），编译器会在编译阶段直接计算出结果，而不是等到运行时。对于字符串拼接，如果参与拼接的都是编译时常量，编译器会直接将拼接结果放入常量池。

3. 结合代码分步分析

将上述概念应用于具体的代码行，解释每个 String 变量是如何创建的，以及它们引用的是内存中的哪个位置。

• String a = "xiaoming2";: a 引用常量池中的字符串字面量 "xiaoming2"。
• final String b = "xiaoming";: b 引用常量池中的字符串字面量 "xiaoming"。由于 b 被 final 修饰且直接赋值为常量，b 的值在编译时是确定的常量。
• String d = "xiaoming";: d 引用常量池中的字符串字面量 "xiaoming"。它与 b 引用的是同一个对象。但 d 不是 final 的。
• String c = b + 2;: 这是字符串拼接。因为 b 是一个 final 变量且其值是编译时常量，编译器会对其执行 常量折叠。它在编译时就将 b + 2 计算为 "xiaoming" + "2"，结果是 "xiaoming2"。这行代码编译后实际上等同于 String c = "xiaoming2";。因此，c 也引用常量池中 "xiaoming2" 这个对象，与 a 引用的是同一个对象。
• String e = d + 2;: 这也是字符串拼接。但 d 不是 final 变量。即使其值在此处看来是常量，编译器无法保证非 final 变量在运行时不变。因此，编译器 不会 对 d + 2 执行常量折叠。这个拼接操作会在运行时通过 StringBuilder 完成，生成一个新的 "xiaoming2" 字符串对象，这个新对象位于 堆内存 中，而不是常量池。e 引用这个新的堆对象。

4. 解释 == 比较结果

基于前面的分析，解释 == 比较的结果。

• System.out.println(a == c);

  • a 引用常量池中的 "xiaoming2" 对象。
  • c (经过常量折叠) 引用常量池中的 "xiaoming2" 对象。
  • 因为 a 和 c 指向内存中的同一个对象，所以 a == c 的结果是 true。

• System.out.println(a == e);

  • a 引用常量池中的 "xiaoming2" 对象。
  • e 引用运行时在堆中新创建的 "xiaoming2" 对象。
  • 因为 a 和 e 指向内存中的不同对象，所以 a == e 的结果是 false。

5. 强调最佳实践

最后，简要说明在实际开发中比较字符串的最佳实践，体现良好的编程习惯。

在实际开发中，我们通常只关心字符串的内容是否相等，而不是它们是否是内存中的同一个对象。因此，比较字符串内容时，应该始终使用 equals() 方法，例如 a.equals(e)。这会返回 true，因为它们的内容确实相同。

相似的 String 面试案例

这类问题有很多变体，理解核心概念后，可以触类旁通。以下是一些常见的相似案例：

案例 1: new String() 创建的对象

Java

1
2
3
4
5
6
7
8
9

String s1 = "hello";        // 常量池
String s2 = "hello";        // 常量池 (与 s1 同一个)
String s3 = new String("hello"); // 堆中新对象 (内容是 "hello")
String s4 = new String("hello"); // 堆中另一个新对象 (内容是 "hello")

System.out.println(s1 == s2);     // true (同是常量池对象)
System.out.println(s1 == s3);     // false (常量池 vs 堆对象)
System.out.println(s3 == s4);     // false (堆中不同对象)
System.out.println(s1.equals(s3)); // true (内容相同)

案例 2: intern() 方法的使用

intern() 方法会检查字符串对象的内容是否已存在于常量池。如果存在，则返回常量池中该对象的引用；如果不存在，则将该对象的内容放入常量池，并返回常量池中的引用。

Java

1
2
3
4
5
6
7
8

String s5 = new String("world").intern(); // 在堆中创建 "world"，然后将 "world" 放入/查找常量池，并返回常量池引用
String s6 = "world";                      // 常量池

System.out.println(s5 == s6); // true (都引用常量池中的 "world")

String s7 = new String("java"); // 堆中新对象
System.out.println(s7 == "java"); // false (堆 vs 常量池)
System.out.println(s7.intern() == "java"); // true (intern() 返回常量池引用，与 "java" 字面量相同)

案例 3: 字面量拼接的常量折叠

如果拼接操作的左右两边都是字符串字面量，编译器会直接进行常量折叠。

Java

1
2
3
4
5
6
7
8

String partA = "abc";
String partB = "def";
String s8 = "abcdef";      // 常量池
String s9 = "abc" + "def"; // 编译器直接计算为 "abcdef"，放入常量池 (与 s8 同一个)
String s10 = partA + partB; // partA, partB 不是 final，运行时拼接，生成堆对象

System.out.println(s8 == s9);  // true (都指向常量池的 "abcdef")
System.out.println(s8 == s10); // false (常量池 vs 堆对象)

详细解析

为了理解为什么 s7 == s9 的结果是 false，我们需要再次强调 常量折叠 这个概念，以及它在哪些情况下会发生。

1. String s7 = "abcdef";

   • 这是一个简单的字符串字面量。
   • JVM 会在 字符串常量池 中查找是否存在内容为 "abcdef" 的字符串。
   • 如果不存在，则在常量池中创建一个新的 "abcdef" 对象。
   • 如果存在（或者刚刚创建了），则 s7 变量将引用 常量池 中的这个 "abcdef" 对象。

2. String s8 = "abc" + "def";

   • 这是一个字符串拼接操作，但它的特别之处在于，参与拼接的 "abc" 和 "def" 都直接是 字符串字面量。
   • 关键点： Java 编译器有一项优化叫做 常量折叠 (Constant Folding)。当编译器发现一个表达式完全由编译时常量组成时，它会在编译阶段就计算出表达式的结果。字符串字面量（如 "abc" 和 "def"）就是编译时常量。
   • 因此，对于 "abc" + "def" 这个表达式，编译器在编译时就直接将其计算为 "abcdef"。
   • 所以，String s8 = "abc" + "def"; 在编译后的字节码中，实际上就等同于 String s8 = "abcdef";。
   • 这意味着 s8 也引用 字符串常量池 中的 "abcdef" 对象。
   • 结论： s7 和 s8 都引用常量池中的同一个 "abcdef" 对象。因此，s7 == s8 的结果是 true。

3. String s9 = part1 + part2;

   • 这也是一个字符串拼接操作，但参与拼接的是变量 part1 和 part2。
   • part1 引用常量池中的 "abc"。
   • part2 引用常量池中的 "def"。
   • 关键点： 尽管在当前代码的上下文里，part1 和 part2 似乎看起来是“不变”的，但它们并没有被 final 关键字修饰。对于编译器来说，它 无法 确定 part1 和 part2 的值在程序运行时是否会改变。
   • 由于表达式 part1 + part2 包含了 非编译时常量（因为它使用了非 final 变量），编译器 不会 对其进行常量折叠。
   • 这个拼接操作会在 运行时 执行。在运行时，Java 通常使用 StringBuilder（或在旧版本中使用 StringBuffer）来执行字符串拼接。
   • 运行时会大概执行类似这样的逻辑：new StringBuilder().append(part1).append(part2).toString();
   • StringBuilder 的 toString() 方法会创建一个 全新的 String 对象，这个新对象位于 堆内存 中（而不是常量池），其内容是 "abcdef"。
   • s9 变量将引用这个 新创建的、位于堆内存中 的 "abcdef" 对象。
   • 结论： s9 引用的是一个运行时在堆中创建的新对象，而 s7 (和 s8) 引用的是常量池中的对象。它们是内存中的两个不同的对象。因此，s7 == s9 的结果是 false。

总结案例 3 的核心差异

案例 3 的关键在于区分两种拼接方式：

• "字面量A" + "字面量B"：编译器能确定结果，执行常量折叠，结果是常量池中的 "字面量A字面量B" 对象。
• 变量A + 变量B (变量 A 或 B 不是 final 或不是编译时常量)：编译器不能确定结果，留待运行时通过 StringBuilder 拼接，结果是在堆中创建的 新 对象。

这就是为什么 s8 (字面量拼接) 与 s7 (直接字面量) 指向同一个常量池对象，而 s9 (变量拼接) 指向堆中新对象的原因。

案例 4: final 变量拼接的常量折叠 (与原题核心原理相同)

Java

1
2
3
4
5
6

final String FINAL_PART_1 = "compile";
final String FINAL_PART_2 = "time";
String s11 = "compilertime"; // 常量池
String s12 = FINAL_PART_1 + FINAL_PART_2; // final 变量拼接，编译器常量折叠为 "compilertime"，放入常量池 (与 s11 同一个)

System.out.println(s11 == s12); // true (都指向常量池的 "compilertime")

通过深入理解 String Constant Pool、== 与 equals() 的区别，以及编译器对 final 常量进行的优化（常量折叠），可以清晰地分析这类 String 相等性判断问题。记住：对于字符串内容的比较，永远优先使用 equals() 方法。