Java 中的 == 与 equals()：不要再掉进“字符串相等”的陷阱！——你不知道的 Java（3）

本文链接：https://blog.youkuaiyun.com/qq_45685275/article/details/146804736

大家好！今天我们来聊聊 Java 中一对非常基础但又极易混淆的概念：== 运算符和 equals() 方法。很多开发者，包括一些有经验的，可能都在某个不经意的角落被它们绊倒过。不信？来看个例子：

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = "he" + "llo"; // 编译期优化

System.out.println(s1 == s2);  // 输出 ?
System.out.println(s1 == s3);  // 输出 ?
System.out.println(s1 == s4);  // 输出 ?
System.out.println(s1.equals(s3)); // 输出 ?

如果你能不假思索且完全正确地说出所有输出（true, false, true, true），那么恭喜你，基础非常扎实！但如果你有任何一丝犹豫，或者对 s1 == s4 为 true 感到惊讶，那么这篇文章就是为你准备的。这个小小的字符串比较，恰恰暴露了我们理解 == 和 equals() 可能存在的盲区。

让我们借此机会，彻底搞懂这两个家伙的底层逻辑和使用场景。

一、`==` 运算符：比较的是“地址”还是“值”？

== 运算符的行为取决于它操作的数据类型：

基本数据类型 (Primitives):
对于 Java 的八种基本数据类型（byte, short, int, long, float, double, char, boolean），== 比较的是它们存储的字面值 (value)。

int a = 10;
int b = 10;
double x = 3.14;
double y = 3.14;
boolean flag1 = true;
boolean flag2 = true;

System.out.println(a == b);      // true (值相等)
System.out.println(x == y);      // true (值相等)
System.out.println(flag1 == flag2); // true (值相等)

这部分比较直观，符合我们的日常逻辑。

引用数据类型 (Reference Types / Objects):
对于类、接口、数组等引用类型，== 比较的是对象的内存地址 (memory address)，也就是判断两个引用变量是否指向堆内存中的同一个对象实例。

// 自定义一个简单的 Person 类
class Person {
    String name;
    Person(String name) { this.name = name; }
}

Person p1 = new Person("Alice");
Person p2 = new Person("Alice");
Person p3 = p1; // p3 指向 p1 所指向的对象

System.out.println(p1 == p2); // false (p1 和 p2 是两个不同的对象实例，内存地址不同)
System.out.println(p1 == p3); // true (p1 和 p3 指向同一个对象实例)

关键点： new 关键字每次都会在堆内存中创建一个新的对象实例，即使它们的内容看起来完全一样。== 检查的是“身份”是否相同，而非“内容”是否相同。

二、`equals()` 方法：从 `Object` 类说起

equals() 是一个定义在 java.lang.Object 类中的方法。这意味着 Java 中所有的类（除了基本类型）都天然地继承了这个方法。

Object 类中 equals() 的默认实现:
如果你查看 Object 类的源码，你会发现它的 equals() 方法实现极其简单：
```
public boolean equals(Object obj) {
    return (this == obj);
}
```
划重点： Object 类默认的 equals() 实现，就是直接使用 == 运算符！这意味着，如果一个类没有重写 (override) equals() 方法，那么调用它的 equals() 方法就等同于使用 ==，比较的仍然是对象的内存地址。
```
Person p1 = new Person("Alice");
Person p2 = new Person("Alice");

// 假设 Person 类没有重写 equals() 方法
System.out.println(p1.equals(p2)); // false (因为底层是 p1 == p2)
```
重写 equals() 方法的目的与约定:
Object.equals() 的默认行为通常不是我们想要的。我们往往希望比较两个对象在逻辑上是否相等，即它们的内容或状态是否相同，而不是它们是否是内存中的同一个实例。

因此，许多 Java核心类（如 String, Integer, Date 等）都重写了 equals() 方法，以实现基于内容的比较。

重写 equals() 时必须遵守的通用约定 (Contract):
为了保证 equals() 方法在各种情况下（尤其是与集合框架配合时）都能正确工作，Java 规范要求重写时必须满足以下特性：
- 自反性 (Reflexive): 对于任何非空引用 x，x.equals(x) 必须返回 true。
- 对称性 (Symmetric): 对于任何非空引用 x 和 y，x.equals(y) 返回 true 当且仅当 y.equals(x) 返回 true。
- 传递性 (Transitive): 对于任何非空引用 x, y, z，如果 x.equals(y) 返回 true 且 y.equals(z) 返回 true，那么 x.equals(z) 必须返回 true。
- 一致性 (Consistent): 对于任何非空引用 x 和 y，只要 equals 比较操作所用的信息没有被修改，则多次调用 x.equals(y) 要么一致地返回 true，要么一致地返回 false。
- 非空性 (Non-nullity): 对于任何非空引用 x，x.equals(null) 必须返回 false。
典型的 equals() 实现步骤：
```
@Override
public boolean equals(Object obj) {
    // 1. 地址相同，必然相等 (优化，并满足自反性)
    if (this == obj) {
        return true;
    }
    // 2. 类型检查 (null 检查 和 是否同类或兼容类)
    if (obj == null || getClass() != obj.getClass()) { // 或者使用 instanceof，但要注意对称性问题
        return false;
    }
    // 3. 强制类型转换
    Person other = (Person) obj;
    // 4. 比较关键属性 (根据业务逻辑定义何为“相等”)
    // 注意：属性是基本类型用 ==，是引用类型用 Objects.equals() 或递归调用 equals()
    return java.util.Objects.equals(name, other.name);
    // 如果有其他属性，如 age (int)，则：
    // return this.age == other.age && java.util.Objects.equals(name, other.name);
}
```
注意：java.util.Objects.equals(a, b) 是一个推荐使用的工具方法，它能很好地处理 a 或 b 可能为 null 的情况。

三、`equals()` 与 `hashCode()` 的“孪生”关系

这是一个非常重要的知识点，经常被忽视。当你重写 equals() 方法时，几乎总是需要同时重写 hashCode() 方法。

hashCode() 方法的约定:

在 Java 应用程序执行期间，在对同一个对象多次调用 hashCode() 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。
如果两个对象根据 equals(Object) 方法比较是相等的，那么调用这两个对象中任意一个对象的 hashCode() 方法都必须产生相同的整数结果。
如果两个对象根据 equals(java.lang.Object) 方法比较是不相等的，那么调用这两个对象中任意一个对象的 hashCode() 方法，不要求必须产生不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表（例如 HashMap, HashSet）的性能。

为什么必须一起重写？

核心原因在于哈希集合（如 HashMap, HashSet）的工作原理。这些集合使用 hashCode() 来快速定位对象可能存储的位置（桶/bucket），然后（如果需要）再使用 equals() 来精确比较该位置上的对象是否真的是你要找的那个。

如果只重写 equals() 而不重写 hashCode()，会导致两个逻辑相等（equals() 返回 true）的对象可能拥有不同的哈希码。当把这样的对象放入 HashSet 时，HashSet 会认为它们是不同的对象（因为哈希码不同，可能放在了不同的桶里），从而允许你存入两个“内容相同”的对象，违反了 Set 的唯一性原则。
同样，在 HashMap 中，如果你用一个对象作为 key 存入数据，然后用另一个 equals() 相等但 hashCode() 不同的对象去查找，HashMap 会因为哈希码不同而找不到对应的条目，即使按逻辑它们是“同一个” key。

简单的 hashCode() 实现:
通常，hashCode() 的计算应该基于 equals() 方法中用来比较的那些字段。

@Override
public int hashCode() {
    // 使用 Objects.hash() 工具方法可以方便地计算哈希码
    // 将用于 equals 比较的字段传入
    return java.util.Objects.hash(name);
    // 如果有其他属性，如 age (int):
    // return java.util.Objects.hash(name, age);
}

四、回到开头的“陷阱”：解密 String 的比较

现在我们用学到的知识来分析开头的例子：

String s1 = "hello"; // 字符串字面量，放入字符串常量池 (String Pool)
String s2 = "hello"; // 同样指向常量池中的 "hello"
String s3 = new String("hello"); // 在堆内存中创建一个新的 String 对象
String s4 = "he" + "llo"; // 编译期常量折叠，结果也是 "hello"，指向常量池

s1 == s2 (true): s1 和 s2 都指向字符串常量池中同一个 "hello" 对象。内存地址相同。
s1 == s3 (false): s1 指向常量池，s3 通过 new 在堆上创建了一个新对象。内存地址不同。
s1 == s4 (true): "he" + "llo" 在编译期间被优化为 "hello" 字面量，所以 s4 也指向常量池中的 "hello" 对象，与 s1 地址相同。
s1.equals(s3) (true): String 类重写了 equals() 方法，比较的是字符串的内容。s1 和 s3 的内容都是 “hello”，所以逻辑上相等。

这个例子完美展示了：

对于引用类型，== 比较地址。
String 的特殊性在于字符串常量池和编译期优化，有时会导致 == 也能比较内容（但依赖这个特性是危险的！）。
比较字符串内容，永远应该使用 equals() 方法。

Integer 等包装类的陷阱:
类似地，Integer 等包装类也有缓存机制（默认缓存 -128 到 127 之间的值）。

Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;

System.out.println(i1 == i2); // true (使用了缓存，指向同一个对象)
System.out.println(i3 == i4); // false (超出缓存范围，new 了新对象)
System.out.println(i3.equals(i4)); // true (Integer 重写了 equals，比较值)

所以，比较包装类对象的值时，也应该总是使用 equals()。

五、总结与最佳实践

好了，让我们来总结一下 == 和 equals() 的核心区别和使用场景：

== 运算符:
- 基本类型: 比较值是否相等。
- 引用类型: 比较两个引用变量是否指向堆内存中的同一个对象实例（比较内存地址）。
equals() 方法:
- 源自 Object 类，默认实现是 ==。
- 设计意图是比较两个对象在逻辑上是否相等（比较内容/状态）。
- 核心类库（如 String, Integer, Date 等）已经重写了 equals() 以实现内容比较。
- 自定义类如果需要比较内容，必须重写 equals()，并严格遵守其约定。
hashCode() 方法:
- 与 equals() 紧密相关。
- 重写 equals() 时，必须同时重写 hashCode()，并保证 equals() 相等的对象哈希码也相等。
- 这对于 HashMap, HashSet 等哈希集合的正确工作至关重要。

最佳实践建议：

比较基本类型值： 始终使用 ==。
比较对象引用是否指向同一个实例： 使用 ==。
比较对象内容/逻辑状态是否相等：
- 对于 String, 包装类 (Integer, Double 等), File, Date 等已知重写了 equals() 的类，始终使用 equals()。
- 对于自定义类，确保你已经（或需要）正确地重写了 equals() 和 hashCode()，然后使用 equals() 进行比较。
比较字符串内容： 永远使用 equals()，避免依赖字符串常量池的细节。
比较包装类对象的值： 永远使用 equals()，避免依赖缓存机制。
在 equals() 实现中： 使用 Objects.equals() 处理可能的 null 值。
在 hashCode() 实现中： 使用 Objects.hash() 简化计算。