【027期】面试必问 hashCode() 和 equals() 及使用规范，你掌握了吗？

Java精选 2022-08-09

收录于合集

#面试题系列专栏 349 个

#面试官问 405 个

>>号外：关注“Java精选”公众号，回复“面试资料”，免费领取资料！“Java精选面试题”小程序，3000+ 道面试题在线刷，最新、最全 Java 面试题！

背景

在看阿里巴巴Java开发手册时，看到了有关hashCode()和equals()方法的使用规范。

建议重写equals，就必须重写hashCode。
因为设置存储的对象不是重复的对象，所以两个哈希码和等于进行判断，所以设置存储的对象必须改这方法。
如果自定义对象做为 Map 的键，那么必须重写 hashCode 和 equals。

并且举了String重写了hashCode和equals方法，所以我们可以非常愉快地使用String对象作为key来使用的例子。

我们看下String的hashCode()和equals()的源码：

String的hashCode()

哈希码（）：

private int hash; // Default to 0
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

代码没有一行的解释了，容易的从角度上说，我们也可以代码理解一些知识点。

恢复的恢复，这里的价值属性就作为恢复了。
新闻报道下时间是在使用时生成的。
计算 hash 时可以用类计算的属性值与 31 乘积。

为什么是31，而不是32，33等其他数字呢？

31是一个素数，素数的作用就是如果我用一个数字来乘以这个素数，那么最终的出来的结果只能被素数来整除乘数。
31由可以i*31 == (i<<5)-1来表示，现在很多虚拟机里面都有做相关优化。
选择因子的时候要选择耕大的系数。因为如果你的努力奋斗出来，重回的“难度”，寻找起来的效率也会提高。
并且 31 只占用 5bits，相乘造成数据引用的指责。

一次原则，HashCode 的设计继续介绍equals()。

字符串的equals()

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

equals 方法就没有好说的，为什么这么写，这里就跟equals 的设计原则有关，会解释什么。下面我们从开发者手册的三句话来解释hashCode 和equals 方法的特性，以及为什么要重新解释这两个方法。

想要重写equals，就必须重写hashCode

我们先举个例子: Person类:

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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 instanceof Person){
            Person p = (Person)o;
            return this.age == p.getAge() && this.name.equals(p.getName());
        }
        return false;
    }
}

运行类：

public class Application {
    public static void main(String[]args){
        Set<Person> set = new HashSet<>();
        Person p1 = new Person("Lilei", 25);
        Person p2 = new Person("Lilei", 25);
        set.add(p1);
        System.out.println("p1 equals p2: " + (p1 == p2));//1
        System.out.println("set contains p1: " + set.contains(p1));//2
        System.out.println("set contains p2: " + set.contains(p2));//3
    }
}

输出结果：

p1 equals p2: false
set contains p1: true
set contains p2: false

看出来p1虽然等于p2（我们换了个人类的方法），但是把p1可以动态一套，通过p2之后是无法取出来的，但是我们要的效果是可以通过p2取出来的，实景中肯定是有这样的使用场景的。

因为集存储不是重复的对象，两个哈希码和等于进行判断，所以集存储的对象必须改这方法

还是上面的例子，我们不改写人类的方法，也不改写它的hashCode。

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

运行类：

public class Application {
    public static void main(String[]args){
        Set<Person> set = new HashSet<>();
        Person p1 = new Person("Lilei", 25);
        Person p2 = new Person("Lilei", 25);
        set.add(p1);
        set.add(p2);
        System.out.println("set size is: " + set.size());
        //System.out.println("p1 equals p2: " + (p1 == p2));
        //System.out.println("set contains p1: " + set.contains(p1));
        //System.out.println("set contains p2: " + set.contains(p2));

    }
}

运行结果：

set size is: 2

设置里面是不重复的，如果不重写Person类的hashCode和等价的方法，这里p1和p2是可以同时动态设置对象里的。那么我们只重写了Person的hashCode方法能不能行呢？

@Override
public int hashCode(){
    return name.hashCode() * 31 + age;
}

运行结果：

set size is: 2

最后重写Person类的equals()方法：

@Override
public boolean equals(Object o){
    if(this == o){
        return true;
    }
    if(o instanceof Person){
        Person p = (Person)o;
        return this.age == p.getAge() && this.name.equals(p.getName());
    }
    return false;
}

@Override
public int hashCode(){
    return name.hashCode() * 31 + age;
}

运行结果：

set size is: 1

如果自定义对象做为 Map 的键，那么必须重写 hashCode() 和 equals()

这一点和第二点实际上是一样的，这里就不举例介绍了。
实际上，Set的对象和Map的key的操作和hashCode以及equals方法有关，比如查这个对象是否在Set里，先根据hashCode定位到一个段，在根据equals进行确定是否存在，这样不需要把Set里所有的对象都遍历一遍，效率太低，Map的key是同样道理。
那么hashCode和equals的设计原则就呼之欲出了。

equals()的设计原则

对称性：如果x.equals(y)返回为真，那么y.equals(x)也应该返回为真。
反射性：x.equals(x)必须返回为true。
类推性：如果x.equals(y)返回为true，而且y.equals(z)返回为true，那么z.equals(x)也应该返回为true。
一致性：如果x.equals(y)返回是真的，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是真的。
非空性：x.equals(null)，永远返回是false；x.equals(和x不同类型的对象)永远返回是false。

hashCode()的设计原则

在一个 Java 的执行期间，如果对象提供了一个等于做比较的信息，则该对象多次调用hashCode()方法，该方法必须始终如一返回同一个整数。
如果两个对象根据(Object)方法相同，则调用调用插件的hashCode()必须产生同一个整数结果。
不是根据要求equals(java.lang.Object) 不完全相同的两个对象，调用方法公开方法的hashCode()必须生成不同的eger结果。整数结果，有可能会提高哈希表的性能。