深入理解：为什么必须同时重写 equals() 和 hashCode() 方法？

2026-02-02 02:31:32 0条评论 1次阅读 0人点赞

作为一名 Java 开发者，我们每天都在和对象打交道。你是否曾经想过，当你把一个自定义对象放入 INLINECODE891e2a72 或 INLINECODE6bbbcb6a 时，Java 虚拟机（JVM）底层究竟发生了什么？为什么有时候我们明明觉得两个对象“内容”是一样的，但集合却把它们当成两个不同的对象？

这篇文章，我们将一起深入探讨 Java 中对象相等性的核心机制：INLINECODE38d9816d 和 INLINECODE20446456 方法。我们将揭开它们背后的契约关系，并彻底弄清楚为什么在重写其中一个时，必须重写另一个。这不仅是一道面试题，更是编写健壮代码的基石。

基础篇：基于哈希的集合是如何工作的？

在 Java 中，像 INLINECODE1aa3d38a、INLINECODEa8ed02d1 和 Hashtable 这样的集合类，它们的底层实现都依赖于哈希表。哈希表的核心优势在于能够提供快速的查找能力——理想情况下的时间复杂度是 O(1)。为了实现这种高效查找，Java 采用了“两步走”的策略来存储和检索对象：

第一步：定位桶

当我们调用 INLINECODE6cb18bf3 或者 INLINECODE5ff21da1 时，JVM 首先会调用 key 对象的 INLINECODEcfd7b519 方法。这个方法返回的一个整数值，被用来计算该对象在内部数组中应该存放的索引位置（我们通常称之为“桶”）。如果两个对象通过 INLINECODE94ed4666 计算出了不同的值，它们肯定会被放在不同的桶里，我们就无需进行后续的比较。

第二步：精确匹配

如果两个（或多个）对象的 INLINECODE75f439b9 返回值相同，它们就会落在同一个桶里。这种情况被称为“哈希冲突”。这时，为了确保唯一性，集合会使用 INLINECODEa6331702 方法在这个桶内进行逐一比较。只有当 INLINECODEfd201efd 方法返回 INLINECODE4923902b 时，集合才认为这两个对象是相同的，从而进行覆盖操作；否则，它们将作为不同的对象共存于链表或红黑树中。

简单总结：INLINECODE31eaeb10 决定了对象去哪里，INLINECODEe25deed1 决定了对象是谁。

核心契约：equals() 与 hashCode() 的铁律

Joshua Bloch 在经典著作《Effective Java》中明确指出：在每个重写了 INLINECODE37b45da6 方法的类中，你也必须重写 INLINECODE567e3b50 方法。

这不仅仅是 Java 规范的要求，更是逻辑自洽的必然。如果不遵守这一原则，所有基于哈希的集合（HashMap, HashSet, Hashtable）都将无法正常工作。根据 java.lang.Object 的通用约定，我们需要遵守以下规则：

一致性：在 Java 应用程序执行期间，只要对象的 INLINECODE7282a1fb 比较操作所用到的信息没有被修改，那么对这同一个对象多次调用 INLINECODEdd14b70d 方法时，它必须始终如一地返回同一个整数。

对等性：如果两个对象根据 INLINECODE828a4c47 方法比较是相等的，那么调用这两个对象中任意一个对象的 INLINECODE7318fc59 方法都必须产生相同的整数结果。

独立性（性能优化）：如果两个对象根据 INLINECODEab2d5ffe 方法比较是不相等的，那么调用这两个对象中任意一个对象的 INLINECODE0a41aae3 方法，不要求必须产生不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同的整数结果可以提高哈希表的性能。

场景实战演练

为了让大家有更直观的感受，让我们定义一个简单的 INLINECODE7f9dd124 类，包含 INLINECODEc986b7a0 和 id 两个属性。我们将通过三种不同的重写组合，来看看程序行为会发生什么戏剧性的变化。

#### 情况 1：完美的实现 —— 同时重写两者

当我们同时正确地重写了 INLINECODEbe947071 和 INLINECODEcc8ba6a7 时，对象在哈希集合中的行为将符合我们的直觉：逻辑相等的对象被视为同一个键。

import java.util.*;
import java.util.Objects;

class Geek {
    String name;
    int id;

    Geek(String name, int id) {
        this.name = name;
        this.id = id;
    }

    // 正确重写 equals：比较逻辑内容
    @Override
    public boolean equals(Object obj) {
        // 1. 检查是否为同一引用
        if (this == obj) return true;
        // 2. 检查是否为 null 或类型不同
        if (obj == null || getClass() != obj.getClass()) return false;
        // 3. 类型转换并比较关键字段
        Geek geek = (Geek) obj;
        return id == geek.id && Objects.equals(name, geek.name);
    }

    // 正确重写 hashCode：基于逻辑内容生成哈希码
    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

public class Main {
    public static void main(String[] args) {
        Geek g1 = new Geek("Ram", 1);
        Geek g2 = new Geek("Ram", 1);

        // 我们要验证的核心问题：g1 和 g2 在 Map 中会被视为同一个键吗？
        Map map = new HashMap();
        map.put(g1, "CSE"); // 放入第一个对象
        map.put(g2, "IT");  // 放入第二个对象（逻辑上与第一个相同）

        // 遍历 Map 看看里面剩下了什么
        for (Geek geek : map.keySet()) {
            System.out.println("存储的对象: " + geek.name + " - 值: " + map.get(geek));
        }
        System.out.println("Map 大小: " + map.size());
    }
}

输出结果：

存储的对象: Ram - 值: IT
Map 大小: 1

深度解析：

在这个场景中，INLINECODE01991b0e 和 INLINECODE11429374 虽然是内存中两个不同的对象（INLINECODEcaa5bb8e 了两次），但它们的 INLINECODE8228a907 和 name 相同。

当我们放入 g1 时，HashMap 计算哈希并存入。
当我们放入 INLINECODE6706f4f6 时，HashMap 发现 INLINECODE731fc16d 与 g1 相同，于是定位到同一个桶。
随后，HashMap 在该桶内调用 INLINECODE83420f1e，结果返回 INLINECODEbb264790。
结论：Java 认为这是同一个键，因此 INLINECODE0828eaa8 的值 "IT" 覆盖了 INLINECODE8662cdab 的值 "CSE"。这完全符合我们的预期。

—

#### 情况 2：逻辑陷阱 —— 仅重写 equals()

这是新手最容易犯的错误之一：我们定义了什么是“相等”，却忘了告诉 Java 如何计算“哈希”。让我们把上面的代码中 hashCode() 方法删掉，看看会发生什么。

import java.util.*;
import java.util.Objects;

class Geek {
    String name;
    int id;

    Geek(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Geek geek = (Geek) obj;
        return id == geek.id && Objects.equals(name, geek.name);
    }
    
    // 注意：这里故意没有重写 hashCode()
}

public class Main {
    public static void main(String[] args) {
        Geek g1 = new Geek("Ram", 1);
        Geek g2 = new Geek("Ram", 1);

        Map map = new HashMap();
        map.put(g1, "CSE");
        map.put(g2, "IT");

        for (Geek geek : map.keySet()) {
            System.out.println("存储的对象: " + geek.name + " - 值: " + map.get(geek));
        }
        System.out.println("Map 大小: " + map.size());
    }
}

输出结果：

存储的对象: Ram - 值: CSE
存储的对象: Ram - 值: IT
Map 大小: 2

深度解析：

为什么 Map 里会有两个条目？

equals() 告诉我们：INLINECODE35b29408 是 INLINECODE5b36e27d，它们在逻辑上是相等的。
hashCode() 却背叛了我们：由于我们没有重写 INLINECODEfcad5671，Java 会调用 INLINECODE5fa461a0 类默认的 INLINECODE3f8bbf76 方法。默认方法通常是将对象的内存地址转换为整数。因为 INLINECODE1ee03a34 和 g2 在堆内存中是两个不同的实体，它们的内存地址不同，导致默认哈希码不同。
后果：HashMap 去查找 INLINECODE97196c82 的哈希桶时，去了一个完全不同的地方（因为哈希码不同）。它根本没有机会去和 INLINECODE9cb6dda6 进行 equals 比较！
结论：Map 认为这是两个完全不相关的键。这破坏了 equals 契约，导致数据逻辑混乱（出现了重复的键）。

—

#### 情况 3：哈希碰撞 —— 仅重写 hashCode()

让我们反过来，只重写 INLINECODE4076393d，让它们都返回相同的值（比如固定的 INLINECODE3627805a），但保留默认的 equals()（比较引用）。

import java.util.*;
import java.util.Objects;

class Geek {
    String name;
    int id;

    Geek(String name, int id) {
        this.name = name;
        this.id = id;
    }

    // 强制所有 id 为 1 的对象都去同一个桶
    @Override
    public int hashCode() {
        return id; 
    }
    
    // 注意：这里没有重写 equals()，使用默认的引用比较
}

public class Main {
    public static void main(String[] args) {
        Geek g1 = new Geek("Ram", 1);
        Geek g2 = new Geek("Ram", 1);

        Map map = new HashMap();
        map.put(g1, "CSE");
        map.put(g2, "IT");

        for (Geek geek : map.keySet()) {
            System.out.println("存储的对象: " + geek.name + " - 值: " + map.get(geek));
        }
        System.out.println("Map 大小: " + map.size());
    }
}

输出结果：

存储的对象: Ram - 值: CSE
存储的对象: Ram - 值: IT
Map 大小: 2

深度解析：

这次虽然它们去了同一个地方，但依然没有合并。

hashCode() 工作正常：INLINECODEc8ab8139 和 INLINECODE13dc5f7a 的哈希码都是 1。HashMap 成功地将它们放入了同一个桶中。
equals() 失效：在这个桶里，HashMap 需要判断是否重复。由于我们没有重写 INLINECODEc5fa86e3，它使用 INLINECODEf1a78482 的默认实现，即 INLINECODEfba36ba5 比较。这意味着它在比较 INLINECODE29d7630f。显然，两个不同的对象引用是不相等的。
后果：HashMap 认为这是哈希冲突，但对象本身不同。于是它在这个桶里把这两个对象串起来（链表或红黑树结构），保留了两个条目。
结论：虽然它们物理位置在同一个桶，但逻辑上被视为不同的键。

进阶技巧与最佳实践

通过上面的演示，我们已经了解了原理。但在实际开发中，如何写出高质量的 INLINECODEc5b547de 和 INLINECODE52cf23bd 呢？这里有一些实战经验分享给你。

#### 1. 使用 IDE 或 Lombok 自动生成

手动编写这两个方法非常枯燥且容易出错（比如漏写某个字段，或者写错 INLINECODE283bb506 检查）。现代 IDE（如 IntelliJ IDEA 或 Eclipse）都提供了一键生成功能（INLINECODE2817a16b）。

如果你使用 Lombok 库，一个 @EqualsAndHashCode 注解就能完美搞定，它还能自动处理调用父类方法的情况，非常优雅。

#### 2. 算法选择：Objects 类 vs IDE 模板

在 Java 7 及以上版本，推荐使用 INLINECODE8eb58e26 类。它提供了 INLINECODE7adac943 和 INLINECODE208460a5 静态方法，不仅代码简洁，而且自动处理了 INLINECODEc6fd7eb2 值的安全性。

错误的哈希算法示例：

// 不要这样做！虽然分布均匀，但质量差且性能低
@Override
public int hashCode() {
    return (int)(Math.random() * 100); // 违反了契约中的“一致性”原则
}

推荐的哈希算法示例：

@Override
public int hashCode() {
    // 使用 Objects.hash 自动组合多个字段的哈希值
    // 内部实现通常类似于 31 * x + y，能有效减少哈希冲突
    return Objects.hash(name, id);
}

#### 3. 性能优化：从缓存哈希码谈起

计算哈希码是有成本的，特别是当对象包含复杂的字段或者哈希算法很复杂时。如果一个对象是不可变的，并且哈希码的计算开销较大，我们可以在第一次计算时将其缓存起来。

public class ExpensiveObject {
    private final String data;
    private int cachedHashCode; // 默认为 0

    public ExpensiveObject(String data) {
        this.data = data;
    }

    @Override
    public int hashCode() {
        if (cachedHashCode == 0) {
            // 假设 computeHash 是一个很重的操作，或者 data 很长
            cachedHashCode = Objects.hash(data);
        }
        return cachedHashCode;
    }
}

#### 4. 常见陷阱：不要在 equals() 中依赖易变字段

如果你的对象是放入 INLINECODEcacd1109 或作为 INLINECODEa1f5135d 的 Key 的，请确保用于计算 INLINECODE560d8201 和 INLINECODEb10e97e8 的字段是不可变的。

危险场景：

class MutableKey {
    private int id;
    // getter, setter, equals, hashCode based on id...
}

MutableKey key = new MutableKey(1);
map.put(key, "Value");
key.setId(2); // 修改了 key 的状态
map.get(key); // 返回 null！

原因： 当你修改了 key 的 INLINECODEbab09cd0 后，它的哈希码变了。当你再去 INLINECODE9a0b3c57 时，HashMap 会去新的哈希桶里找，但原来的对象还在旧的桶里躺着呢。这就导致对象“丢失”在 HashMap 中。最佳实践是：作为 Map 键的对象，最好是不可变的。

总结

回顾我们的探索之旅，INLINECODE947a5120 和 INLINECODE7c7dfd0d 不仅仅是两个简单的方法，它们是 Java 对象模型与集合框架之间的桥梁。

必须同时重写：这是为了保证对象在基于哈希的集合中逻辑的一致性。
契约必须遵守：相等的对象必须有相等的哈希码；反之不亦然，但最好不同以提高性能。
工具辅助：不要手动去写，利用 IDE 或 Lombok 避免低级错误。
保持一致：参与计算的字段必须保持一致，且最好是不可变的。

下次当你创建一个自定义类，并打算把它放进 HashMap 时，请记得检查这两个方法是否已经“整装待发”。希望这篇文章能帮助你彻底攻克这个知识点，写出更健壮的 Java 代码！

投稿给我们	如何建站？
vps是什么？	如何安装宝塔？
如何通过博客赚钱？	便宜wordpress托管方案
免费wordpress主题	这些都是免费方案

豆丁博客

深入理解：为什么必须同时重写 equals() 和 hashCode() 方法？

基础篇：基于哈希的集合是如何工作的？

核心契约：equals() 与 hashCode() 的铁律

场景实战演练

进阶技巧与最佳实践

总结

相关文章美国1G带宽/1T流量高速vps $17.99/年