HashMap之Hash碰撞源码解析

转自：https://blog.csdn.net/luo_da/article/details/77507315

　　https://www.cnblogs.com/tongxuping/p/8276198.html

HashMap是最常用的集合类框架之一，它实现了Map接口，所以存储的元素也是键值对映射的结构，并允许使用null值和null键，其内元素是无序的，如果要保证有序，可以使用LinkedHashMap。HashMap是线程不安全的，下篇文章会讨论。HashMap的类关系如下：

　　　　java.util 

　　　　Class HashMap

　　　　　　java.lang.Object

  　　　　　　　　|--java.util.AbstractMap

    　　　　　　　　　　  |--java.util.HashMap

所有已实现的接口：

　　Serializable,Cloneable,Map

直接已知子类：

　　LinkedHashMap,PrinterStateReasons

 

　　HashMap中用的最多的方法就属put() 和 get() 方法；HashMap的Key值是唯一的，那如何保证唯一性呢？我们首先想到的是用equals比较，没错，这样可以实现，但随着内部元素的增多，put和get的效率将越来越低，这里的时间复杂度是O(n)，假如有1000个元素，put时最差情况需要比较1000次。实际上，HashMap很少会用到equals方法，因为其内通过一个哈希表管理所有元素，哈希是通过hash单词音译过来的，也可以称为散列表，哈希算法可以快速的存取元素，当我们调用put存值时，HashMap首先会调用Key的hash方法，计算出哈希码，通过哈希码快速找到某个存放位置（桶），这个位置可以被称之为bucketIndex，但可能会存在多个元素找到了相同的bucketIndex，有个专业名词叫碰撞，当碰撞发生时，这时会取到bucketIndex位置已存储的元素，最终通过equals来比较，equals方法就是碰撞时才会执行的方法，所以前面说HashMap很少会用到equals。HashMap通过hashCode和equals最终判断出Key是否已存在，如果已存在，则使用新Value值替换旧Value值，并返回旧Value值，如果不存在 ，则存放新的键值对到bucketIndex位置。通过下面的流程图来梳理一下整个put过程。

 　　　　　　　　　　

 

 

最终HashMap的存储结构会有这三种情况，我们当然期望情形3是最少发生的（效率最低）。

 

HashMap 碰撞问题处理：

　　碰撞：所谓“碰撞”就上面所述是多个元素计算得出相同的hashCode，在put时出现冲突。

　　处理方法：

　　Java中HashMap是利用“拉链法”处理HashCode的碰撞问题。在调用HashMap的put方法或get方法时，都会首先调用hashcode方法，去查找相关的key，当有冲突时，再调用equals方法。hashMap基于hasing原理，我们通过put和get方法存取对象。当我们将键值对传递给put方法时，他调用键对象的hashCode()方法来计算hashCode，然后找到bucket（哈希桶）位置来存储对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当碰撞发生了，对象将会存储在链表的下一个节点中。hashMap在每个链表节点存储键值对对象。当两个不同的键却有相同的hashCode时，他们会存储在同一个bucket位置的链表中。键对象的equals()来找到键值对。

 HashMap基本结构概念图：

　　　　　　

 

到目前为止，我们了解了两件事：

　　1、HashMap通过键的hashCode来快速的存取元素。

　　2、当不同的对象发生碰撞时，HashMap通过单链表来解决，将新元素加入链表表头，通过next指向原有的元素。单链表在Java中的实现就是对象的引用(复合)。

HashMap.put()和get()源码：

 

 1 /** 
 2  * Returns the value to which the specified key is mapped, 
 3  * or if this map contains no mapping for the key. 
 4  * 
 5  * 获取key对应的value 
 6  */  
 7 public V get(Object key) {  
 8     if (key == null)  
 9         return getForNullKey();  
10     //获取key的hash值  
11     int hash = hash(key.hashCode());  
12     // 在“该hash值对应的链表”上查找“键值等于key”的元素  
13     for (Entry e = table[indexFor(hash, table.length)];  
14          e != null;  
15          e = e.next) {  
16         Object k;  
17         if (e.hash == hash && ((k = e.key) == key || key.equals(k)))  
18             return e.value;  
19     }  
20     return null;  
21 }  
22 
23 /** 
24  * Offloaded version of get() to look up null keys.  Null keys map 
25  * to index 0.   
26  * 获取key为null的键值对，HashMap将此键值对存储到table[0]的位置 
27  */  
28 private V getForNullKey() {  
29     for (Entry e = table[0]; e != null; e = e.next) {  
30         if (e.key == null)  
31             return e.value;  
32     }  
33     return null;  
34 }  
35 
36 /** 
37  * Returns true if this map contains a mapping for the 
38  * specified key. 
39  * 
40  * HashMap是否包含key 
41  */  
42 public boolean containsKey(Object key) {  
43     return getEntry(key) != null;  
44 }  
45 
46 /** 
47  * Returns the entry associated with the specified key in the 
48  * HashMap.   
49  * 返回键为key的键值对 
50  */  
51 final Entry getEntry(Object key) {  
52     //先获取哈希值。如果key为null，hash = 0；这是因为key为null的键值对存储在table[0]的位置。  
53     int hash = (key == null) ? 0 : hash(key.hashCode());  
54     //在该哈希值对应的链表上查找键值与key相等的元素。  
55     for (Entry e = table[indexFor(hash, table.length)];  
56          e != null;  
57          e = e.next) {  
58         Object k;  
59         if (e.hash == hash &&  
60             ((k = e.key) == key || (key != null && key.equals(k))))  
61             return e;  
62     }  
63     return null;  
64 }  
65 
66 
67 /** 
68  * Associates the specified value with the specified key in this map. 
69  * If the map previously contained a mapping for the key, the old 
70  * value is replaced. 
71  * 
72  * 将“key-value”添加到HashMap中，如果hashMap中包含了key，那么原来的值将会被新值取代 
73  */  
74 public V put(K key, V value) {  
75     //如果key是null，那么调用putForNullKey(),将该键值对添加到table[0]中  
76     if (key == null)  
77         return putForNullKey(value);  
78     //如果key不为null，则计算key的哈希值，然后将其添加到哈希值对应的链表中  
79     int hash = hash(key.hashCode());  
80     int i = indexFor(hash, table.length);  
81     for (Entry e = table[i]; e != null; e = e.next) {  
82         Object k;  
83         //如果这个key对应的键值对已经存在，就用新的value代替老的value。  
84         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
85             V oldValue = e.value;  
86             e.value = value;  
87             e.recordAccess(this);  
88             return oldValue;  
89         }  
90     }  
91 
92     modCount++;  
93     addEntry(hash, key, value, i);  
94     return null;  
95 }

 

从HashMap的put()和get方法实现中可以与拉链法解决hashCode冲突解决方法相互印证。并且从put方法中可以看出HashMap是使用Entry来存储数据。

Java8碰撞优化提升

　　　为什么会有这么大的性能提升，尽管这里用的是大O符号（大O描述的是渐近上界）？其实这个优化在JEP-180中已经提到了。如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。这个性能提升有什么用处？比方说恶意的程序，如果它知道我们用的是哈希算法，它可能会发送大量的请求，导致产生严重的哈希碰撞。然后不停的访问这些key就能显著的影响服务器的性能，这样就形成了一次拒绝服务攻击（DoS）。JDK 8中从O(n)到O(logn)的飞跃，可以有效地防止类似的攻击，同时也让HashMap性能的可预测性稍微增强了一些。