equals与hashCode之间的关系(重写equals方法与重写hashCode方法的关联)

最新推荐文章于 2024-03-02 09:15:00 发布

悬浮海

最新推荐文章于 2024-03-02 09:15:00 发布

阅读量483

点赞数

分类专栏： # 《On Java 8》 java基础文章标签：哈希算法 equals hashcode

本文链接：https://blog.csdn.net/wang_luwei/article/details/121056410

版权

java基础同时被 2 个专栏收录

80 篇文章 2 订阅

订阅专栏

《On Java 8》

9 篇文章 1 订阅

订阅专栏

文章目录

问题：

重写equals()就一定要重写hashCode()吗？
什么情况下需要两者都重写？
什么情况下两者不重写也无所谓？

一、equals()方法

equals()方法：

(1) 作用：用于判断两个对象是否相等；
(2) 实现：如果对象重写了equals()方法，重写的比较逻辑一般是比较两个对象的内容是否相等；如果没有重写，那就是比较的是两个对象的引用，等价于“==”；
(3) Object类：equals()定义在JDK的Object.java中，这就意味着Java中的任何类都包含有equals()函数，并且通过调用equals()方法比较两个引用相等，引用赋值就相等，浅复制和深复制都不相等。（具体可看：引用赋值、浅复制和深复制具体情况）

public class DemoTest {
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(obj.equals(obj));
    }
}

这段代码中，obj引用就是通过调用equals()方法来比较对象引用的。

二、hashCode()方法

hashCode() 方法：

(1) 作用：用于判断两个对象是否相等；
(2) 实现：通过获取到的哈希码来确定该对象在哈希表中的索引位置，哈希码也称散列码，实际上就是返回一个int整数；
(3) Object类：hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数，并且通过调用hashCode()方法获取对象的hash值。
hashCode()方法返回的就是一个数值，从方法的名称上就可以看出，其目的是生成一个hash码。hash码的主要用途就是在对对象进行散列的时候作为key输入，据此很容易推断出，我们需要每个对象的hash码尽可能不同，这样才能保证散列的存取性能。事实上，Object类提供的默认实现确实保证每个对象的hash码不同（在对象的内存地址基础上经过特定算法返回一个hash码）。Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是）。

public class DemoTest {
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(obj.hashCode());
    }
}

这段代码中，obj引用就是通过调用hashCode()方法来获取对象的hash值。

三、equals()与hashCode()的关系(相关规定)

equals不重写，判断的依然是对象引用：

两个对象相同，equals相等，hashCode一定相等
两个对象 == 相等，hashCode一定相等
两个对象 == 不相等，hashCode有可能相等（hash冲突的存在）
hashCode相等，两个对象不一定相等（hash冲突的存在）
a.equals(b) 必须与 a.hashCode() == b.hashCode()等值，但 a.hashCode() == b.hashCode()不一定要与a.equals(b) 等值

四、重写equals()与重写hashCode() 的关系

4.1、不会创建“该类对应的散列表”的情况

这里所说的“不会创建类对应的散列表”是说：我们不会在HashSet, HashTable, HashMap等这些本质是散列表的数据结构中使用该类作为泛型。在这种情况下，该类的“hashCode() 和 equals() ”没有半毛钱关系。

不会创建“类对应的散列表”的情况下，

(1) hashCode()：hashCode()除了打印引用所指向的对象地址看一看，没有任何调用，重写hashCode()逻辑也没有用，反正没有调用；（因为hashCode()得到的是对象在散列中的存放地址，这种情况下就不会用到散列表，那hashCode()得到的hash值还有什么用呢？）
(2) equals()：equals()用来比较，可以自定义比较逻辑；
(3) 关系：hashCode()和equals()是两个独立方法，没有任何关系，所以不存在重写equals()要重写hashCode()。

小结：当我们不在HashSet, HashTable, HashMap等等这些本质是散列表的数据结构中用到这个类，此时，equals() 用来比较该类的两个对象是否相等，而hashCode() 则根本没有任何作用，所以，不用理会hashCode()。

例子：

class Main2cumtomzieEquals {
    public static void main(String[] args) {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());
    }

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

        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        
        /**
         * 重写equals方法
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }

            // 如果是同一个对象返回true，反之返回false
            if (this == obj) {
                return true;   // 引用相同，返回为true
            }
            
            // 判断是否类型相同
            if (this.getClass() != obj.getClass()) {
                return false;   // getClass() 不相同，为false
            }
            Person person = (Person) obj;  // 引用赋值
            // name引用相同 && age引用相同
            return name.equals(person.name) && age == person.age;   
        }
    }
}
//运行结果：
p1.equals(p2) : true; p1(2133927002) p2(1836019240)
p1.equals(p3) : false; p1(2133927002) p3(1625635731)

这段程序证明：对于当我们不在HashSet, HashTable, HashMap等等这些本质是散列表的数据结构中用到这个类作为泛型，此时，这个类的hashCode() 和 equals()没有任何关系，在p1和p2使用equals()比较相等的情况下，hashCode()也不一定相等。

小结：不会创建“类对应的散列表”的情况下，

对于hashCode()：默认hashCode()仅仅返回一个int型哈希值，但是这个返回的哈希值没卵用（因为没用到散列表）；
对于equals()：默认的equals)比较两个引用是否相等，而我们自己重写的equals用来比较两类的属性是否相等，因为引用赋值，所有最后两个属性int string一定是一样的

Person person = (Person) obj; // 引用赋值
return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同

4.2、会创建“该类对应的散列表”的情况

这里所说的“会创建类对应的散列表”是说：我们会在HashSet, HashTable, HashMap等这些本质是散列表的数据结构中使用该类作为泛型

在会创建“类对应的散列表”的情况下，该类的“hashCode() 和 equals() ”是有关系的:

(1) 如果两个对象相等，那么它们的hashCode()值一定相同。这里的“对象相等”是指通过equals()比较两个对象时返回true。
(2) 如果两个对象hashCode()相等，它们的equals()不一定相等。因为在散列表中，hashCode()相等，即两个键值对的哈希值相等，然而哈希值相等，并不一定能得出键值对相等，此时就出现所谓的哈希冲突场景。

4.2.1 Set无法去重问题

自定义类作为HashSet的泛型，自定义类重写equals()，不重写hashCode()，equals()的return true的范围比hashCode() return 哈希值范围大，导致HashSet中中出现重复元素，举个例子，如下：

import java.util.HashSet;

class Main3cumtomizeEquals {
    public static void main(String[] args) {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        // 新建HashSet对象
        HashSet<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        // 比较p1 和 p2， 并打印它们的hashCode()
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        // 打印set
        System.out.printf("set:%s\n", set);
    }

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

        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }

        /**
         * 重写equals方法,当其 name引用相同 && age引用相同 的时候就认为它相同，
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }

            // 如果是同一个对象返回true，反之返回false
            if (this == obj) {
                return true;   // 引用相同，返回为true
            }
            
            // 判断是否类型相同
            if (this.getClass() != obj.getClass()) {
                return false;   // getClass() 不相同，为false
            }
            Person person = (Person) obj;  // 引用赋值
            // name引用相同 && age引用相同
            return name.equals(person.name) && age == person.age;   
        }
    }
}

//运行结果：
p1.equals(p2) : true; p1(2133927002) p2(1836019240)
set:[package1.Main3cumtomizeEquals$Person@6d6f6e28, package1.Main3cumtomizeEquals$Person@7f31245a, package1.Main3cumtomizeEquals$Person@135fbaa4]

结果分析：

问题：上面的程序中，重写了Person的equals()，但是，HashSet中仍然有重复元素：p1 和 p2。为什么会出现这种情况呢？

回答：因为虽然p1 和 p2的内容相等，但是它们的hashCode()不等，所以，HashSet在添加p1和p2的时候，认为它们不相等，从而导致存储HashSet存储重复元素。

4.2.2 哈希冲突问题

自定义类作为HashSet的泛型，自定义类重写equals()，并重写hashCode()，hashCode() return 哈希值范围比equals() return true范围大，造成哈希冲突，举个例子，如下：

import java.util.HashSet;

class Main4cumtomizeEqualsAndhashcode {

    public static void main(String[] args) {
        // 新建Person对象
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        Person p4 = new Person("EEE", 100);
        // 新建HashSet对象
        HashSet<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);
        // 比较p1 和 p2， 并打印它们的hashCode()
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        // 比较p1 和 p4， 并打印它们的hashCode()
        System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());
        // 打印set
        System.out.printf("set:%s\n", set);
    }

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

        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        
        /**
         * 重写equals方法,当其 name引用相同 && age引用相同 的时候就认为它相同
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }

            // 如果是同一个对象返回true，反之返回false
            if (this == obj) {
                return true;   // 引用相同，返回为true
            }
            
            // 判断是否类型相同
            if (this.getClass() != obj.getClass()) {
                return false;   // getClass() 不相同，为false
            }
            Person person = (Person) obj;  // 引用赋值
            // name引用相同 && age引用相同
            return name.equals(person.name) && age == person.age;   
        }
        
        /**
         * 重写hashCode方法,逻辑为  name的哈希值^age
         */
        @Override
        public int hashCode() {
            // 68517 ^ 100 = 68545
            // 64545 ^ 200 =68545
            // 68517 ^ 100 =68545
            int nameHash = name.toUpperCase().hashCode();
            return nameHash ^ age;   //  ^  异或运算，相同为0，不同为1
        }
    }
}
//运行结果：
p1.equals(p2) : true; p1(68545) p2(68545)   //
p1.equals(p4) : false; p1(68545) p4(68545)   //  hashcode相等，equals不相等，这样还是不好
set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]

结果分析：上面程序中，重写hashCode()的同时重写了equals()，equals()生效了，HashSet中没有重复元素。

因为在HashSet比较p1和p2时，HashSet会发现，它们的hashCode()相等，通过equals()比较它们也返回true，所以，HashSet将p1和p2被视为相等，不会存储多份。同样地，在比较p1和p4时，HashSet发现：虽然它们的hashCode()相等，但是通过equals()比较它们返回false，所以，HashSet将p1和p4被视为不相等，p1和p4各存储一份。

4.2.3 equals()和hashCode()完全对应

上面代码好的修改方法（让equals和hashcode完全对应）：

/**
 * 重写equals方法,当其 name引用相同 && age引用相同 的时候就认为它相同，
 */
@Override
public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }

    // 如果是同一个对象返回true，反之返回false
    if (this == obj) {
        return true;   // 引用相同，返回为true
    }

    // 判断是否类型相同
    if (this.getClass() != obj.getClass()) {
        return false;   // getClass() 不相同，为false
    }
    Person person = (Person) obj;  // 引用赋值
    // name引用相同 && age引用相同
    return name.equals(person.name) && age == person.age;   
}

/**
 * 重写hashCode方法,逻辑为  name的哈希值^age
 */
@Override
public int hashCode() {
    int nameHash = name.hashCode();
    return nameHash ^ age;   //  ^  异或运算，相同为0，不同为1
}

//最后返回:
p1.equals(p2) : true; p1(68545) p2(68545)   //  hashcode相等，equals相等
p1.equals(p4) : false; p1(68545) p4(68548)   //  hashcode不相等，equals不相等
set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]

4.2.4 进一步解释为什么重写equals()就要重写hashCode()

/**
 * HashSet部分
 */
public boolean add (E e){
    return map.put(e, PRESENT) == null;
}

/**
 * map.put方法部分
 */
public V put (K key, V value){
    return putVal(hash(key), key, value, false, true);
}

/**
 * putVal方法部分
 */
final V putVal ( int hash, K key, V value,boolean onlyIfAbsent, boolean evict){
    Node<K, V>[] tab;
    Node<K, V> p;
    int n, i;
    if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);
    else {
        Node<K, V> e;
        K k;
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;
        else if (p instanceof TreeNode) e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break;
                p = e;
            }
        }
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null) e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold) resize();
    afterNodeInsertion(evict);
    return null;
}

由上面HashSet源码可知，HashSet使用的是HashMap的put方法，而hashMap的put方法，使用hashCode()用key作为参数计算出hash值，然后进行比较，如果相同，再通过equals()比较key值是否相同，如果相同，返回同一个对象。

所以，如果类使用在散列表的集合对象中，要判断两个对象是否相同，除了要覆盖equals()之外，也要覆盖hashCode()函数，否则，equals()无效。（重写的目标是： equals()和hashCode()完全对应，这是因为散列表结构中判断两个对象是否相等，会先判断hash值，再判断equals()。）

所以，在HashSet中，一定要同时重写hashCode()和equals()，HashSet底层是由于HashMap的数据结构（数组+链表/红黑树）的比较逻辑决定的。

五、面试

5.1 为什么重写equals()一定要重写hashCode()

5.1.1 不会创建“类对应的散列表”的情况

当我们不在HashSet, HashTable, HashMap等这些本质是散列表的数据结构中，用到这个类作为泛型，此时，这个类的hashCode() 和 equals()没有任何关系；

equals()方法
(1) 作用： equals() 用来比较该类的两个对象是否相等。
(2) 实现：equals未被重写就直接进行引用比较，源码如下：

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

若equals已被重写，就按照自己的重写equals逻辑来。

hashCode()：默认的hashcode()就是返回哈希值，但是此时返回的哈希值根本没有任何作用（因为没用到散列表），不用理会hashCode()。

当我们不在HashSet, HashTable, HashMap等等这些本质是散列表的数据结构中，用到这个类作为泛型（就不存在hash冲突啊），这种情况下，

(1) 不重写equals，不重写hashCode()

equals直接比较引用，hashCode()也是直接返回对象地址，所以，equals()与hashCode()完全对应，即对于两个引用：
- equals为true，hashCode()一定相等；
- equals为false，hashCode()一定不相等；
- hashCode()相等，equals一定为true；
- hashCode()不相等，equals一定为false。
(2) 重写equals()让其比较对象的属性，不重写hashCode()
- 如果equals()相等，表示两个引用相等或两个引用指向的对象各个属性(基本类型+String)相等，hashcode()不一定相等（理由：因为一定要并且只有两个引用相等，指向的对象地址才相等）。
- 如果hashCode()相等，表示两个引用指向的对象哈希地址相等，则引用相等（因为对象哈希地址是任意分配的），equals()一定相等（未重写时比较引用相等，但现在已重写）。
- 如果equals不相等，表示两个引用一定不相等，hashcode()两个引用所指向的对象地址一定不相等（因为哈希地址随机分配）。
- 如果hashcode不相等，两个引用指向的对象地址不相等，equals()可以相等，可以不相等。（因为equals()还会比较属性）

小结：不能说明equals()和hashCode()有关系，只是因为重写equals()把return true的条件放宽了，只要两个引用指向的对象中属性相等就好，不一定引用相等，但是hashCode()还是返回对象地址。

5.1.2 创建“类对应的散列表”的情况下

当我们在HashSet, HashTable, HashMap等等这些本质是散列表的数据结构中，用到这个类，就是这个类作为集合框架的泛型，此时，这个类的hashCode() 和 equals()紧密相关；因为这些散列表数据结构，对其泛型，要求两个引用所指向的对象hashCode() 和 equals()均相同，才认为是同一个对象。

(1) 重写equals()让其比较对象的属性，不重写hashCode()

equals()相等，hashcode()可以不相等：HashSet中放入两个具有相同属性的Person对象，两个Person对象属性相同，所以equals比较两个引用得到的结果相等，但是底层指向不同的对象地址，因此hashcode不相等，则HashSet在添加p1和p2的时候认为它们不相等，所以，HashSet中仍然有重复元素：p1 和 p2。

这说明默认的hashcode()不够好，一个好的哈希算法不应该让HashSet中有重复元素。因为equals()的判断要和hashCode()的判断完全对应，默认的equals()和hashCode()就是比较引用和对象地址的，我们重写的equals()和hashCode()，是比较引用所指向的对象的个数属性的，总之，equals()和hashCode()要一一对应，所以重写equals()就要重写hashCode()。

(2) 重写equals为比较对象的属性，并且重写hashCode()

重写的equals()：两个引用相等或者两个引用所指向的对象的属性相等，返回true，其余返回为false。
重写的hashCode()： name的哈希值^age，异或运算，相同为0，不同为1。
重写equals并且重写hashCode()，三种情况如下：
- ① equals相等，hashcode()不相等：HashSet集合中的内容相同的元素(这就是重写equals，不重写hashcode带来的问题);
- ② equals相等，hashcode()相等：完全对应;
- ③ hashCode()相等，equals不相等：HashMap中的哈希冲突.

在完全对应的情况下，在HashSet看来：比较p1和p2，它们的hashCode()相等，通过equals()比较它们也返回true，所以p1和p2被视为相等；比较p1和p4，虽然它们的hashCode()相等；但是，通过equals()比较它们返回false，p1和p4被视为不相等。

5.1.3 总结：

(1) 在不会创建“类对应的散列表”情况下，hashcode除了打印引用所指向的对象地址看一看，没有任何调用，重写hashcode逻辑也没有用，反正没有调用，equals用来比较，可以自定义比较逻辑，hashcode和equals是两个独立方法，没有任何关系，不存在重写equals要重写hashcode。
(2) 当我们在HashSet, HashTable, HashMap等等这些本质是散列表的数据结构中，用到这个类，就是这个类作为集合框架的泛型，此时，这个类的hashCode() 和 equals()紧密相关，因为这些散列表数据结构，对其泛型，要求两个引用所指向的对象hashCode() 和 equals()均相同，才认为是同一个对象。

5.2 hashCode()底层实现，一个好的哈希算法

理论上，一个好的hashCode的方法的目标：为不相等的对象（equals为false）产生不相等的散列码，同样的，相等的对象（equals为true）必须拥有相等的散列码，即equals和hashcode对应，像默认的那样，既不会出现hashcode相等，equals不相等的哈希冲突，也不会出现equals相等，hashcode不相等造成HashSet存放equals为true的元素。

实践上，一般来说，hashcode相等，equals不相等的哈希冲突还能忍受，但是equals相等造成hashcode不相等，造成HashSet存放相同是一定不能忍受的，就是说，重写equals放宽return true，一定要重写hashcode放宽return 哈希码，

验证本文中心问题：一定要hashcode范围和equals范围一样大，如果不能保证，就让hashcode范围比equals范围大，允许哈希冲突，不允许HashSet存放重复元素。

悬浮海

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
equals与hashCode之间的关系(重写equals方法与重写hashCode方法的关联)

文章目录一、equals()方法二、hashCode()方法三、equals()与hashCode()的关系(相关规定)四、重写equals()与重写hashCode() 的关系4.1、不会创建“该类对应的散列表”的情况4.2、会创建“该类对应的散列表”的情况4.2.1 Set无法去重问题4.2.2 哈希冲突问题4.2.3 equals()和hashCode()完全对应4.2.4 进一步解释为什么重写equals()就要重写hashCode()五、面试5.1 为什么重写equals()一定要重写hashCo
复制链接

扫一扫