百度360必应搜狗淘宝本站头条
php redisredis 命令redis 锁redis 主从redis 删除
当前位置：网站首页 > 技术教程 > 正文

面试官:重写 equals 时为什么一定要重写 hashCode?

mhr18 2025-04-05 20:30 26 浏览 0 评论

重要说明：本篇为博主《面试题精选-基础篇》系列中的一篇，关注我，查看更多面试题。Gitee 面试题系列开源地址：
https://gitee.com/mydb/interview


本题目难度：低

常见程度：高


equals 方法和 hashCode 方法是 Object 类中的两个基础方法，它们共同协作来判断两个对象是否相等。为什么要这样设计嘞？原因就出在“性能” 2 字上。


使用过 HashMap 我们就知道，通过 hash 计算之后，我们就可以直接定位出某个值存储的位置了，那么试想一下，如果你现在要查询某个值是否在集合中？如果不通过 hash 方式直接定位元素（的存储位置），那么就只能按照集合的前后顺序，一个一个地询问比对了，而这种依次比对的效率明显低于 hash 定位的方式。这就是 hash 以及 hashCode 存在的价值。

当我们对比两个对象是否相等时，我们就可以先使用 hashCode 进行比较，如果比较的结果是 true，那么就可以使用 equals 再次确认两个对象是否相等，如果比较的结果是 true，那么这两个对象就是相等的，否则其他情况就认为两个对象不相等。这样就大大地提升了对象比较的效率，这也是为什么 Java 设计使用 hashCode 和 equals 协同的方式，来确认两个对象是否相等的原因。


那为什么不直接使用 hashCode 就确定两个对象是否相等呢？


这是因为不同对象的 hashCode 可能相同；但 hashCode 不同的对象一定不相等，所以使用 hashCode 可以起到快速初次判断对象是否相等的作用。


但即使知道了以上基础知识，依然解决不了本篇的问题，也就是：重写 equals 时为什么一定要重写 hashCode？要想了解这个问题的根本原因，我们还得先从这两个方法开始说起。

1.equals 方法

Object 类中的 equals 方法用于检测一个对象是否等于另外一个对象。在 Object 类中，这个方法将判断两个对象是否具有相同的引用。如果两个对象具有相同的引用，它们一定是相等的。


equals 方法的实现源码如下：

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

通过上述源码和 equals 的定义我们可以看出，在大多数情况来说，equals 的判断是没有什么意义的！例如，使用 Object 中的 equals 比较两个自定义的对象是否相等，这就完全没有意义（因为无论对象是否相等，结果都是 false）。


通过以下示例，就可以说明这个问题：

public class EqualsMyClassExample {
    public static void main(String[] args) {
        Person u1 = new Person();
        u1.setName("Java");
        u1.setAge(18);
		
        Person u2 = new Person();
        u1.setName("Java");
        u1.setAge(18);
        
        // 打印 equals 结果
        System.out.println("equals 结果：" + u1.equals(u2));
    }
}

class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

以上程序的执行结果，如下图所示：

因此通常情况下，我们要判断两个对象是否相等，一定要重写 equals 方法，这就是为什么要重写 equals 方法的原因。

2.hashCode 方法

hashCode 翻译为中文是散列码，它是由对象推导出的一个整型值，并且这个值为任意整数，包括正数或负数。


需要注意的是：散列码是没有规律的。如果 x 和 y 是两个不同的对象，x.hashCode() 与 y.hashCode() 基本上不会相同；但如果 a 和 b 相等，则 a.hashCode() 一定等于 b.hashCode()。


hashCode 在 Object 中的源码如下：

public native int hashCode();

从上述源码可以看到，Object 中的 hashCode 调用了一个（native）本地方法，返回了一个 int 类型的整数，当然，这个整数可能是正数也可能是负数。

hashCode 使用

相等的值 hashCode 一定相同的示例：

public class HashCodeExample {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "Hello";
        String s3 = "Java";
        System.out.println("s1 hashCode:" + s1.hashCode());
        System.out.println("s2 hashCode:" + s2.hashCode());
        System.out.println("s3 hashCode:" + s3.hashCode());
    }
}

以上程序的执行结果，如下图所示：

不同的值 hashCode 也有可能相同的示例：

public class HashCodeExample {
    public static void main(String[] args) {
        String s1 = "Aa";
        String s2 = "BB";
        System.out.println("s1 hashCode:" + s1.hashCode());
        System.out.println("s2 hashCode:" + s2.hashCode());
    }
}

以上程序的执行结果，如下图所示：

3.为什么要一起重写？

接下来回到本文的主题，重写 equals 为什么一定要重写 hashCode？


为了解释这个问题，我们需要从下面的这个例子入手。

3.1 Set 正常使用

Set 集合是用来保存不同对象的，相同的对象就会被 Set 合并，最终留下一份独一无二的数据。


它的正常用法如下：

import java.util.HashSet;
import java.util.Set;

public class HashCodeExample {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("Java");
        set.add("Java");
        set.add("MySQL");
        set.add("MySQL");
        set.add("Redis");
        System.out.println("Set 集合长度:" + set.size());
        System.out.println();
        // 打印 Set 中的所有元素
        set.forEach(d -> System.out.println(d));
    }
}

以上程序的执行结果，如下图所示：

从上述结果可以看出，重复的数据已经被 Set 集合“合并”了，这也是 Set 集合最大的特点：去重。

3.2 Set 集合的“异常”

然而，如果我们在 Set 集合中存储的是，只重写了 equals 方法的自定义对象时，有趣的事情就发生了，如下代码所示：

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

public class EqualsExample {
    public static void main(String[] args) {
        // 对象 1
        Persion p1 = new Persion();
        p1.setName("Java");
        p1.setAge(18);
		// 对象 2
        Persion p2 = new Persion();
        p2.setName("Java");
        p2.setAge(18);
		// 创建 Set 集合
        Set set = new HashSet();
        set.add(p1);
        set.add(p2);
		// 打印 Set 中的所有数据
        set.forEach(p -> {
            System.out.println(p);
        });
    }
}


class Persion {
    private String name;
    private int age;

    // 只重写了 equals 方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 引用相等返回 true
        // 如果等于 null，或者对象类型不同返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 强转为自定义 Persion 类型
        Persion persion = (Persion) o;
        // 如果 age 和 name 都相等，就返回 true
        return age == persion.age &&
                Objects.equals(name, persion.name);
    }
	
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
     @Override
    public String toString() {
        return "Persion{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

以上程序的执行结果，如下图所示：

从上述代码和上述图片可以看出，即使两个对象是相等的，Set 集合竟然没有将二者进行去重与合并。这就是重写了 equals 方法，但没有重写 hashCode 方法的问题所在。

3.3 解决“异常”

为了解决上面的问题，我们尝试在重写 equals 方法时，把 hashCode 方法也一起重写了，实现代码如下：

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

public class EqualsToListExample {
    public static void main(String[] args) {
        // 对象 1
        Persion p1 = new Persion();
        p1.setName("Java");
        p1.setAge(18);
		// 对象 2
        Persion p2 = new Persion();
        p2.setName("Java");
        p2.setAge(18);
		// 创建 Set 对象
        Set set = new HashSet();
        set.add(p1);
        set.add(p2);
		// 打印 Set 中的所有数据
        set.forEach(p -> {
            System.out.println(p);
        });
    }
}


class Persion {
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 引用相等返回 true
        // 如果等于 null，或者对象类型不同返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 强转为自定义 Persion 类型
        Persion persion = (Persion) o;
        // 如果 age 和 name 都相等，就返回 true
        return age == persion.age &&
                Objects.equals(name, persion.name);
    }

    @Override
    public int hashCode() {
        // 对比 name 和 age 是否相等
        return Objects.hash(name, age);
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Persion{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

以上程序的执行结果，如下图所示：

通过上述结果可以看出，当我们一起重写了两个方法之后，奇迹的事情又发生了，Set 集合又恢复正常了，这是为什么呢？

3.4 原因分析

出现以上问题的原因是，如果只重写了 equals 方法，那么默认情况下，Set 进行去重操作时，会先判断两个对象的 hashCode 是否相同，此时因为没有重写 hashCode 方法，所以会直接执行 Object 中的 hashCode 方法，而 Object 中的 hashCode 方法对比的是两个不同引用地址的对象，所以结果是 false，那么 equals 方法就不用执行了，直接返回的结果就是 false：两个对象不是相等的，于是就在 Set 集合中插入了两个相同的对象。


但是，如果在重写 equals 方法时，也重写了 hashCode 方法，那么在执行判断时会去执行重写的 hashCode 方法，此时对比的是两个对象的所有属性的 hashCode 是否相同，于是调用 hashCode 返回的结果就是 true，再去调用 equals 方法，发现两个对象确实是相等的，于是就返回 true 了，因此 Set 集合就不会存储两个一模一样的数据了，于是整个程序的执行就正常了。

总结

hashCode 和 equals 两个方法是用来协同判断两个对象是否相等的，采用这种方式的原因是可以提高程序插入和查询的速度，如果在重写 equals 时，不重写 hashCode，就会导致在某些场景下，例如将两个相等的自定义对象存储在 Set 集合时，就会出现程序执行的异常，为了保证程序的正常执行，所以我们就需要在重写 equals 时，也一并重写 hashCode 方法才行。

关注公众号：Java面试真题解析，查看更多 Java 面试题。

相关推荐

【推荐】一个开源免费、AI 驱动的智能数据管理系统，支持多数据库

如果您对源码&技术感兴趣，请点赞+收藏+转发+关注，大家的支持是我分享最大的动力！！！.前言在当今数据驱动的时代，高效、智能地管理数据已成为企业和个人不可或缺的能力。为了满足这一需求，我们推出了这款开...

Pure Storage推出统一数据管理云平台及新闪存阵列

PureStorage公司今日推出企业数据云(EnterpriseDataCloud)，称其为组织在混合环境中存储、管理和使用数据方式的全面架构升级。该公司表示，EDC使组织能够在本地、云端和混...

对Java学习的10条建议（对java课程的建议）

不少Java的初学者一开始都是信心满满准备迎接挑战，但是经过一段时间的学习之后，多少都会碰到各种挫败，以下北风网就总结一些对于初学者非常有用的建议，希望能够给他们解决现实中的问题。Java编程的准备：...

SQLShift 重大更新:Oracle→PostgreSQL 存储过程转换功能上线!

官网：https://sqlshift.cn/6月，SQLShift迎来重大版本更新！作为国内首个支持Oracle->OceanBase存储过程智能转换的工具，SQLShift在过去一...

JDK21有没有什么稳定、简单又强势的特性?

佳未阿里云开发者2025年03月05日08:30浙江阿里妹导读这篇文章主要介绍了Java虚拟线程的发展及其在AJDK中的实现和优化。阅前声明：本文介绍的内容基于AJDK21.0.5[1]以及以上...

「松勤软件测试」网站总出现404 bug?总结8个原因，不信解决不了

在进行网站测试的时候，有没有碰到过网站崩溃，打不开，出现404错误等各种现象，如果你碰到了，那么恭喜你，你的网站出问题了，是什么原因导致网站出问题呢，根据松勤软件测试的总结如下：01数据库中的表空间不...

Java面试题及答案最全总结(2025版)

大家好，我是Java面试陪考员最近很多小伙伴在忙着找工作，给大家整理了一份非常全面的Java面试题及答案。涉及的内容非常全面，包含：Spring、MySQL、JVM、Redis、Linux、Sprin...

数据库日常运维工作内容（数据库日常运维 工作内容）

#数据库日常运维工作包括哪些内容?#数据库日常运维工作是一个涵盖多个层面的综合性任务，以下是详细的分类和内容说明：一、数据库运维核心工作监控与告警性能监控：实时监控CPU、内存、I/O、连接数、锁等待...

分布式之系统底层原理(上)（底层分布式技术）

作者：allanpan，腾讯IEG高级后台工程师导言分布式事务是分布式系统必不可少的组成部分，基本上只要实现一个分布式系统就逃不开对分布式事务的支持。本文从分布式事务这个概念切入，尝试对分布式事务...

oracle 死锁了怎么办?kill 进程 直接上干货

1、查看死锁是否存在selectusername,lockwait,status,machine,programfromv$sessionwheresidin(selectsession...

SpringBoot 各种分页查询方式详解(全网最全)

一、分页查询基础概念与原理1.1什么是分页查询分页查询是指将大量数据分割成多个小块（页）进行展示的技术，它是现代Web应用中必不可少的功能。想象一下你去图书馆找书，如果所有书都堆在一张桌子上，你很难...

《战场兄弟》全事件攻略 一般事件合同事件红装及隐藏职业攻略

《战场兄弟》全事件攻略，一般事件合同事件红装及隐藏职业攻略。《战场兄弟》事件奖励，事件条件。《战场兄弟》是OverhypeStudios制作发行的一款由xcom和桌游为灵感来源，以中世纪、低魔奇幻为...

LoadRunner（loadrunner录制不到脚本）

一、核心组件与工作流程LoadRunner性能测试工具-并发测试-正版软件下载-使用教程-价格-官方代理商的架构围绕三大核心组件构建，形成完整测试闭环：VirtualUserGenerator(...

Redis数据类型介绍（redis 数据类型）

介绍Redis支持五种数据类型：String（字符串），Hash（哈希），List（列表），Set（集合）及Zset(sortedset：有序集合)。1、字符串类型概述1.1、数据类型Redis支持...

RMAN备份监控及优化总结（rman备份原理）

今天主要介绍一下如何对RMAN备份监控及优化，这里就不讲rman备份的一些原理了，仅供参考。一、监控RMAN备份1、确定备份源与备份设备的最大速度从磁盘读的速度和磁带写的带度、备份的速度不可能超出这两...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表