重写 equals 时为什么一定要重写 hashCode

equals 方法和 hashCode 方法是 Object 类中的两个基础方法，它们共同协作来判断两个对象是否相等。为什么要这样设计嘞？

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

为了解答这个问题，可以结合 Set 集合来讲解

1、Set 正常

package equalsAndHashCode.demo1;

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

/**
 * @author AlenLin
 * @version 1.0
 * @DESCRIPTION TODO
 * @date 2024/4/12 10:04
 */

//Set 集合是用来保存不同对象的，相同的对象就会被 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 集合最大的特点
    }

}

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

2、Set 异常

package equalsAndHashCode.demo2;

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

/**
 * @author AlenLin
 * @version 1.0
 * @DESCRIPTION TODO
 * @date 2024/4/12 10:06
 */


//然而，如果我们在 Set 集合中存储的是，只重写了 equals 方法的自定义对象时，
// 有趣的事情就发生了
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 方法的问题所在。

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

3、重写equals和hashcode解决异常

package equalsAndHashCode.demo3;

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

/**
 * @author AlenLin
 * @version 1.0
 * @DESCRIPTION TODO
 * @date 2024/4/12 10:11
 */


//为了解决demo2的问题，我们尝试在重写 equals 方法时，把 hashCode 方法也一起重写了，实现代码如下：
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 集合又恢复正常了。

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

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

4、总结

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