关于java:面试官重写-equals-时为什么一定要重写-hashCode

重要阐明：本篇为博主《面试题精选-根底篇》系列中的一篇，关注我，查看更多面试题。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 办法的实现源码如下：

<code class="java">public boolean equals(Object obj) {
    return (this == obj);
}

通过上述源码和 equals 的定义咱们能够看出，在大多数状况来说，equals 的判断是没有什么意义的！例如，应用 Object 中的 equals 比拟两个自定义的对象是否相等，这就齐全没有意义（因为无论对象是否相等，后果都是 false）。

通过以下示例，就能够阐明这个问题：

<code class="java">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 中的源码如下：

<code class="java">public native int hashCode();

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

hashCode 应用

相等的值 hashCode 肯定雷同的示例：

<code class="java">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 也有可能雷同的示例：

<code class="java">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 合并，最终留下一份举世无双的数据。
​

它的失常用法如下：

<code class="java">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 办法的自定义对象时，乏味的事件就产生了，如下代码所示：

<code class="java">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 办法也一起重写了，实现代码如下：

<code class="java">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 面试题。

喜欢 (0)赏

[搞代码]

分享 (0)