HashMap 概念

對於 Map ，最直觀就是理解就是鍵值對，對映，key-value 形式。一個對映不能包含重複的鍵，一個鍵只能有一個值。平常我們使用的時候，最常用的無非就是 HashMap。

HashMap 實現了 Map 介面，允許使用 null 值 和 null 鍵，並且不保證對映順序。

HashMap 有兩個引數影響效能：

• 初始容量：表示雜湊表在其容量自動增加之前可以達到多滿的一種尺度
• 載入因子：當雜湊表中的條目超過了容量和載入因子的乘積的時候，就會進行重雜湊操作。

如下成員變數原始碼：

static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
transient Node<K,V>[] table;
 

可以看到，預設載入因子為 0.75， 預設容量為 1 << 4，也就是 16。載入因子過高，容易產生雜湊衝突，載入因子過小，容易浪費空間，0.75是一種折中。

另外，整個 HashMap 的實現原理可以簡單的理解成：當我們 put 的時候，首先根據 key 算出一個數值 x，然後在 table[x] 中存放我們的值。這樣有一個好處是，以後的 get 等操作的時間複雜度直接就是O(1)，因為 HashMap 內部就是基於陣列的一個實現。

put 方法的實現 與 雜湊衝突

下面再結合程式碼重點分析下 HashMap 的 put 方法的內部實現 和 雜湊衝突的解決辦法：

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;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    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)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}
 

首先我們看到 hash(key) 這個就是表示要根據 key 值算出一個數值，以此來決定在 table 陣列的哪一個位置存放我們的數值。（Ps：這個 hash(key) 方法 也是大有講究的，會嚴重影響效能，實現得不好會讓 HashMap 的 O(1) 時間複雜度降到 O(n)，在JDK8以下的版本中帶來災難性影響。它需要保證得出的數在雜湊表中的均勻分佈，目的就是要減少雜湊衝突）

重要說明一下：

• **JDK8 中雜湊衝突過多，連結串列會轉紅黑樹，時間複雜度是O(logn)，不會是O(n) **
• **JDK8 中雜湊衝突過多，連結串列會轉紅黑樹，時間複雜度是O(logn)，不會是O(n) **
• **JDK8 中雜湊衝突過多，連結串列會轉紅黑樹，時間複雜度是O(logn)，不會是O(n) **

然後，我們再看到：

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);
else {
    ......

這就表示，如果沒有 雜湊衝突，那麼就可以放入資料 tab[i] = newNode(hash, key, value, null); 如果有雜湊衝突，那麼就執行 else 需要解決雜湊衝突。

那麼放入資料 其實就是 建立一個 Node 節點，該 Node節點有屬性 key，value，分別儲存我們的 key 值 和 value 值，然後再把這個 Node 節點放入到 table 陣列中，並沒有什麼神祕的地方。

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

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

上述可以看到 Node 節點中 有一個 Node<K,V> next; ，其實仔細思考下就應該知道這個是用來解決雜湊衝突的。下面再看看是如何解決雜湊衝突的：

雜湊衝突：通俗的講就是首先我們進行一次 put 操作，算出了我們要在 table 陣列的 x 位置放入這個值。那麼下次再進行一個 put 操作的時候，又算出了我們要在 table 陣列的 x 位置放入這個值，那之前已經放入過值了，那現在怎麼處理呢？

其實就是通過連結串列法進行解決。

首先，如果有雜湊衝突，那麼：

if (p.hash == hash &&
    ((k = p.key) == key || (key != null && key.equals(k))))
e = p;

需要判斷 兩者的 key 是否一樣的，因為 HashMap 不能加入重複的鍵。如果一樣，那麼就覆蓋，如果不一樣，那麼就先判斷是不是 TreeNode 型別的：

 else if (p instanceof TreeNode)
    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

這裡表示 是不是現在已經轉紅黑樹了（在大量雜湊衝突的情況下，連結串列會轉紅黑樹），一般我們小資料的情況下，是不會轉的，所以這裡暫時不考慮這種情況（Ps：本人也沒太深入研究紅黑樹，所以就不說這個了）。

如果是正常情況下，會執行下面的語句來解決雜湊衝突：

for (int binCount = 0; ; ++binCount) {
    if ((e = p.next) == null) {
        p.next = newNode(hash, key, value, null);
        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;
}

這裡其實就是用連結串列法來解決。並且：

• 衝突的節點放在連結串列的最下面。
• 衝突的節點放在連結串列的最下面。
• 衝突的節點放在連結串列的最下面。

因為 首先有：p = tab[i = (n - 1) & hash] ，再 for 迴圈，然後有 if ((e = p.next) == null) { ,並且如果 當前節點的下一個節點有值的話，那麼就 p = e;，這就說明了放在最下面。

強烈建議自己拿筆拿紙畫畫。

總結

• 一個對映不能包含重複的鍵，一個鍵只能有一個值。允許使用 null 值 和 null 鍵，並且不保證對映順序。
• HashMap 解決衝突的辦法先是使用連結串列法，然後如果雜湊衝突過多，那麼會把連結串列轉換成紅黑樹，以此來保證效率。
• 如果出現了雜湊衝突，那麼新加入的節點放在連結串列的最後面。