HashSet底层原理，为什么要重写hashCode()和equals()，重写equals()为什么一定要重写hashCode()

不念不忘少年蓝@ 2023-10-01 21:38 28阅读 0赞

#### 文章目录 ####

*  前言
 *  一、重写hashCode()和equal()小测试
 *   *  （1）未重写hashCode()和equal()
     *  （2）重写hashCode()和equal()
 *  二、重写equals()为什么一定要重写hashCode()？
 *  三、总结

--------------------

## 前言 ##

在写文章之前我阅读了这篇博客[https://blog.csdn.net/qq\_35868412/article/details/89380409][https_blog.csdn.net_qq_35868412_article_details_89380409]  
关于hashCode和equals方面介绍的很清晰，也很官方。但接下来的内容是我个人针对hashCode()、equals()这两个方法并结合HashSet底层源码进行的分析。

=====================  
重写hashCode()和equals()相信有不少小伙伴是在学HashMap或HashSet中接触到的，下面这篇文章彻底带你搞懂这两个方法的作用

--------------------

## 一、重写hashCode()和equal()小测试 ##

### （1）未重写hashCode()和equal() ###

首先来看下面这段代码，你们认为hashset集合的大小size()是多少？是1还是2？

public class Text {
        
        public static void main(String[] args) {
        
            HashSet<Object> hashSet = new HashSet<>();
            people people1= new people("张三");
            people people2= new people("张三");
            hashSet.add(people1);
            hashSet.add(people2);
            System.out.println(hashSet.size());
        }
    }
    class people{
        
        public String name;
    
        public people(String name) {
        
            this.name = name;
        }
    }

先来揭晓答案：2  
![在这里插入图片描述][04c31da3bcfa4d31808dd587d330c58b.png]  
有些人已经猜出来了，因为我们都知道HashSet集合的一个特点，那就是不允许集合中有重复值，而上面代码中people1和people2作为值并不是同一个对象（哪怕它们的属性一样），这两个引用都是存储在栈中，分别指向堆中不同的两个People实例，相信大家都知道。所以这里HashSet不会将它们作为相同值而去重。

不信的话我们先输出这两个对象的hashcode值。

System.out.println("people1的hashCode："+people1.hashCode());
    System.out.println("people2的hashCode："+people2.hashCode());
    
    结果：
    people1的hashCode：1360875712
    people2的hashCode：1625635731

很明显不一样，hashCode不同说明并不是同一个对象。

接下里再结合源码验证上面所述，首先我们追踪people2是怎么添加进hashset集合中发生了什么。  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16]  
图中看出，`HashSet.add()`底层实际上调用了`HashMap.put()`，和HashMap不同的是，**HashSet仅存储对象，HashMap存储键值对**。那HashSet底层调用put时不也是有key和value的吗。其实这里的key就是person2对象，value是一个叫`PRESENT`的东西，这里就不展开讲PRESENT是什么，它涉及到判断add和remove返回值问题。

继续看`putVal()`方法。只挑核心部分  
程序运行到这个地方，说明存放元素映射到桶中索引处没有元素，那么直接创建一个新节点  
![在这里插入图片描述][db550f678f75423dbb4c09e9ad477c77.png]  
查看一下当前数组中存放的对象个数 ---- 两个对象  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
当然这是不发生hash冲突的情况，如果发送了hash冲突呢？就会经过这段代码  
![在这里插入图片描述][193052c082e34f18af3e50e4e33ea0c5.png]  
但这段代码是不会返回true的，hash值是经过高低十六位异或运算的，哪怕有极小的概率相同，那么接下来的判断p.key==key是否相等也是不成立的，因为是person1和person2是两个不同的对象。好了关键来了**，后面的equals方法判断会不会是true呢？不可能。因为Object对象中的equals()在没重写之前，它就是判断两个对象的内存地址是否是相同的（对引用类型，==判断内存地址）。**  
![在这里插入图片描述][5b8336bbf67a4091b068cb25b5d2ec12.png]  
**总结：以上就是为什么size()为2的原因，因为存储对象不同，所以哪怕对象的属性（名称）相同，也不作为同一种元素，因此不会当做重复处理。**

那么问题来了，实际业务中，我们是希望person1和person2是同一个对象的，因为他们的名称都相同代表同一个人，现在我想让HashSet集合中只存放一个元素，能实现吗？

### （2）重写hashCode()和equal() ###

看下接下来的代码↓

public class Text {
        
        public static void main(String[] args) {
        
            HashSet<Object> hashSet = new HashSet<>();
            people people1= new people("1001","张三");
            people people2= new people("1001","张三");
            System.out.println("people1的hashCode："+people1.hashCode());
            System.out.println("people2的hashCode："+people2.hashCode());
            hashSet.add(people1);
            hashSet.add(people2);
            System.out.println(hashSet.size());
    
        }
    }
    class people{
        
        public String id;
        public String name;
    
        public people(String id, String name) {
        
            this.id = id;
            this.name = name;
        }
    
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            people people = (people) o;
            return Objects.equals(id, people.id) && Objects.equals(name, people.name);
        }
    
        @Override
        public int hashCode() {
        
            return Objects.hash(id, name);
        }
    }

我对People增加了id属性，并重写了hashCode()和equals()方法。运行结果如下：  
![在这里插入图片描述][7b21c4c9667642fa8c80a1b75fe5f744.png]  
结果显示，people1和people2的hashCode是相同的，并且size()大小也是1。为什么？它们两个不是两个不同的对象吗，为什么hashCode会相同？**这是因为原先的Object中的hashCode()方法是一个本地方法，它是为了给每个对象生成一个唯一的标识符。但是我经过重写hashCode()后，生成的hashCode值是按照People的id和name属性生成的，为了验证得到的hashCode相同，我们还需要看一下hash()计算的底层实现**。

return Objects.hash(id, name);  
先调用了Object.hash()，参数就是id、name。但底层实际上是调用了Array.hashCode()

public static int hash(Object... values) {
        
         return Arrays.hashCode(values);
     }

看看Array.hashCode()

public static int hashCode(Object a[]) {
        
        if (a == null)
            return 0;
    
        int result = 1;
    
        for (Object element : a)
            result = 31 * result + (element == null ? 0 : element.hashCode());
    
        return result;
    }

返回值是result，那么这段代码就是关键了----> result = 31 \* result + (element == null ? 0 : element.hashCode());  
这里又调用了一个hashCode方法，element.hashCode()，继续往下看

element.hashCode()  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
很明显答案出来了，最终还是调用的是String.hashCode()方法。其中`hash`表示该串的哈希值，在第一次调用hashCode方法时，字符串的哈希值被计算并且赋值给hash字段，之后再调用hashCode方法便可以直接取hash字段返回。  
![在这里插入图片描述][b08ddde9c1ac46e887851437e38efb2f.png]  
它是缓存字符串的哈希码，**也就是说，相同字符串因为这个缓存机制，都能获取到同样的hash值。所以就算people1和people2不是同一个对象，经过重写hashCode()后，因为它们的属性都是相同的，而字符串内容一样的String对象，调用String.hashCode()返回值也是一样的，所以最终得到的hashCode也是相同的。**

因为hashCode都是相同的，那么add的时候，经过hash计算，元素映射到数组的索引位置也是相同的，在运行到这一段代码的时候  
![在这里插入图片描述][b68563c2bbc54a019cac28b36031e018.png]

hash值相同，直接将p(people1)节点赋值给e(people2)，这是为了接下来的value覆盖。  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
直接覆盖了原先位置上的值，当然这个值是前面提到的PRESENT，实际上存储的对象并没有被覆盖。  
查看此时数组table中的元素个数（1，还是原来的对象即people1）  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_19_color_FFFFFF_t_70_g_se_x_16]

**总结:以上就是为什么size为1的原因，因为people1和people2的hashCode相同，所以并不会新增加一个元素，而只会进行vlaue的覆盖，不影响HashSet里面存储的对象。**

## 二、重写equals()为什么一定要重写hashCode()？ ##

个人理解：比如在HashSet中，因为只重写equals()的话，hashCode()依旧是调用Object.hashCode()，也就是说不同的对象生产的hashCode不同且唯一，那么就必然会新建一个节点。举个例子（只重写了equals时，且只进行两次元素添加）

第二次元素添加，当没有发生hash冲突的时候，存进来的元素就会作为一个新的节点。  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
如果发送了hash冲突（意味着桶处已有值），那么就会进行下面这段代码进行判断，由于没有重写hashCode()，那么不同对象的hashCode必然不同，&&具有短路性，这里if直接跳过

![在这里插入图片描述][4bfe0e588af64aa3aaf4492a24b8e24e.png]  
于是就会执行下面这段代码，拉链法，还是会创建一个新的节点。![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
**总结：所以这跟之前的size为2的例子是一样的，hashCode不同，代表对象不同，所以存储不会影响。但是在业务逻辑中就有问题了，people people1= new people(“1001”,“张三”);和people people1= new people(“1001”,“张三”);我希望的是只存储一个，那就必须要重写hashCode才行，重写之后才能保证它们逻辑上是同一个对象，这样才能符合业务逻辑。**

## 三、总结 ##

*  未重写hashCode和equals时，HashSet底层add()方法实际上是调用了HashMap的put()方法，当hashCode相同并且equals为true的时候，会进行覆盖value（PRESENT），但不影响对象的存储，对象并没有被覆盖，保证为Set的唯一性。
 *  重写了equals但没重写hashCode时，结果判断对象相等，但其hashCode却不一致。当使用hash集合类时，存放时会根据该类的hashcode方法，来确定其存放位置，如hashset，将无法过滤业务逻辑上相同的对象，因为不重写hashcode，会默认调用Object类的hashcode方法，计算出来的存放地址不一样，会导致能同时存放两个值相等的对象，产生混淆。

以上内容大部分基于个人研究，如果有错误还请指正！

[https_blog.csdn.net_qq_35868412_article_details_89380409]: https://blog.csdn.net/qq_35868412/article/details/89380409
[04c31da3bcfa4d31808dd587d330c58b.png]: https://img-blog.csdnimg.cn/04c31da3bcfa4d31808dd587d330c58b.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/9871d0bfd4be460495ae8b542e66f3ea.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5Yaw5qONaGZ2,size_20,color_FFFFFF,t_70,g_se,x_16
[db550f678f75423dbb4c09e9ad477c77.png]: https://img-blog.csdnimg.cn/db550f678f75423dbb4c09e9ad477c77.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/c19e41f773b14129a82086a16a8c02bf.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5Yaw5qONaGZ2,size_20,color_FFFFFF,t_70,g_se,x_16
[193052c082e34f18af3e50e4e33ea0c5.png]: https://img-blog.csdnimg.cn/193052c082e34f18af3e50e4e33ea0c5.png
[5b8336bbf67a4091b068cb25b5d2ec12.png]: https://img-blog.csdnimg.cn/5b8336bbf67a4091b068cb25b5d2ec12.png
[7b21c4c9667642fa8c80a1b75fe5f744.png]: https://img-blog.csdnimg.cn/7b21c4c9667642fa8c80a1b75fe5f744.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/31c12793d5194ab38770dcee21de5a5e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5Yaw5qONaGZ2,size_20,color_FFFFFF,t_70,g_se,x_16
[b08ddde9c1ac46e887851437e38efb2f.png]: https://img-blog.csdnimg.cn/b08ddde9c1ac46e887851437e38efb2f.png
[b68563c2bbc54a019cac28b36031e018.png]: https://img-blog.csdnimg.cn/b68563c2bbc54a019cac28b36031e018.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/c9def04bf6a44053b4e6de30ee604885.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5Yaw5qONaGZ2,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_19_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/362babf49c0d4c8ca1de9f8d3d9f6049.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5Yaw5qONaGZ2,size_19,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/5c95bd4a803c4975ad218092998ee3a2.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5Yaw5qONaGZ2,size_20,color_FFFFFF,t_70,g_se,x_16
[4bfe0e588af64aa3aaf4492a24b8e24e.png]: https://img-blog.csdnimg.cn/4bfe0e588af64aa3aaf4492a24b8e24e.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5Yaw5qONaGZ2_size_20_color_FFFFFF_t_70_g_se_x_16 5]: https://img-blog.csdnimg.cn/ae3de8a1798943c6902081ae6f56bf8b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5Yaw5qONaGZ2,size_20,color_FFFFFF,t_70,g_se,x_16

发表评论取消回复

表情：

评论列表（有 0 条评论，28人围观）

还没有评论，来说两句吧...

相关阅读

相关【重写 equals 时为什么一定要重写 hashCode？】

在Java中，equals和hashCode是一对重要的方法，通常需要同时重写它们。这是因为equals方法用于判断两个对象是否相等，而hashCode方法用于计算对象的哈希值

太过爱你忘了你带给我的痛/ 2024年03月26日 16:58/ 0 赞/ 159 阅读

相关重写equals为什么要重写hashcode

判断两个对象是否相等，我们需要先判断hashcode，在hashcode相等的条件下，再用equals进行比较，equals返回true，两个对象才相等。如果hashcode不

我就是我/ 2024年03月17日 22:48/ 0 赞/ 176 阅读

相关重写equals为什么要重写hashcode

当我们重写一个类的`equals`方法时，通常也需要同时重写`hashCode`方法。这是因为在Java中，`hashCode`方法和`equals`方法是相关联的： 1.

淡淡的烟草味﹌/ 2024年03月17日 21:00/ 0 赞/ 169 阅读

相关 HashSet底层原理，为什么要重写hashCode()和equals()，重写equals()为什么一定要重写hashCode()

文章目录前言一、重写hashCode()和equal()小测试（1）未重写hashCode()和equal() （2）重写ha

不念不忘少年蓝@/ 2023年10月01日 21:38/ 0 赞/ 29 阅读

相关为什么重写equals一定要重写hashcode？

[link1][]，[link2][]，[link3][]，[link4][]，[link5][]，[link6][] 主要是为了提升哈希表的性能。因为HashMap 集合类

缺乏、安全感/ 2023年03月06日 03:46/ 0 赞/ 127 阅读

相关为什么重写equals还要重写hashcode

为什么重写equals还要重写hashcode 1）简介 equals和hashcode都属于Object类的方法，其中hashcode为本地方法。 object中e

╰半夏微凉°/ 2023年01月05日 12:07/ 0 赞/ 325 阅读

相关为什么重写equals()一定要重写hashCode()？

因为hashMap，hashSet等数据结构是依赖hashCode判断两个对象是否是一致的，如重写了equals，不重写hashCode，会有以下问题。 ![water

心已赠人/ 2022年10月31日 05:28/ 0 赞/ 319 阅读

相关重写equals 为什么要重写hashCode方法

来源 [https://www.jianshu.com/p/3819388ff2f4][https_www.jianshu.com_p_3819388ff2f4] Obj

我就是我/ 2022年10月16日 09:52/ 0 赞/ 317 阅读

相关为什么重写equals一定要重写hashcode？

引言这篇文章已经是我很久之前写的，其中的内容表述得不太清楚，或多或少难以让人信服，于是我又写了一篇，链接如下： CSDN链接：[彻底搞懂为什么重写equals还要重写

朱雀/ 2022年05月24日 09:51/ 0 赞/ 367 阅读

相关为什么重写equals方法一定要重写hashcode方法

为什么重写equals方法一定要重写hashcode方法先来看看如果重写类的equals方法，但是没有重写hashcode方法会发生什么。例如：重写了一个类H

冷不防/ 2022年01月23日 12:25/ 0 赞/ 441 阅读