HashMap 原始碼分析

下半夜的風發表於2022-03-07
HashMap原始碼

HashMap 應該是開發中最常用的資料結構之一了，理解其原理能讓我們在合適的時機用正確的方式使用它。

目錄

一、結構

  • 內部類及成員變數
  • 構造方法
  • 圖解

二、呼叫原理

  • put
  • get
  • remove
  • 迭代

三、總結

一、結構

1. 內部類及成員變數

Node 內部類：單連結串列資料結構，是理解 HashMap 結構的關鍵，內部儲存：hash（對 key 的 hashCode值的高低位異或，後面有解釋）、key（傳進來的鍵）、value（傳進來的值）、next（指向下一個 Node 節點）。

TreeNode 內部類：紅黑樹資料結構，這裡對紅黑樹做一個簡單的解釋，它是一種平衡二叉搜尋樹，二叉搜尋樹即是每個節點的左子節點的值小於父節點的值，右子節點的值大於父節點的值，平衡的意義在於二叉樹插入的資料如果一直是最小或最大的值，那麼其實他會退化成連結串列，因此需要插入的時候做一些調整，儘量能達到左右子樹的平衡。說了這麼多，為什麼要轉換成紅黑樹？因為完全二叉樹的查詢效率是 O(logn), 比連結串列的查詢效率 O(n) 快太多了，所以一旦碰撞變多，雜湊表的單連結串列查詢效率就會變慢。紅黑樹非常複雜，若是對其有興趣可以專門去研究下，不建議在看 HashMap 的時候去理解它。。本文講解會對這塊內容跳過。

table：雜湊表，用 Node<K,V>[] 宣告，表示一個陣列，我們把每個條目稱作 bucket 桶，把桶內單連結串列 node 的每個元素稱之為節點。

size：所有鍵值對的數量，即節點的個數。

modCount：雜湊表內修改次數，用來判斷 HashMap 是否被多執行緒修改中，如果是則要丟擲異常。

threshold：閾值 = capacity（容量） * loadFactor（裝載因子），當陣列中元素數量超過這個值說明該擴容了，初始容量預設是 16，要根據自己的業務場景設定一個適合的容量大小，太大會造成記憶體消耗以及迭代耗時，太小會造成多次擴容。

loadFactor：裝載因子，由它決定閾值，預設是0.75。loadFactor 也要適合自己業務場景來自定義，一般情況用預設的沒問題。

2. 構造方法

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}
複製程式碼

如果不指定此構造方法的兩個引數，那麼就是使用預設的 capacity = 16 和 loadFactor = 0.75, 這段程式碼判斷了初始容量的合法性以及儲存裝載因子，tableSizeFor 這個方法主要是調整下初始容量，HashMap 強制容量是2的冪次方，如果給了 13 的初始容量，那麼這個方法就會調整為 16。

3. 圖解

下圖能比較清晰的看到 HashMap 的結構：

HashMap

藍色矩陣代表 Node 單連結串列, 藍色圓形代表 TreeNode 紅黑樹。正常情況下都會是單連結串列，當單連結串列節點的數量超過 8 個的時候會轉換成紅黑樹的結構（這個只是隨便畫的。。），紅黑樹雖說定義是平衡二叉樹，但他不一定是完全二叉樹，只是相對來說保持平衡。

二、呼叫原理

1. put

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
複製程式碼

直接呼叫了 putVal 去做真正的儲存工作，在此之前先看下 hash(key) 方法。

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

這個 hash 函式可以說是極其精美了，獲取了 key 的 hashCode 將其高16位與低16位異或得到最終的 hash 值。對高低位異或的原因是，key 的雜湊值最終需要對陣列長度取模，這個時候如果很多 key 的雜湊值低位都相同咋辦？因此和高位異或就能讓高位也參與計算，會降低碰撞的概率。而這麼做並不是說讓碰撞的概率很小，只是這樣能大大降低概率而且計算還非常簡潔，不會耗費效能。如果碰撞多了，那就用紅黑樹來解決。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 如果雜湊表是空的，表示這是第一次呼叫 put 那就建立一個雜湊表， resize 方法後面解釋
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 對 hash 值取模，找到雜湊表中對應的索引，如果此索引下沒有元素，
    // 那麼新建一個 Node 節點將hash、key、value儲存進去
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 每個陣列對應索引的元素都是一個單連結串列或紅黑樹，
        // 根據 hash 值和 key 判斷 put 進來的 key 是否已存在，若存在則替換 value。
        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);
        // 陣列的 Node 節點是存在的，並且單連結串列的頭結點並不是要插入的節點，
        // 那麼遍歷這個單連結串列，如果找到相同點則替換，沒找到就插入到尾部
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 如果單連結串列的節點數達到 8 個，就將單鏈錶轉換成紅黑樹
                    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;
            }
        }
        // 找到相同 key 的節點，那麼就替換原來的值，
        // onlyIfAbsent可以控制不替換原來的值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 空實現，只有在LinkedHashMap會用到，因此不用管
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 若達到閾值，則擴容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}
複製程式碼

程式碼中的註釋已經對每個關鍵的部分做了解釋。 put 可以簡單分為三個階段：

  • 首次 put 建立雜湊表。
  • 插入的節點若存在則替換原有節點的值，否則插到單連結串列的尾部或紅黑樹中。
  • 若超出閾值則擴容。
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 之前雜湊表已經被建立
    if (oldCap > 0) {
        // 大於最大容量，就永遠不擴容了
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 新容量是老容量的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    // 表示雜湊表還未被建立，新容量就等於使用者設定的初始容量
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    // 雜湊表未被建立，使用者又沒有設定初始容量，那就用預設的
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                // 單連結串列節點只有一個，那就直接重新計算 bucket 索引 index 並移交到新雜湊表
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                // 紅黑樹移到新雜湊表，暫不深究
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 單連結串列loHead從老雜湊表移到新雜湊表中 index 不變
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 單連結串列hiHead從老雜湊表移到新雜湊表中 index + oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        // 即使索引變化也是有規律的
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}
複製程式碼

resize 擴容方法主要做兩件事：

  • 新容量擴充為老容量的2倍，閾值也增大兩倍。若是首次建立則新容量為初始容量。然後通過新容量建立新雜湊表。
  • 將老雜湊表的元素移到新雜湊表中。這裡有個規律：由於容量是2倍增長，因此元素的 hash 值取模要麼結果不變，要麼 索引 = 原索引 + 老容量大小。

以下是擴容圖解：

resize

藍色矩陣表示早已新增到雜湊表的節點，黃色矩陣表示剛插入的一個節點。

假定 HashMap 的初始容量 capacity 是 4, loadFactor 是 0.75 , 此時插入一個節點，那麼容量就超出閾值（4 * 0.75 = 3），於是就發生擴容了。圖上的 hash 那一列表示 key 的 hashCode 後四位（hashCode本來是32位，為了節省空間只寫後4位），可以看到根據 hash & (capacity - 1), 就可以知道各個節點索引位置，如 0001 & 0011 = 0001 即 index 為 1 這個位置。因此當容量增加兩倍後 (capacity - 1) = 0111, 可以發現和老容量的差別就在於右數第三位從 0 變成了1, 所以 key 的 hashCode & (capacity - 1) 其他位都是一樣的，只是右數第三位要麼是 0 要麼是 1, 如果 hashCode 的右數第三位是 1 代表索引在原來的基礎上增加原來容量的大小即 + 4, 如果是 0 那麼還是在原來的索引上，直接放到新雜湊表的對應位置，這個操作只會遍歷陣列長度，而不會對單連結串列的每個節點重新計算索引，節省了時間，對效能有提高。

2. get

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 雜湊表不為空並且通過 hash 找到對應 bucket 的位置
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 單連結串列頭節點就是要找的目標節點
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            // 已經轉換成紅黑樹了
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 在連結串列內遍歷查詢
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}
複製程式碼

同樣程式碼做了清晰的註釋。呼叫 get 方法後會計算出 key 的 hash 值並呼叫 getNode 方法，getNode 裡面做的事情也非常清楚，找到對應 bucket 下是否有節點，如果有則從單連結串列內遍歷查詢或在紅黑樹內查詢。

3. remove

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        // 以下部分與 get 查詢基本一樣，找到要刪除的節點
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 找到 key 對應的節點，還要看看 value 的情況。
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            // 紅黑樹刪除
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            // 要刪除的節點處在單連結串列的頭節點
            else if (node == p)
                tab[index] = node.next;
            // 前驅節點指向目標節點的後一個節點，這個操作表示移除了 node 節點
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}
複製程式碼

remove 做了兩件事：

  • 前半部分程式碼和 get 方法很類似，其實本質上就是找到想要移除的節點，p 節點是 node 節點的前驅節點。
  • 根據找到的目標節點 node，如果使用者使用 remove 時傳入了 key 和 value，那麼還需要匹配 value 才行，匹配成功後用 p 節點指向 node 節點的後一個節點即可，這樣 node 節點就會被刪除。紅黑樹刪除原始碼不深究。

4. 迭代

Map<String, String> map = new HashMap<>();

// foreach 遍歷 entries
for(Map.Entry<String,String> entry: map.entrySet()) {
    System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}

// foreach 遍歷 keys
for(String key: map.keySet()) {
    System.out.println("key = " + key);
}

// foreach 遍歷 values
for(String value: map.values()) {
    System.out.println("value = " + value);
}

// iterator 遍歷 entries
Iterator<Map.Entry<String,String>> iterator = map.entrySet().iterator();
while(iterator.hasNext()) {
    Map.Entry<String,String> entry = iterator.next();
    System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}

// iterator 遍歷 keys
Iterator<String> iteratorKey = map.keySet().iterator();
while(iteratorKey.hasNext()) {
    String key= iteratorKey.next();
    System.out.println("key = " + key);
}

// iterator 遍歷 values
Iterator<String> iteratorValue = map.values().iterator();
while(iteratorValue.hasNext()) {
    String value= iteratorValue.next();
    System.out.println("value = " + value);
}
複製程式碼

HashMap 提供了多種迭代方式，這裡只分析一種迭代方式。

public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
複製程式碼

直接建立一個 EntrySet 物件，看看是啥東西:

final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final Iterator<Map.Entry<K,V>> iterator() {
        return new EntryIterator();
    }
    
    public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            // Android-changed: Detect changes to modCount early.
            for (int i = 0; (i < tab.length && modCount == mc); ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }
}
複製程式碼

關鍵就兩個方法，一個是 foreach 迭代，從示例上看是非常簡潔的，但效能貌似比 iterator 慢一些。HashMap 是不同步的，迭代的過程中是不允許多執行緒操作，這個時候 modCount 變數就排上用場了，如果發現 modCount 在迭代完後和迭代前不相等就會丟擲 ConcurrentModificationException 異常。

iterator 返回一個 EntryIterator 物件：

final class EntryIterator extends HashIterator
    implements Iterator<Map.Entry<K,V>> {
    public final Map.Entry<K,V> next() { return nextNode(); }
}

abstract class HashIterator {
    Node<K,V> next;        // next entry to return
    Node<K,V> current;     // current entry
    int expectedModCount;  // for fast-fail
    int index;             // current slot

    HashIterator() {
        expectedModCount = modCount;
        Node<K,V>[] t = table;
        current = next = null;
        index = 0;
        if (t != null && size > 0) { // advance to first entry
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }

    public final boolean hasNext() {
        return next != null;
    }

    final Node<K,V> nextNode() {
        Node<K,V>[] t;
        Node<K,V> e = next;
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }
}
複製程式碼

呼叫 next 方法實際上是呼叫了這裡的 nextNode 方法，如果下一個條目不為 null, 那麼直接返回對應的節點即可，如果下個節點為空，則需要迴圈遍歷直到找到不為 null 的節點附給 next, 保證下次返回節點的正確性。

三、總結

用問答的形式來總結下本文的內容以及 HashMap 常見的問題。

  1. 裝載因子的作用是什麼？ loadFactor 用於計算 HashMap 的閾值，當雜湊表內的節點個數超過閾值時，雜湊表就會進行擴容。
  2. 碰撞過多怎麼辦/擴容的原理？當節點數超過閾值，內部會新建一個比原來雜湊表大小大兩倍的新雜湊表，然後將老雜湊表內的節點重新雜湊到新雜湊表中。
  3. 當雜湊表一個 bucket 桶上的單連結串列過長導致查詢效率過低怎麼辦？jdk1.8 加入了紅黑樹解決此問題，當單連結串列長度超過 8 的時候會轉換成紅黑樹，紅黑樹的查詢效率是O(logn)，但由於紅黑樹結構更消耗記憶體，因此單連結串列超過 8 個節點才會轉成紅黑樹。
  4. HashMap 和 HashTable 的區別？HashMap 相對 HashTable 的區別就在於不同步以及可以用null鍵。但為什麼一般不用HashTable呢，因為HashTable用的是 synchronized 關鍵字，特別耗時，所以一般同步也就會用 concurrentHashMap。而且 HashMap 真的想同步的話，也可以用 Collections.synchronizedMap(new HashMap) 。
  5. 儲存鍵值對的流程是怎樣的？呼叫 put 方法，如果雜湊表為空則建立，首先根據 key 計算得出 hash 值，又根據 hash 得出對應的桶的位置，若這個桶上還沒有節點，那麼直接新增到桶中，如果有節點則遍歷單連結串列或紅黑樹，發現有相同 hash 值和相同 key 的節點，直接替換它的 value，如果沒有找到相同節點就加入到單連結串列的尾部。最後如果節點數量超過閾值，那麼擴容。
  6. hash 函式為什麼高低位異或？陣列的長度一般來說都不大，如果直接拿 key 的 hashCode 來取模，那麼都是拿二進位制的低位進行與運算，會有很大機率產生碰撞，高16位和低16位異或就會讓高位也參與計算，此時碰撞概率會大大減少。
  7. 初始容量是否有必要設定？有必要，在大概知道資料量的前提下，儘量設定對應的容量，減少擴容次數，擴容耗費效能。
  8. HashMap 的工作原理？HashMap 是一個鍵值對儲存的資料結構，其內部結構是一個雜湊表。當執行 put 操作時，會根據 key 計算得出 hash 值，又根據 hash 得出對應的桶的位置，若這個桶上還沒有節點，那麼直接新增到桶中，如果有節點則遍歷單連結串列或紅黑樹，發現有相同 hash 值和相同 key 的節點，直接替換它的 value，如果沒有找到相同節點就加入到單連結串列的尾部（紅黑樹）。最後如果節點數量超過閾值即 loadFactor * capacity，那麼擴容兩倍。當執行 get 獲取時，會計算出 key 的 hash 值，找到對應 bucket 桶的 index，如果該索引下沒有節點則直接返回null，如果有節點則在單連結串列內遍歷查詢或在紅黑樹內查詢。

暫時就想到這些問題了。

相關文章