HashMap 核心源碼分析 （jdk8）

寫在前面

若是對 HashMap 的基本工做原理不清楚，繼續閱讀後續內容的效果不是很好，建議先學習前置知識HashMap 基本工做原理 ： https://my.oschina.net/j4love/blog/1797058

 

java.util.HashMap#putVal

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;

        // table 爲 null 說明是首次調用 put 方法 , 進行 resize 操做真正爲 table 分配存儲空間

        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

        // i = (n - 1) & hash 計算出的值判斷 table[i] 是否爲 null , 
        // 若是爲 null 就爲 key ， value 建立一個新的 Node 節點 ,
        // 不須要進行碰撞檢測直接存儲在 table 中 i 的位置上 

        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;

            // 檢測要存儲的 key 是否和 bucket 中存儲的頭節點相同
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

            // 檢測 bucket 中當前存放的節點類型是否是紅黑樹結構 ,
            // 是紅黑樹結構 , 存儲爲一個紅黑樹節點

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

                // 這個 bucket 中存放的節點是鏈表結構 , 
                // 循環直到鏈表的末尾或者是找到相同的 key 

                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);

                        // 存儲新節點的時候 ， 檢測鏈表長度是否超過 TREEIFY_THRESHOLD - 1 ,
                        // 超過的話將鏈表轉換爲紅黑樹結構 ,提升性能

                        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;
            }
        }

        // 併發修改計數器 ,有併發修改就拋異常 ConcurrentModificationException
        ++modCount;

        // 存儲了一個新節點 ， 檢測 size 是否超過 threshold 
        // 若是超過了要進行 resize 操做
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

 

java.util.HashMap#getNode

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;

        // 檢測 table 中是否已經存儲了節點 ，
        // 檢測key所在的 bucket 是否存儲了節點 ，
        // 以上兩點都不知足說明 key 不存在

        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {

            // 對 bucket 中存儲節點的頭結點進行碰撞檢測 ,
            // 若是運氣好的話只須要進行這一次碰撞檢測

            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;

            // 檢測 bucket 存儲的節點是不是單個節點

            if ((e = first.next) != null) {

                // 檢測節點數據結構是不是紅黑樹

                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {

                    // 節點是鏈表數據結構，循環直到鏈表末尾或者是發現 key 一致的節點
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

 

java.util.HashMap#removeNode

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;
            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 是 node 的前一個節點
                        p = e;
                    } while ((e = e.next) != null);
                }
            }

            // 以上代碼是 getNode(hash , key) , 我的以爲這個函數中的代碼冗餘了

            // 獲取到 key 對應的節點 ， 判斷是否要進行值匹配

            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;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

 

java.util.HashMap#clear

public void clear() {
        Node<K,V>[] tab;
        modCount++;
        if ((tab = table) != null && size > 0) {
            size = 0;

            // 很簡單把數組中每一個位置設置爲 null
            for (int i = 0; i < tab.length; ++i)
                tab[i] = null;
        }
    }