重要阐明：本篇为博主《面试题精选-根底篇》系列中的一篇，关注我，查看更多面试题。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<String> 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<Persion> set = new HashSet<Persion>();        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<Persion> set = new HashSet<Persion>();        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 面试题。