HashMap：JDK7 與 JDK8 的實現

JDK7中的HashMap

HashMap底層維護一個數組，數組中的每一項都是一個Entry：

1 transient Entry<K,V>[] table;

咱們向在HashMap 中存放的對象其實是存儲在該數組當中的：Map中的key，value則以Entry的形式存放在數組中。

 

1 static class Entry<K,V> implements Map.Entry<K,V> {
2         final K key;
3         V value;
4         Entry<K,V> next;
5         int hash;
6 }

 

而這個Entry應該放在數組的哪個位置上（這個位置一般稱爲位桶或者hash桶，即hash值相同的Entry會放在同一位置，用鏈表相連），是經過key的hashCode來計算的。

 

1 final int hash(Object k) {
2         int h = 0;
3         h ^= k.hashCode();
4         h ^= (h >>> 20) ^ (h >>> 12);
5         return h ^ (h >>> 7) ^ (h >>> 4);
6 }

 

經過hash計算出來的值將會使用indexFor方法找到它應該所在的table下標：

 

1 static int indexFor(int h, int length) {
2         return h & (length-1);
3 }

 

這個方法其實至關於對table.length取模。當兩個key經過hashCode計算相同時，則發生了hash衝突(碰撞)，HashMap解決hash衝突的方式是用鏈表。當發生hash衝突時，則將存放在數組中的Entry設置爲新值的next（這裏要注意的是，好比A和B都hash後都映射到下標i中，以前已經有A了，當map.put(B)時，將B放到下標i中，A則爲B的next，因此新值存放在數組中，舊值在新值的鏈表上），如圖所示：

因此當hash衝突不少時，HashMap退化成鏈表。

 

 

總結一下map.put的過程：

 

當向 HashMap 中 put 一對鍵值時，它會根據 key的 hashCode 值計算出一個位置， 該位置就是此對象準備往數組中存放的位置。 

 

若是該位置沒有對象存在，就將此對象直接放進數組當中；若是該位置已經有對象存在了，則順着此存在的對象的鏈開始尋找(爲了判斷是不是否值相同，map不容許<key,value>鍵值對重複)， 若是此鏈上有對象的話，再去使用 equals方法進行比較，若是對此鏈上的每一個對象的 equals 方法比較都爲 false，則將該對象放到數組當中，而後將數組中該位置之前存在的那個對象連接到此對象的後面。 

 

值得注意的是，當key爲null時，都放到table[0]中

 

 

 1 private V putForNullKey(V value) {
 2         for (Entry<K,V> e = table[0]; e != null; e = e.next) {
 3             if (e.key == null) {
 4                 V oldValue = e.value;
 5                 e.value = value;
 6                 e.recordAccess(this);
 7                 return oldValue;
 8             }
 9         }
10         modCount++;
11         addEntry(0, null, value, 0);
12         return null;
13 }

 

當size大於threshold時，會發生擴容。 threshold等於capacity*load factor

 

1 void addEntry(int hash, K key, V value, int bucketIndex) {
2         if ((size >= threshold) && (null != table[bucketIndex])) {
3             resize(2 * table.length);
4             hash = (null != key) ? hash(key) : 0;
5             bucketIndex = indexFor(hash, table.length);
6         }
7 
8         createEntry(hash, key, value, bucketIndex);
9 }

 

 

jdk7中resize，只有當 size>=threshold而且 table中的那個槽中已經有Entry時，纔會發生resize。即有可能雖然size>=threshold，可是必須等到每一個槽都至少有一個Entry時，纔會擴容。還有注意每次resize都會擴大一倍容量。默認的容量很是小 若存儲的數據太多的話 須要resize的次數就會越多 resize是空間和時間消耗都很是驚人的內部操做 他須要new一個容量更大的table 而後把原來的table重新散列到新的table中去因此，當目標數據太多時  能夠增大初始化因子 使得一開始就建立一個大容量的table 減小resize的次數。

 

JDK8中的HashMap

 

一直到JDK7爲止，HashMap的結構都是這麼簡單，基於一個數組以及多個鏈表的實現，hash值衝突的時候，就將對應節點以鏈表的形式存儲。

這樣子的HashMap性能上就抱有必定疑問，若是說成百上千個節點在hash時發生碰撞，存儲一個鏈表中，那麼若是要查找其中一個節點，那就不可避免的花費O(N)的查找時間，這將是多麼大的性能損失。這個問題終於在JDK8中獲得瞭解決。再最壞的狀況下，鏈表查找的時間複雜度爲O(n),而紅黑樹一直是O(logn),這樣會提升HashMap的效率。

JDK7中HashMap採用的是位桶+鏈表的方式，即咱們常說的散列鏈表的方式，而JDK8中採用的是位桶+鏈表/紅黑樹（有關紅黑樹請查看紅黑樹）的方式，也是非線程安全的。當某個位桶的鏈表的長度達到某個閥值的時候，這個鏈表就將轉換成紅黑樹。

 

JDK8中，當同一個hash值的節點數不小於8時，將再也不以單鏈表的形式存儲了，會被調整成一顆紅黑樹（上圖中null節點沒畫）。這就是JDK7與JDK8中HashMap實現的最大區別。

接下來，咱們來看下JDK8中HashMap的源碼實現。

JDK中Entry的名字變成了Node，緣由是和紅黑樹的實現TreeNode相關聯。

 

1 transient Node<K,V>[] table;

 

當衝突節點數不小於8-1時，轉換成紅黑樹。

1 static final int TREEIFY_THRESHOLD = 8;

put方法在JDK8中有了很大的改變

 

 

 1 public V put(K key, V value) {
 2         return putVal(hash(key), key, value, false, true);
 3  }
 4 
 5 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 6                    boolean evict) {
 7         Node<K,V>[] tab;
 8     Node<K,V> p; 
 9     int n, i;
10     //若是當前map中無數據，執行resize方法。而且返回n
11         if ((tab = table) == null || (n = tab.length) == 0)
12             n = (tab = resize()).length;
13      //若是要插入的鍵值對要存放的這個位置恰好沒有元素，那麼把他封裝成Node對象，放在這個位置上就完事了
14         if ((p = tab[i = (n - 1) & hash]) == null)
15             tab[i] = newNode(hash, key, value, null);
16     //不然的話，說明這上面有元素
17         else {
18             Node<K,V> e; K k;
19               //若是這個元素的key與要插入的同樣，那麼就替換一下，也完事。
20             if (p.hash == hash &&
21                 ((k = p.key) == key || (key != null && key.equals(k))))
22                 e = p;
23               //1.若是當前節點是TreeNode類型的數據，執行putTreeVal方法
24             else if (p instanceof TreeNode)
25                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
26             else {
27                //仍是遍歷這條鏈子上的數據，跟jdk7沒什麼區別
28                 for (int binCount = 0; ; ++binCount) {
29                     if ((e = p.next) == null) {
30                         p.next = newNode(hash, key, value, null);
31                        //2.完成了操做後多作了一件事情，判斷，而且可能執行treeifyBin方法
32                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
33                             treeifyBin(tab, hash);
34                         break;
35                     }
36                     if (e.hash == hash &&
37                         ((k = e.key) == key || (key != null && key.equals(k))))
38                         break;
39                     p = e;
40                 }
41             }
42             if (e != null) { // existing mapping for key
43                 V oldValue = e.value;
44                 if (!onlyIfAbsent || oldValue == null) //true || --
45                     e.value = value;
46            //3.
47                 afterNodeAccess(e);
48                 return oldValue;
49             }
50         }
51         ++modCount;
52         //判斷閾值，決定是否擴容
53         if (++size > threshold)
54             resize();
55         //4.
56         afterNodeInsertion(evict);
57         return null;
58     }

treeifyBin()就是將鏈表轉換成紅黑樹。

以前的indefFor()方法消失 了，直接用(tab.length-1)&hash，因此看到這個，表明的就是數組的下角標。

 

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