为什么重写equals()方法必须要重写hashCode()方法？

约定不等于承诺〃 2023-05-31 12:14 3阅读 0赞

参考：[https://blog.csdn.net/qq\_31459039/article/details/89522735][https_blog.csdn.net_qq_31459039_article_details_89522735]

以下为本文目录：

首先我们分别解释equals()方法和hashCode()方法分别是用来做什么的？  
我们再来看equals()方法和hashCode()方法两者有什么关系？  
最后来看为什么重写equals()就一定要重写hashCode()方法？  
1、首先我们分别解释equals()方法和hashCode()方法分别是用来做什么的？  
equals()方法：  
很明显，该方法就是用来判断两个对象是否是同一个对象。在Object类源码（如下所示）中，其底层是使用了“==”来实现，也就是说通过比较两个对象的内存地址是否相同判断是否是同一个对象。

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

但是在实际应用中，该方法不能满足的我们的需求。因为我们认为两个对象即使不是指向的同一块内存，只要这两个对象的各个字段属性值都相同，那么就认为这两个对象是同一个对象。所以就需要重写equals（）方法，即如果两个对象指向内存地址相同或者两个对象各个字段值相同，那么就是同一个对象。

hashCode()方法：  
一提到hashcode，很自然就想到哈希表。将某一key值映射到表中的一个位置，从而达到以O(1)的时间复杂度来查询该key值。**Object类源码（如下所示）中，hashCode()是一个native方法**，***哈希值的计算利用的是内存地址***。

public native int hashCode();

可以认为利用哈希表也能起到一定的判重的作用，但是现实是可能存在哈希冲突，即使是两个不同的对象，他们的哈希值也可能相同，如何解决哈希冲突，这里就略略略了。总之，我们记住哈希表具有优越的查询性能，并且存在哈希冲突。

2、我们再来看equals()方法和hashCode()方法两者有什么关系？  
两者事实关系如下：   
**1. 如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同!；   
2. 如果两个对象不同（即用equals比较返回false），那么它们的hashCode值可能相同也可能不同；   
3. 如果两个对象的hashCode相同（存在哈希冲突），那么它们可能相同也可能不同(即equals比较可能是false也可能是true)   
4. 如果两个对象的hashCode不同，那么他们肯定不同(即用equals比较返回false)**

# 两个对象用equals方法比较为true，它们的Hashcode值相同吗？ #

答：不一定相同。正常情况下，因为equals()方法比较的就是对象在内存中的值，如果值相同，那么Hashcode值也应该相同。但是如果不重写hashcode方法，就会出现不相等(**默认比较的是内存中的地址值**)的情况。

3、最后来看为什么重写equals()就一定要重写hashCode()方法？  
对于对象集合的判重，如果一个集合含有10000个对象实例，仅仅使用equals()方法的话，那么对于一个对象判重就需要比较10000次，随着集合规模的增大，时间开销是很大的。但是同时使用**哈希表**的话，就能快速定位到对象的大概存储位置，并且在定位到大概存储位置后，后续比较过程中，如果两个对象的hashCode不相同，也不再需要调用equals（）方法，从而大大减少了equals()比较次数。   
所以从程序实现原理上来讲的话，既需要equals()方法，也需要hashCode()方法。那么既然重写了equals（），那么也要重写hashCode()方法，以保证两者之间的配合关系。   
基于以上分析，我们可以在Java集合框架中得到验证。由于***HashSet是基于HashMap***来实现的，所以这里只看HashMap的put方法即可。源码如下：

public V put(K key, V value) {
            if (table == EMPTY_TABLE) {
                inflateTable(threshold);
            }
            if (key == null)
                return putForNullKey(value);
            int hash = hash(key);
            //这里通过哈希值定位到对象的大概存储位置
            int i = indexFor(hash, table.length);
            for (Entry<K,V> e = table[i]; e != null; e = e.next) {
                Object k;
                //if语句中，先比较hashcode，再调用equals()比较
                //由于“&&”具有短路的功能，只要hashcode不同，也无需再调用equals方法
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
     
            modCount++;
            addEntry(hash, key, value, i);
            return null;
        }

我们在实际应用过程中，如果仅仅重写了equals（），而没有重写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;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Person)) return false;
            Person person = (Person) o;
            return getAge() == person.getAge() &&
                    Objects.equals(getName(), person.getName());
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        //    @Override
        //    public int hashCode() {
        //        return Objects.hash(getName(), getAge());
        //    }
    
        public static void main(String[] args) {
            Person p1 = new Person("Bob", 20);
            Person p2 = new Person("Bob", 20);
            Map<Person, String> map = new HashMap<Person, String>();
            map.put(p1, "person1");
            map.put(p2, "person1");
            System.out.println(map.toString());
        }
    }

输出结果：

1.\{Person\{name='Bob', age=20\}=person1, Person\{name='Bob', age=20\}=person1\}【重写equals()方法，未重写hashCode()方法】

2.\{Person\{name='Bob', age=20\}=person1\} 【重写equals()方法，重写hashCode()方法】

***字段属性值完全相同的两个对象因为hashCode不同，所以在hashmap中的table数组的下标不同，从而这两个对象就会同时存在于集合中，所以重写equals()就一定要重写hashCode()方法。  
同理 如果仅仅重写了hashCode()，而没有重写equals（）方法 在hashmap中的table数组的下标相同  但是没有重写equals()方法导致认为不是一个key不会覆盖,将会形成一个链表***

对于“***为什么重写equals()就一定要重写hashCode()方法？”这个问题应该是有个前提，就是你需要用到HashMap,HashSet,HashTable等Java*****哈希表*****集合***。用不到哈希表的话，其实仅仅重写equals()方法也可以吧。而工作中的场景是常常用到Java集合，所以Java官方建议 重写equals()就一定要重写hashCode()方法。

[https_blog.csdn.net_qq_31459039_article_details_89522735]: https://blog.csdn.net/qq_31459039/article/details/89522735