Java面试题-为什么重写equals就一定要重写hashCode方法呢？

目录

1、为什么要重写equals 方法

2、hashCode 方法

3、为什么要一起重写？

4 原因分析

总结

---

先放结论：

• hashCode 和 equals 两个方法是用来协同判断两个对象是否相等的，采用这种方式的原因是可以提高程序插入和查询的速度。
• 如果只重写equals方法，不重写hashCode方法，就有可能导致a.equals(b)这个表达式成立，但是hashCode却不同。会造成一个完全相同的对象会存储在hash表的不同位置。

1、为什么要重写equals 方法

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

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

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

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

package cn.itcast.interview;
 
/**
 * @author: msf
 * @date: 2022/11/26
 */
public class EqualsMyClassExample {
    public static void main(String[] args) {
        Person u1 = new Person();
        u1.setName("Java");
        u1.setAge(18);
 
        Person u2 = new Person();
        u2.setName("Java");
        u2.setAge(18);
 
        System.out.println(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 使用

package cn.itcast.interview;
 
/**
 * @author: msf
 * @date: 2022/11/26
 */
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("s1 hashCode" + s2.hashCode());
        System.out.println("s1 hashCode" + s3.hashCode());
 
        // 在一些特殊情况下是相同的
        String t1 = "Aa";
        String t2 = "BB";
        System.out.println("s1 hashCode" + t1.hashCode());
        System.out.println("s1 hashCode" + t2.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 集合的“异常”

 只重写equals方法

package cn.itcast.interview;
 
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
 
/**
 * @author: msf
 * @date: 2022/11/26
 */
public class EqualsMyClassExample {
    public static void main(String[] args) {
        Person u1 = new Person();
        u1.setName("Java");
        u1.setAge(18);
 
        Person u2 = new Person();
        u2.setName("Java");
        u2.setAge(18);
 
        System.out.println("equals result = " + u1.equals(u2));
 
        // 创建 Set 集合
        Set set = new HashSet();
        set.add(u1);
        set.add(u2);
        // 打印 Set 中的所有数据
        set.forEach(System.out::println);
    }
}
 
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;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
 
        Person person = (Person) o;
        return age == person.age && Objects.equals(name,person.name);
    }
 
    /*@Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }*/
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

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

 这就造成了命名是相同值，为什么Set却重复存储呢？

下面对hashCode进行重写后结果

4 原因分析

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

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

总结

• hashCode 和 equals 两个方法是用来协同判断两个对象是否相等的，采用这种方式的原因是可以提高程序插入和查询的速度。
• 如果只重写equals方法，不重写hashCode方法，就有可能导致a.equals(b)这个表达式成立，但是hashCode却不同。会造成一个完全相同的对象会存储在hash表的不同位置。