JDK7與JDK8中HashMap的實現

1. JDK7中的HashMap
2. JDK8中的HashMap

JDK7中的HashMap

HashMap底層維護一個陣列，陣列中的每一項都是一個Entry

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

我們向 HashMap 中所放置的物件實際上是儲存在該陣列當中；

而Map中的key，value則以Entry的形式存放在陣列中

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

而這個Entry應該放在陣列的哪一個位置上（這個位置通常稱為位桶或者hash桶，即hash值相同的Entry會放在同一位置，用連結串列相連），是通過key的hashCode來計算的。

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

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

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

這個方法其實相當於對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]中

private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount  ;
        addEntry(0, null, value, 0);
        return null;
    }

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

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

jdk7中resize，只有當 size>=threshold並且 table中的那個槽中已經有Entry時，才會發生resize。即有可能雖然size>=threshold，但是必須等到每個槽都至少有一個Entry時，才會擴容。還有注意每次resize都會擴大一倍容量

JDK8中的HashMap

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

這樣子的HashMap效能上就抱有一定疑問，如果說成百上千個節點在hash時發生碰撞，儲存一個連結串列中，那麼如果要查詢其中一個節點，那就不可避免的花費O(N)的查詢時間，這將是多麼大的效能損失。這個問題終於在JDK8中得到了解決。再最壞的情況下，連結串列查詢的時間複雜度為O(n),而紅黑樹一直是O(logn),這樣會提高HashMap的效率。

JDK7中HashMap採用的是位桶連結串列的方式，即我們常說的雜湊連結串列的方式，而JDK8中採用的是位桶連結串列/紅黑樹（有關紅黑樹請檢視紅黑樹）的方式，也是非執行緒安全的。當某個位桶的連結串列的長度達到某個閥值(預設超過8)的時候，這個連結串列就將轉換成紅黑樹。

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中有了很大的改變

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;
    //如果當前map中無資料，執行resize方法。並且返回n
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
     //如果要插入的鍵值對要存放的這個位置剛好沒有元素，那麼把他封裝成Node物件，放在這個位置上就完事了
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
    //否則的話，說明這上面有元素
        else {
            Node<K,V> e; K k;
        //如果這個元素的key與要插入的一樣，那麼就替換一下，也完事。
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
        //1.如果當前節點是TreeNode型別的資料，執行putTreeVal方法
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
        //還是遍歷這條鏈子上的資料，跟jdk7沒什麼區別
                for (int binCount = 0; ;   binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
            //2.完成了操作後多做了一件事情，判斷，並且可能執行treeifyBin方法
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            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) //true || --
                    e.value = value;
           //3.
                afterNodeAccess(e);
                return oldValue;
            }
        }
         modCount;
    //判斷閾值，決定是否擴容
        if (  size > threshold)
            resize();
        //4.
        afterNodeInsertion(evict);
        return null;
    }

treeifyBin()就是將連結串列轉換成紅黑樹。

之前的indefFor()方法消失了，直接用(tab.length-1)&hash，所以看到這個，代表的就是陣列的下角標。

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

效能提升有什麼用處？例如說惡意的程式，假設它知道我們用的是雜湊演算法。它可能會傳送大量的請求，導致產生嚴重的雜湊碰撞。然後不停的訪問這些 key就能顯著的影響server的效能。這樣就形成了一次拒絕服務攻擊（DoS）。

JDK 8中從O(n)到O(logn)的飛躍，能夠有效地防止類似的攻擊，同一時候也讓HashMap效能的可預測性略微增強了一些

JDK7即使負載因子和Hash演算法設計的再合理，也免不了會出現拉鍊過長的情況，一旦出現拉鍊過長，則會嚴重影響HashMap的效能。於是，在JDK1.8版本中，對資料結構做了進一步的優化，引入了紅黑樹。而當連結串列長度太長（預設超過8）時，連結串列就轉換為紅黑樹，利用紅黑樹快速增刪改查的特點提高HashMap的效能，其中會用到紅黑樹的插入、刪除、查詢等演算法。

當插入新元素時，對於紅黑樹的判斷如下：

判斷table[i] 是否為treeNode，即table[i] 是否是紅黑樹，如果是紅黑樹，則直接在樹中插入鍵值對，否則轉向下面；

遍歷table[i]，判斷連結串列長度是否大於8，大於8的話把連結串列轉換為紅黑樹，在紅黑樹中執行插入操作，否則進行連結串列的插入操作；遍歷過程中若發現key已經存在直接覆蓋value即可；

文章來源：http://www.importnew.com/23164.html