文章目录：

1.引出话题

2.关于equals方法

3.关于hashCode方法

4.为什么要一起重写这两个方法？

5.总结

1.引出话题

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

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

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

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

这是因为 如果两个对象相等，则hashcode一定也是相同的；两个对象有相同的hashcode值，它们并不一定是相等的。所以使用 hashCode 可以起到快速初次判断对象是否相等的作用。

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

2.关于equals方法

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

equals 方法的实现源码如下：

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

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

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

/****/
class User {private String name;private Integer age;public User(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}
}public class EqualsMethodTest {public static void main(String[] args) {User u1 = new User("张起灵", 18);User u2 = new User("张起灵", 18);System.out.println(u1.equals(u2));}
}

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

就像8种数据类型的包装类、String这些类都重写了equals方法的。

3.关于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是否相同？

/****/
class People {private String name;private Integer age;public People(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}
}public class HashCodeMethodTest {public static void main(String[] args) {People p1 = new People("张起灵", 18);People p2 = new People("张起灵", 18);System.out.println(p1.hashCode());System.out.println(p2.hashCode());}
}

上面的结果显然不同，那这不就与我们上面所说的相悖了吗？

下面再来看一个：重写hashCode之后，两个对象相同，它们的hashCode是否相同？（以String类为例）

package com.interview;/****/
public class HashCodeMethodTest {public static void main(String[] args) {String s1 = "Hello";String s2 = "Hello";System.out.println(s1.hashCode());System.out.println(s2.hashCode());}
}

但是不同的对象，它们的 hashCode 也有可能相同，示例如下：

package com.interview;/****/
public class HashCodeMethodTest {public static void main(String[] args) {String str1 = "Aa";String str2 = "BB";System.out.println(str1.hashCode());System.out.println(str2.hashCode());}
}

4.为什么要一起重写这两个方法？

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

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

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

import java.util.HashSet;
import java.util.Set;/****/
public class EqualsHashCodeTest {public static void main(String[] args) {Set<String> set = new HashSet<>();set.add("Java");set.add("Java");set.add("SpringBoot");set.add("SpringBoot");set.add("SpringBoot");set.add("Redis");System.out.println("set集合的长度为：" + set.size());set.forEach(System.out::println);}
}

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

上面的案例种，set集合的泛型是String，这个类已经重写过了equals和hashCode，那么下面我们将泛型修改为一个自定义的类，而在这个自定义的类中，只重写equals方法。

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;/****/
class Student {private String name;private Integer age;public Student(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return Objects.equals(name, student.name) && Objects.equals(age, student.age);}//    @Override
//    public int hashCode() {
//        return Objects.hash(name, age);
//    }@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}public class EqualsHashCodeTest {public static void main(String[] args) {Set<Student> set = new HashSet<>();set.add(new Student("张起灵", 18));set.add(new Student("张起灵", 18));System.out.println("set集合的长度为：" + set.size());set.forEach(System.out::println);}
}

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

解决上述问题，自然就是在重写equals的同时一定要重写hashCode！！！

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;/****/
class Student {private String name;private Integer age;public Student(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return Objects.equals(name, student.name) && Objects.equals(age, student.age);}@Overridepublic int hashCode() {return Objects.hash(name, age);}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}public class EqualsHashCodeTest {public static void main(String[] args) {Set<Student> set = new HashSet<>();set.add(new Student("张起灵", 18));set.add(new Student("张起灵", 18));System.out.println("set集合的长度为：" + set.size());set.forEach(System.out::println);}
}

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

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

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

5.总结

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

JavaSE——为什么重写equals的同时一定要重写hashCode？相关推荐

hashcode相等的两个对象一定相等吗_为什么重写 equals方法时一定要重写hashCode方法？...
推荐阅读: 一线架构师总结SpringBoot,Cloud,Nginx与Docker,不信你搞不懂 47天洒热血复习,我终于"挤进"了字节跳动(附面经+学习笔记) 五年时间,从蘑菇 ...
面试官：重写 equals 时为什么一定要重写 hashCode？
作者 | 磊哥来源 | Java面试真题解析(ID:aimianshi666) 转载请联系授权(微信ID:GG_Stone) 重要说明:本篇为博主<面试题精选-基础篇>系列中的一篇,关注 ...
Java重写equals方法时为什么要重写hashCode方法
在我们平时编写Java代码时,重写equals方法时一定要重写hashCode方法,这是为什么呢? 在讨论这个问题前,我们先看下Object类中hashCode方法和equals方法. hashCod ...
重写equals()时为什么也得重写hashCode()之深度解读equals方法与hashCode方法渊源
重写equals()时为什么也得重写hashCode()之深度解读equals方法与hashCode方法渊源在使用Map接口时,我们的愿望是当key1.equals(key2)时,它们获取的valu ...
面试题：重写equals方法为什么通常会重写hashcode方法？
最近在面试的时候,当问完了HashMap的数据结构之后,通常会再多问一个问题,就是:重写equals方法时通常为什么也要重写一下hashcode方法? 其实这个问题,本质上又回到HashMap的应用场 ...
为什么重写equals方法时一定要重写hashCode方法
在每个类中,在重写equals方法的时侯,一定要重写hashcode方法. 根据Object规范,规范约定: 如果两个对象通过equals方法比较是相等的,那么它们的hashCode方法结果值也是相等 ...
JAVA中重写equals()方法的同时要重写hashcode()方法
object对象中的 public boolean equals(Object obj),对于任何非空引用值 x 和 y,当且仅当 x 和 y 引用同一个对象时,此方法才返回 true:注意:当此方法 ...
重写 equals 方法就一定要重写 hashCode 方法？其实有个前提
作者 l 会点代码的大叔(CodeDaShu) 如果问到 == 和 equals 的区别,相信很多程序员同学都能脱口而出:一个是判断地址,一个是判断内容. 但是如果继续追问:"你重写过 eq ...
为什么重写equals方法就一定要重写hashCode方法
在hashMap和hashTable集合中,元素是不能够重复的,所以我们在添加元素时,先要判断是否存在这个元素.而判断的方法就是先用hashCode方法判断哈希值是否相同,如果哈希值相同,再使用equ ...

JavaSE——为什么重写equals的同时一定要重写hashCode？

文章目录：

1.引出话题

2.关于equals方法

3.关于hashCode方法

4.为什么要一起重写这两个方法？

5.总结

JavaSE——为什么重写equals的同时一定要重写hashCode？相关推荐

最新文章

热门文章