1. 为什么字符串比较会踩坑？

刚学Java那会儿，我最困惑的就是这段代码：

String a = "hello"; String b = new String("hello"); System.out.println(a == b); // false System.out.println(a.equals(b)); // true

明明两个变量内容都是"hello"，为什么==比较的结果不一样？后来在项目里还真因为这个踩过坑——用户登录时，从数据库查出的密码和用户输入的密码用==比较，死活验证不通过。今天我们就彻底搞懂这个经典问题。

关键点在于：==比较的是身份证，equals()比较的是长相。就像双胞胎兄弟，长得再像也是两个独立的人（内存地址不同）。Java中的字符串比较有三大陷阱：

1. 字面量陷阱：直接赋值的字符串会进入字符串常量池
2. new对象陷阱：每次new都会创建新对象
3. 编译优化陷阱：拼接的字符串可能被编译器合并

2. ==和equals的本质区别

2.1 ==操作符的真相

==在Java中是个"直男"，它只关心两件事：

• 对基本类型（int、char等）：直接比较值
• 对引用类型（如String）：比较内存地址

int num1 = 10; int num2 = 10; System.out.println(num1 == num2); // true String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); // false

2.2 equals的智慧

equals()是Object类的方法，默认行为和==一样。但String类重写了这个方法，让它变得"聪明"：

// String类中的equals实现（简化版） public boolean equals(Object anObject) { if (this == anObject) return true; if (anObject instanceof String) { String anotherString = (String)anObject; // 逐个比较字符 for (int i = 0; i < value.length; i++) { if (value[i] != anotherString.value[i]) return false; } return true; } return false; }

实测案例：

String s1 = "Java"; String s2 = "Java"; String s3 = new String("Java"); String s4 = "Ja" + "va"; System.out.println(s1.equals(s2)); // true System.out.println(s1.equals(s3)); // true System.out.println(s1 == s4); // true（编译器优化）

3. 字符串常量池的魔法

3.1 什么是字符串常量池

JVM有个特殊区域叫字符串常量池（String Pool），相当于一个字符串缓存中心。当使用字面量创建字符串时：

1. JVM先检查池中是否已有相同内容字符串
2. 如果存在，直接返回引用
3. 如果不存在，创建新字符串并放入池中

String a = "hello"; // 第一次创建，放入池中 String b = "hello"; // 直接使用池中的引用 System.out.println(a == b); // true

3.2 new String()的特殊性

使用new创建字符串时，会强制在堆内存新建对象：

String c = new String("hello"); // 创建两个对象： // 1. 先在常量池创建"hello"（如果不存在） // 2. 再在堆中创建新对象

内存结构示意图：

栈内存 堆内存 字符串常量池 a ──────────→ "hello" ←─────── b c ──────────→ [new String] 指向常量池的"hello"

3.3 intern()方法的神奇作用

手动将字符串放入常量池的方法：

String s1 = new String("hello").intern(); String s2 = "hello"; System.out.println(s1 == s2); // true

intern()的工作流程：

1. 检查常量池是否有相同内容字符串
2. 有则返回池中引用，没有则添加当前字符串到池中

4. 实战中的避坑指南

4.1 推荐写法

1. 常量比较：始终使用equals()

userInput.equals("quit") // 正确 "quit".equals(userInput) // 更安全（防null）

2. 忽略大小写比较：

"Hello".equalsIgnoreCase("hello") // true

3. 使用Objects.equals()（Java7+）：

Objects.equals(null, "hello") // false（不会抛NPE）

4.2 性能优化技巧

1. 避免重复创建字符串：

// 不好的写法 for (int i = 0; i < 1000; i++) { String s = new String("constant"); // 创建1000个对象 } // 好的写法 String constant = "constant"; for (int i = 0; i < 1000; i++) { String s = constant; // 复用同一个引用 }

2. 字符串拼接优化：

// 编译前 String s = "a" + "b" + "c"; // 编译后（编译器优化） String s = "abc";

但如果是变量拼接：

String a = "a"; String b = a + "b"; // 实际会new StringBuilder

4.3 常见面试题解析

问题1：下面代码创建了几个对象？

String s = new String("hello");

答案：1或2个。如果常量池没有"hello"，先创建常量池对象，再创建堆对象；如果已有，只创建堆对象。

问题2：以下输出结果是什么？

String s1 = "hello"; String s2 = "he" + "llo"; System.out.println(s1 == s2);

答案：true。编译器会优化为"hello"，从常量池复用。

问题3：如何证明字符串是不可变的？

String s = "hello"; s.toUpperCase(); // 返回新对象，原字符串不变 System.out.println(s); // 仍输出"hello"

5. 进阶：字符串比较的底层实现

5.1 JDK中的优化

现代JDK（如Java 17）中，String的equals()实现更加智能：

// Java 17的优化实现 public boolean equals(Object anObject) { if (this == anObject) return true; return (anObject instanceof String aString) && (!COMPACT_STRINGS || this.coder == aString.coder) && StringLatin1.equals(value, aString.value); }

关键优化点：

1. 先比较地址（快速路径）
2. 再比较编码格式（Latin1/UTF16）
3. 最后比较字节数组

5.2 哈希码缓存机制

String的hashCode()有缓存优化：

private int hash; // 默认为0 public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { hash = h = computeHashCode(); } return h; }

这使得多次调用hashCode()不会重复计算，这也是为什么String常被用作HashMap的key。

6. 特殊场景处理

6.1 空指针安全比较

// 传统写法（可能NPE） if (str.equals("value")) {...} // 安全写法 if ("value".equals(str)) {...} // Java7+推荐 if (Objects.equals(str, "value")) {...}

6.2 排序场景下的比较

String[] names = {"Alice", "Bob", "alice"}; Arrays.sort(names, String.CASE_INSENSITIVE_ORDER); // 排序结果：Alice, alice, Bob

6.3 敏感信息比较

对于密码等敏感信息，建议使用专门方法：

import java.security.MessageDigest; boolean isPasswordCorrect(String input) { return MessageDigest.isEqual( input.getBytes(), storedPassword.getBytes() ); }

7. 最佳实践总结

1. 基础规则：

   • 内容比较：永远用equals()
   • 地址比较：特殊场景才用==

2. 性能敏感场景：

   • 优先使用字面量创建字符串
   • 避免在循环中new String
   • 大文本比较先用length()过滤

3. 代码可读性：

   • 使用Objects.equals()避免null检查
   • 常量放equals()左侧（"literal".equals(var)）

4. 新版本特性：

   • Java 15+的文本块（"""..."""）也遵循常量池规则
   • Record类的字符串比较行为与String一致

记住这个口诀："字面量省内存，new对象必不同，比较内容用equals，地址比较需慎重"。在实际项目中，我见过太多因为字符串比较不当导致的bug，特别是分布式系统中，不同节点生成的字符串即使内容相同，用==比较也会失败。