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

最新推荐文章于 2023-12-22 22:37:59 发布

兜兜转转m

最新推荐文章于 2023-12-22 22:37:59 发布

阅读量1.6k

点赞数 6

分类专栏： Java面试文章标签： java 开发语言面试

本文链接：https://blog.csdn.net/abc123mma/article/details/128051897

版权

Java面试专栏收录该内容

7 篇文章 0 订阅

订阅专栏

先放结论：

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<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 集合的“异常”

只重写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<Person> set = new HashSet<Person>();
        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表的不同位置。