当前位置：网站首页>重写equals为什么要重写hashcode

重写equals为什么要重写hashcode

2022-07-17 00:33:00 【51CTO】

重写equals为什么要重写hashcode？

前提

先了解下object 类

       
       public 
       
       class 
       
       Object {
       
       // 比较内存地址是否相等
       
       public 
       
       boolean 
       
       equals(
       
       Object 
       
       obj) {
       
       return (
       
       this 
       
       == 
       
       obj);
       
    }
       
       //把对象的内部地址转换成一个整数，也就是hash值
       
       public 
       
       native 
       
       int 
       
       hashCode();
       
       //........省略部分代码.............
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

实例

假设在业务上，我们认为名字相同的便是同一个人

       
       public 
       
       class 
       
       Student {
       
       private 
       
       String 
       
       name;
       
       private 
       
       Integer 
       
       age;
       
       // ....省略getter和 setter方法....
       
       @Override
       
       public 
       
       boolean 
       
       equals(
       
       Object 
       
       o) { 
       
       //我们认为名字相同的便是同一个人
       
       if (
       
       this 
       
       == 
       
       o) 
       
       return 
       
       true;
       
       if (
       
       o 
       
       == 
       
       null 
       
       || 
       
       getClass() 
       
       != 
       
       o.
       
       getClass()) 
       
       return 
       
       false;
       
       Student 
       
       student 
       
       = (
       
       Student) 
       
       o;
       
       return 
       
       Objects.
       
       equals(
       
       name, 
       
       student.
       
       name);
       
    }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

猜想

如果不重写 hashcode 会发生什么

       
       public 
       
       static 
       
       void 
       
       main(
       
       String[] 
       
       args) {
       
       Map
       
       <
       
       Object, 
       
       Object
       
       > 
       
       map 
       
       = 
       
       new 
       
       HashMap
       
       <>(
       
       4);
       
       Student 
       
       student1 
       
       = 
       
       new 
       
       Student(
       
       "zhangsan", 
       
       11);
       
       Student 
       
       student2 
       
       = 
       
       new 
       
       Student(
       
       "zhangsan", 
       
       22);
       
       map.
       
       put(
       
       student1,
       
       student1);
       
       map.
       
       put(
       
       student2,
       
       student2);
       
       System.
       
       out.
       
       println(
       
       map.
       
       size());
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.

下面看看map的put操作发生了什么？

       
       //hashmap的hash算法
       
       static 
       
       final 
       
       int 
       
       hash(
       
       Object 
       
       key) {
       
       int 
       
       h;
       
       return (
       
       key 
       
       == 
       
       null) 
       
       ? 
       
       0 : (
       
       h 
       
       = 
       
       key.
       
       hashCode()) 
       
       ^ (
       
       h 
       
       >>> 
       
       16);
       
}
       
       public 
       
       V 
       
       put(
       
       K 
       
       key, 
       
       V 
       
       value) {
       
       return 
       
       putVal(
       
       hash(
       
       key), 
       
       key, 
       
       value, 
       
       false, 
       
       true);
       
}
       
       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;
       
       //1、先比较key的hash值是否相等，再比较key的内存地址是否相等 或者 key的 equals 是否相等
       
       if (
       
       p.
       
       hash 
       
       == 
       
       hash 
       
       &&
       
            ((
       
       k 
       
       = 
       
       p.
       
       key) 
       
       == 
       
       key 
       
       || (
       
       key 
       
       != 
       
       null 
       
       && 
       
       key.
       
       equals(
       
       k))))
       
       e 
       
       = 
       
       p;
       
       //2、hash不相等，再比较是不是TreeNode类型
       
       else 
       
       if (
       
       p 
       
       instanceof 
       
       TreeNode)
       
       e 
       
       = ((
       
       TreeNode
       
       <
       
       K,
       
       V
       
       >)
       
       p).
       
       putTreeVal(
       
       this, 
       
       tab, 
       
       hash, 
       
       key, 
       
       value);
       
       //3、链表是否存在相等节点
       
       else {
       
       for (
       
       int 
       
       binCount 
       
       = 
       
       0; ; 
       
       ++
       
       binCount) {
       
       if ((
       
       e 
       
       = 
       
       p.
       
       next) 
       
       == 
       
       null) { 
       
       //当前链表的下一个节点是空的
       
       p.
       
       next 
       
       = 
       
       newNode(
       
       hash, 
       
       key, 
       
       value, 
       
       null);
       
       //添加新节点
       
       if (
       
       binCount 
       
       >= 
       
       TREEIFY_THRESHOLD 
       
       - 
       
       1) 
       
       // 链表长度大于等于 7 ，树化，退出循环
       
       treeifyBin(
       
       tab, 
       
       hash);
       
       break;  
       
                }
       
       //下一个节点是否要添加的节点相等，是退出循环
       
       if (
       
       e.
       
       hash 
       
       == 
       
       hash 
       
       &&
       
                    ((
       
       k 
       
       = 
       
       e.
       
       key) 
       
       == 
       
       key 
       
       || (
       
       key 
       
       != 
       
       null 
       
       && 
       
       key.
       
       equals(
       
       k))))
       
       break;
       
       //继续往链表后面走
       
       p 
       
       = 
       
       e;
       
            }
       
        }
       
       //如果链表中存在相同节点，返回旧值
       
       if (
       
       e 
       
       != 
       
       null) { 
       
       // existing mapping for key
       
       V 
       
       oldValue 
       
       = 
       
       e.
       
       value;
       
       if (
       
       !
       
       onlyIfAbsent 
       
       || 
       
       oldValue 
       
       == 
       
       null)
       
       e.
       
       value 
       
       = 
       
       value;
       
       afterNodeAccess(
       
       e);
       
       return 
       
       oldValue;
       
        }
       
    }
       
       ++
       
       modCount;
       
       if (
       
       ++
       
       size 
       
       > 
       
       threshold)
       
       resize();
       
       afterNodeInsertion(
       
       evict);
       
       return 
       
       null;
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.

我们发现当有冲突时，判断的顺序如下

先比较key的hash值是否相等，再比较key的内存地址是否相等或者 key的 equals 是否相等
hash不相等，再比较是不是TreeNode类型
链表是否存在相等节点

由于我们认为名字相同的便是同一个人
当 put 的时候，先比较 student1 和 student2 的 hash 值，由于 student1 和 student2 是不同的对象，他们的 hashcode 方法是调用的 object.hashcode 方法，比较的是对象的地址，很明显，下面这个方法算出来的hash是不相等的

       
       //hashmap的hash算法
       
       static 
       
       final 
       
       int 
       
       hash(
       
       Object 
       
       key) {
       
       int 
       
       h;
       
       return (
       
       key 
       
       == 
       
       null) 
       
       ? 
       
       0 : (
       
       h 
       
       = 
       
       key.
       
       hashCode()) 
       
       ^ (
       
       h 
       
       >>> 
       
       16);
       
}
      
1.
2.
3.
4.
5.

hash值不相等，也不是TreeNode类型，添加进链表

矛盾了

可是现在名字相同，但是在map中却存在两个人，很明显违背了我们的初衷
很明显，矛盾产生的原因就是调用了 object.hashcode 方法，计算出了不相等的hash值，如果hash值相等，便能满足下面的 if 语句

       
       //1、先比较key的hash值是否相等，再比较key的内存地址是否相等 或者 key的 equals 是否相等
       
       if (
       
       p.
       
       hash 
       
       == 
       
       hash 
       
       && ((
       
       k 
       
       = 
       
       p.
       
       key) 
       
       == 
       
       key 
       
       || (
       
       key 
       
       != 
       
       null 
       
       && 
       
       key.
       
       equals(
       
       k))))
       
       e 
       
       = 
       
       p;
      
1.
2.
3.

于是乎，我想设计使得名字相同的 student 产生相同的hash值

重写hashcode

我们知道不同的值可能会产生相同的hash值，但是在map中这个问题是不存在的，因为当hash值相等时，还会比较它的 equals方法，但是我们也应该尽量避免hash的碰撞，毕竟hash碰撞对性能还是有点影响的

       
       @Override
       
       public 
       
       int 
       
       hashCode() {
       
       return 
       
       Objects.
       
       hash(
       
       name);
       
}
      
1.
2.
3.
4.