1. 从对象比较的困境说起

第一次用Java写业务逻辑时，我遇到过这样一个场景：需要判断用户提交的表单数据是否已存在于系统缓存中。当时直接用了==进行比较，结果明明内容相同的对象却被判定为"不相同"。这个坑让我花了整个下午调试，最终才明白Java中对象比较的三种方式各有其适用场景。

在Java的世界里，==、equals()和hashCode()构成了对象识别的三叉戟。新手容易混淆它们的关系，而面试官又特别爱问这类问题。今天我们就来彻底搞懂它们的区别与联系，以及如何正确实现这两个方法。

2. 操作符==的本质解析

2.1 基本类型比较的直白逻辑

当比较两个基本类型（int、char等）时，==的行为非常直观：

int a = 5; int b = 5; System.out.println(a == b); // true

这里==直接比较的是变量存储的数值本身。对于基本类型，它永远比较的是值是否相等。

2.2 引用类型比较的隐藏规则

但当操作对象是引用类型时，==的行为就变了：

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

这是因为==此时比较的是对象的内存地址，而非对象内容。即使两个String对象包含相同的字符序列，只要它们是不同的内存对象，==就会返回false。

关键理解：==在引用类型比较中检查的是"身份同一性"(identity)，而非"值相等性"(equality)

2.3 字符串常量池的特殊情况

Java对字符串有个优化机制：字符串常量池。这会导致一些看似矛盾的现象：

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

这里结果为true是因为字面量赋值会优先从常量池获取对象，a和b实际指向同一个内存地址。但用new创建字符串对象时就会强制创建新实例。

3. equals方法的契约与实现

3.1 Object类中的原始定义

所有Java类都继承自Object，其equals方法默认实现是：

public boolean equals(Object obj) { return (this == obj); }

可以看到，Object的默认实现其实就是==比较。这显然不能满足我们的实际需求，所以需要重写。

3.2 正确重写equals的五个原则

根据Java规范，重写equals必须满足：

1. 自反性：x.equals(x)必须为true
2. 对称性：x.equals(y)与y.equals(x)结果必须一致
3. 传递性：若x.equals(y)且y.equals(z)，则x.equals(z)
4. 一致性：多次调用结果不变（前提是对象未修改）
5. 非空性：x.equals(null)必须为false

3.3 标准实现模板

一个健壮的equals实现通常包含以下步骤：

@Override public boolean equals(Object o) { // 1. 检查是否同一对象 if (this == o) return true; // 2. 检查类型和null if (o == null || getClass() != o.getClass()) return false; // 3. 类型转换 MyClass obj = (MyClass) o; // 4. 逐个字段比较 return field1 == obj.field1 && Objects.equals(field2, obj.field2) && Arrays.equals(arrayField, obj.arrayField); }

3.4 典型陷阱与规避方法

陷阱1：违反对称性

// 错误示范 class Color { String name; public boolean equals(Object o) { if (!(o instanceof String)) return false; return name.equalsIgnoreCase((String)o); } }

这个实现允许Color与String比较，但String的equals不会处理Color类型，破坏了对称性。

陷阱2：忽略null检查

// 危险代码 public boolean equals(Object o) { MyClass obj = (MyClass) o; // 可能抛出NullPointerException return this.field.equals(obj.field); }

解决方案：始终优先使用Objects.equals()进行安全比较：

return Objects.equals(this.field, obj.field);

4. hashCode的契约与实现

4.1 哈希码的基本要求

hashCode()方法必须遵守：

1. 一致性：同一对象多次调用应返回相同值（前提是equals比较的信息未变）
2. 等价性：若x.equals(y)，则x.hashCode()必须等于y.hashCode()
3. 非等价对象的哈希码可以相同（哈希冲突），但应尽量减少

4.2 为什么需要hashCode？

哈希码主要服务于基于哈希表的集合类（HashMap、HashSet等）。这些集合通过哈希码快速定位元素，再将equals作为最终判据。没有正确实现hashCode会导致：

Set<Student> set = new HashSet<>(); set.add(new Student("101", "Alice")); System.out.println(set.contains(new Student("101", "Alice"))); // 可能返回false

4.3 现代Java的实现方案

Java 7以后推荐使用Objects.hash()：

@Override public int hashCode() { return Objects.hash(field1, field2, arrayField); }

对于数组字段，应使用Arrays.hashCode()：

@Override public int hashCode() { int result = Objects.hash(field1, field2); result = 31 * result + Arrays.hashCode(arrayField); return result; }

4.4 哈希码优化技巧

1. 质数乘法：使用31作为乘数（31是奇质数，且JVM可以优化为移位操作）
2. 延迟计算：对于不可变对象，可以缓存哈希值
3. 选择性包含：只包含equals中使用的关键字段

5. equals与hashCode的协同关系

5.1 违反契约的后果

如果只重写equals而不重写hashCode：

Map<Student, Grade> map = new HashMap<>(); map.put(new Student("101"), new Grade("A")); Grade g = map.get(new Student("101")); // 可能返回null

这是因为两个逻辑相等的对象产生了不同的哈希码，导致HashMap在错误的哈希桶中查找。

5.2 自动化工具的正确使用

现代IDE可以生成equals和hashCode方法，但需要注意：

1. 确保选择相同的字段集合
2. 对于数组字段要特殊处理
3. 继承体系下要谨慎处理父类字段

5.3 不可变对象的最佳实践

对于不可变对象（如String、Integer）：

• 可以缓存哈希值
• 字段比较可以直接使用==（因为值不可变）

public final class ImmutablePoint { private final int x; private final int y; private int hashCode; // 缓存 @Override public int hashCode() { if (hashCode == 0) { hashCode = 31 * x + y; } return hashCode; } }

6. 三种比较方式的对比总结

7. 实际开发中的经验之谈

1. Lombok的取舍：@EqualsAndHashCode注解方便但可能隐藏问题，复杂对象建议手动实现
2. 继承的处理：子类重写equals时，通常要先调用super.equals()
3. 性能考量：对于频繁比较的对象，可考虑缓存比较结果
4. 测试验证：使用单元测试验证equals和hashCode的契约

@Test void testEqualsContract() { MyClass a = new MyClass(...); MyClass b = new MyClass(...); // 与a字段相同 MyClass c = new MyClass(...); // 与a字段相同 // 自反性 assertTrue(a.equals(a)); // 对称性 assertEquals(a.equals(b), b.equals(a)); // 传递性 if (a.equals(b) && b.equals(c)) { assertTrue(a.equals(c)); } // 一致性 assertEquals(a.equals(b), a.equals(b)); // 非空性 assertFalse(a.equals(null)); // hashCode一致性 assertEquals(a.equals(b), a.hashCode() == b.hashCode()); }

在大型项目中，我曾经遇到过因为hashCode实现不当导致的性能问题：某个包含10万元素的HashSet的查询性能比预期慢了100倍。最终发现是hashCode只返回了常量值，导致所有元素都堆积在同一个哈希桶中。这个教训让我深刻理解了"好的hashCode应该产生均匀分布"的重要性。