Java基础面试专栏（七）：hashCode()与equals()的关联，重写的核心原则

PeterMap
4 阅读11分钟

承接前六篇专栏，我们先后拆解了Java数据类型、抽象类与接口、final关键字、static关键字，String、StringBuffer、StringBuilder的区别，以及==与equals()的核心差异，今天继续聚焦Java基础面试的高频重点——hashCode()和equals()的区别，以及“为什么重写equals()必须重写hashCode()”这一核心考点。这两个方法是Java对象的核心方法，贯穿日常开发和面试，很多面试者能说出两者的基本用途，却讲不清它们的关联的底层逻辑，也不懂重写时的核心原则，今天我们就从面试答题角度，把两者的区别、关联逻辑、重写方法和易错点拆透，帮你快速掌握答题思路，轻松应对追问。

先给大家一个面试万能总结（一句话直达核心，适合开场快速应答）：hashCode()用于计算对象的哈希值，核心作用是为哈希表（如HashMap、HashSet）提供快速定位；equals()用于判断两个对象的内容是否逻辑相等；两者用途不同，但需遵循Java对象契约：若两个对象equals()判定为相等，则它们的hashCode()必须返回相同值；仅重写equals()不重写hashCode()，会导致哈希集合出现逻辑矛盾，破坏其正常运作，因此必须同时重写。

一、核心对比：一张表分清hashCode()与equals()的核心差异

面试中，当被问到两者区别时，先给出核心对比表，再逐一拆解，会显得答题有条理、思路清晰。以下是两者核心特性对比，覆盖面试所有高频考点，建议牢记：

核心特性hashCode()equals()
核心作用计算对象的哈希值，用于哈希表快速定位存储位置判断两个对象的内容是否逻辑相等
返回值类型int类型（哈希值，范围-2³¹~2³¹-1）boolean类型（true表示内容相等，false表示不相等）
默认实现（Object类）基于对象的内存地址计算哈希值，不同对象哈希值大概率不同基于==比较，判断两个对象的内存地址是否相同
重写必要性若重写equals()，则必须重写；对象用于哈希集合时，必须重写需判断对象内容是否相等时，需重写
核心关联equals()相等 → hashCode()必须相等；hashCode()相等 → equals()不一定相等（哈希碰撞）与hashCode()遵循Java对象契约，确保哈希集合正常工作
适用场景哈希表（HashMap、HashSet等）的存储、查找、去重所有需要判断对象内容是否相等的场景（如对象比较、集合去重辅助）

二、逐一拆解：hashCode()与equals()的核心用法

掌握对比表后，我们逐一拆解两个方法的核心用法、底层逻辑，结合代码示例，帮你吃透本质，避免死记硬背，同时覆盖日常开发中的常见场景。

1. hashCode()：哈希表的“定位工具”

hashCode()是Object类中定义的方法，每个Java对象都继承了这个方法，其核心作用是计算对象的哈希值（一个int类型的整数）。哈希值的核心用途的是为哈希表（如HashMap、HashSet）提供快速定位，相当于对象在哈希表中的“地址索引”，能大幅提升集合的存储和查找效率。

底层逻辑：哈希表通过哈希值将对象分配到不同的“桶”中，存储时根据哈希值找到对应桶，查找时也先通过哈希值快速定位到桶，再在桶内进行精确比较，避免全量遍历，提升效率。

代码示例（hashCode()的基本用法）：

// 自定义商品类（未重写hashCode()和equals()）
class Goods {
    private String goodsId;
    private String goodsName;
    
    public Goods(String goodsId, String goodsName) {
        this.goodsId = goodsId;
        this.goodsName = goodsName;
    }
}

public class HashCodeBasicTest {
    public static void main(String[] args) {
        Goods goods1 = new Goods("G001", "手机");
        Goods goods2 = new Goods("G001", "手机");
        Goods goods3 = new Goods("G002", "电脑");
        
        // 默认hashCode()基于内存地址，不同对象哈希值不同
        System.out.println("goods1的哈希值：" + goods1.hashCode());
        System.out.println("goods2的哈希值：" + goods2.hashCode());
        System.out.println("goods3的哈希值：" + goods3.hashCode());
        
        // 哈希值不同，即使内容相同，也会被哈希表视为不同对象
        System.out.println("goods1.hashCode() == goods2.hashCode()：" + (goods1.hashCode() == goods2.hashCode())); // false
    }
}

面试重点：默认hashCode()基于对象内存地址计算，因此不同对象（即使内容相同）的哈希值大概率不同；哈希值相同的两个对象，不一定是同一个对象（哈希碰撞），这是哈希算法的固有特性，无需刻意避免，但需保证equals()能区分。

2. equals()：对象内容的“校验工具”

equals()也是Object类中定义的方法，核心作用是判断两个对象的内容是否逻辑相等，我们在上一篇专栏中已经详细拆解过，这里重点衔接hashCode()，回顾其核心特性和重写逻辑。

核心要点：① 默认实现等同于==，比较对象内存地址；② 重写后可自定义比较逻辑，通常比较对象的属性值；③ 重写时需遵循4个核心规则（一致性、传递性、非空性、与hashCode()同步）。

代码示例（重写equals()但未重写hashCode()）：

import java.util.Objects;

// 自定义商品类，重写equals()但未重写hashCode()
class Goods {
    private String goodsId;
    private String goodsName;
    
    public Goods(String goodsId, String goodsName) {
        this.goodsId = goodsId;
        this.goodsName = goodsName;
    }
    
    // 重写equals()，比较商品ID和名称（内容相等）
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Goods goods = (Goods) o;
        return Objects.equals(goodsId, goods.goodsId) && Objects.equals(goodsName, goods.goodsName);
    }
}

public class EqualsWithoutHashCodeTest {
    public static void main(String[] args) {
        Goods goods1 = new Goods("G001", "手机");
        Goods goods2 = new Goods("G001", "手机");
        
        // equals()返回true（内容相同）
        System.out.println("goods1.equals(goods2)：" + goods1.equals(goods2)); // true
        // hashCode()返回false（默认基于内存地址，未重写）
        System.out.println("goods1.hashCode() == goods2.hashCode()：" + (goods1.hashCode() == goods2.hashCode())); // false
    }
}

面试重点：仅重写equals()，会导致“内容相等的对象，哈希值不同”，违背Java对象契约，这也是后续哈希集合出现异常的核心原因。

三、面试核心问题：为什么重写equals()就要重写hashCode()？（必答）

这是面试中高频追问的核心考点，很多面试者只知道“必须重写”，却讲不清底层原因，掌握这个知识点，能让你的答题更有深度，轻松加分。核心原因是为了遵守Java对象契约，保证哈希表（如HashMap、HashSet）的正常运作，我们从“哈希表工作机制”和“违反契约的后果”两个层面拆解。

1. 哈希表的工作机制（底层逻辑）

HashMap、HashSet等哈希集合，其高效存储、查找、去重的核心依赖hashCode()和equals()的配合，具体流程如下：

① 存储时：先调用对象的hashCode()计算哈希值，根据哈希值确定对象在哈希表中的“桶位置”；若该桶为空，直接存入；若该桶已有对象，再调用equals()比较两个对象的内容，若内容不同则存入（哈希碰撞处理），若内容相同则视为同一对象，不重复存储。

② 查找时：先调用对象的hashCode()计算哈希值，快速定位到对应桶；再在桶内调用equals()比较内容，找到匹配的对象并返回。

通俗理解：hashCode()负责“快速定位到大致范围”，equals()负责“在范围中精确匹配”，两者缺一不可，且必须遵循契约。

2. 仅重写equals()的后果（代码示例）

若只重写equals()，不重写hashCode()，会导致“内容相等的对象，哈希值不同”，进而导致哈希表无法正确识别同一对象，出现重复存储、无法正确查找等逻辑异常。

代码示例（哈希集合异常场景）：

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

// 沿用上面的Goods类（重写equals()，未重写hashCode()）
public class HashCollectionErrorTest {
    public static void main(String[] args) {
        Goods goods1 = new Goods("G001", "手机");
        Goods goods2 = new Goods("G001", "手机");
        
        // 场景1：HashSet存储，出现重复元素（预期去重，实际重复）
        Set<Goods> goodsSet = new HashSet<>();
        goodsSet.add(goods1);
        goodsSet.add(goods2);
        System.out.println("HashSet大小：" + goodsSet.size()); // 输出：2（异常，应为1）
        
        // 场景2：HashMap存储，无法正确查找（预期能找到，实际返回null）
        Map<Goods, String&gt; goodsMap = new HashMap<>();
        goodsMap.put(goods1, "华为手机");
        // 用goods2查找，因哈希值不同，无法定位到正确桶，返回null
        String goodsInfo = goodsMap.get(goods2);
        System.out.println("通过goods2查找结果：" + goodsInfo); // 输出：null（异常，应为华为手机）
    }
}

异常原因：goods1和goods2的equals()为true（内容相同），但hashCode()不同（未重写），哈希表会将它们视为两个不同对象，存入不同桶中，导致重复存储和查找失败。

3. 正确做法：同步重写equals()和hashCode()

重写hashCode()的核心原则：与equals()的比较逻辑保持一致——equals()中用于比较的属性，必须全部参与hashCode()的计算，确保“内容相等的对象，哈希值一定相同”。

代码示例（正确重写，解决哈希集合异常）：

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

// 自定义商品类，同步重写equals()和hashCode()
class Goods {
    private String goodsId;
    private String goodsName;
    
    public Goods(String goodsId, String goodsName) {
        this.goodsId = goodsId;
        this.goodsName = goodsName;
    }
    
    // 重写equals()，比较商品ID和名称
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Goods goods = (Goods) o;
        return Objects.equals(goodsId, goods.goodsId) && Objects.equals(goodsName, goods.goodsName);
    }
    
    // 同步重写hashCode()，基于equals()中用到的属性计算哈希值
    @Override
    public int hashCode() {
        return Objects.hash(goodsId, goodsName);
    }
}

public class CorrectRewriteTest {
    public static void main(String[] args) {
        Goods goods1 = new Goods("G001", "手机");
        Goods goods2 = new Goods("G001", "手机");
        
        // 验证契约：equals()为true，hashCode()必相同
        System.out.println("goods1.equals(goods2)：" + goods1.equals(goods2)); // true
        System.out.println("goods1.hashCode() == goods2.hashCode()：" + (goods1.hashCode() == goods2.hashCode())); // true
        
        // 场景1：HashSet正常去重
        Set&lt;Goods&gt; goodsSet = new HashSet<>();
        goodsSet.add(goods1);
        goodsSet.add(goods2);
        System.out.println("HashSet大小：" + goodsSet.size()); // 输出：1（正常）
        
        // 场景2：HashMap正常查找
        Map<Goods, String> goodsMap = new HashMap<>();
        goodsMap.put(goods1, "华为手机");
        String goodsInfo = goodsMap.get(goods2);
        System.out.println("通过goods2查找结果：" + goodsInfo); // 输出：华为手机（正常）
    }
}

四、如何正确重写hashCode()？（面试加分项）

重写hashCode()无需复杂逻辑，核心是“与equals()的比较属性保持一致”，日常开发中主要有两种常用方式，兼顾简洁性和正确性。

1. 方式1：使用Objects.hash()工具类（推荐）

Java提供了Objects.hash()静态方法，可直接传入equals()中用到的所有属性，自动计算哈希值，简洁高效，且能避免手动计算的错误，是日常开发中最常用的方式。

核心逻辑：Objects.hash()会对每个传入的属性计算哈希值，再通过特定算法合并，最终返回一个综合的哈希值，确保“属性相同的对象，哈希值相同”。

2. 方式2：IDE自动生成（推荐）

IntelliJ IDEA、Eclipse等IDE都支持自动生成equals()和hashCode()方法，生成的代码会严格遵循Java对象契约，确保两者逻辑一致，避免手动编写的遗漏和错误。

补充说明：自动生成的代码，会先判断对象是否为同一对象、是否为null、类型是否一致，再比较属性，hashCode()的计算也会基于所有比较属性，兼顾正确性和效率。

3. 注意事项

① 哈希值的唯一性：无需保证“哈希值相同的对象，内容一定相同”（哈希碰撞是正常现象），只需保证“内容相同的对象，哈希值一定相同”；

② 属性不可变：若对象的属性会被修改，修改后哈希值会发生变化，导致对象在哈希表中无法被正确查找，因此用于哈希集合的对象，建议使用不可变属性（如String、包装类）；

③ 避免过度复杂：无需手动编写复杂的哈希算法，Objects.hash()或IDE自动生成即可满足大部分开发场景。

五、高频易错点大汇总（必记，避开面试陷阱）

hashCode()与equals()的面试易错点，主要集中在“重写原则”“哈希集合异常”和“契约理解”，记住以下5点，轻松避开所有陷阱：

  1. 易错点1：认为“重写equals()可不用重写hashCode()”——仅重写equals()会违背Java对象契约，导致哈希集合出现重复存储、查找失败等异常，必须同步重写。

  2. 易错点2：重写hashCode()时，未使用equals()中的所有比较属性——会导致“内容相同的对象，哈希值不同”，同样违背契约，哈希集合无法正常工作。

  3. 易错点3：误以为“hashCode()相同，equals()一定相同”——哈希碰撞是正常现象，哈希值相同的两个对象，内容可能不同，需通过equals()进一步校验。

  4. 易错点4：所有对象都需要重写hashCode()和equals()——并非如此，若对象不会被用于哈希集合（如HashMap的键、HashSet的元素），且无需比较内容，可不重写；但建议重写时同步重写，避免后续使用异常。

  5. 易错点5：手动计算哈希值时出错——日常开发中，优先使用Objects.hash()或IDE自动生成，避免手动计算导致的逻辑错误。

六、面试总结与延伸

  1. 答题逻辑：先一句话总结hashCode()与equals()的核心区别和关联，再给出对比表，接着拆解两者的用法，重点讲解“为什么重写equals()必须重写hashCode()”（底层逻辑+异常示例+正确做法），最后补充重写方法和易错点，答题全面且有条理，符合面试答题习惯。

  2. 高频面试题（提前准备，直接应答）：

① hashCode()和equals()的区别是什么？（核心考点，按本文对比表+用法应答）

② 为什么重写equals()就要重写hashCode()？（遵守对象契约，保证哈希集合正常工作）

③ 仅重写equals()不重写hashCode()，会出现什么问题？（哈希集合重复存储、查找失败）

④ 如何正确重写hashCode()？（与equals()比较属性一致，用Objects.hash()或IDE自动生成）

avatar
文章
阅读
粉丝