HashMap源碼分析

Overview

　　HashMap是Java編程中最常用的數據結構之一，本文基於JDK1.8從源碼角度來分析HashMap的存儲結構和常用操作。HashMap實現了Map接口，Map接口的實現類還有Hashtable、LinkedListHashMap和TreeMap。具體的繼承結構請參考JDK Document。

　　學過數據結構的同學都知道Hash表的實現方式，其實HashMap就是Hash表的一個實現。HashMap是key-value結構的，根據key的hashCode可以快速訪問到key對應的value，訪問操作的時間復雜度為O(1)。但HashMap在多線程的場景下並不能保證數據的一致性，如果要在多線程的場景下使用Map結構，可以考慮使用Collections工具類的synchronizedMap方法使HashMap變為線程安全的，同時也可以考慮使用ConcurrentHashMap。

　　那HashMap和其他幾個Map接口的實現類有什么區別呢？

　　和Hashtable的區別：Hashtable是線程安全的，是JDK的遺留類，內部實現使用synchronized關鍵字對方法加鎖，效率和並發性不好。在線程安全的場景下可以使用ConcurrentHashMap替代，ConcurrentHashMap內部實現使用了分段鎖，效率和並發性都要比Hashtable好。另一個區別是HashMap可以有有個null鍵和多個null值，Hashtable是不可以的。

　　和LinkedHashMap的區別：LinkedHashMap是Map的實現類同時也是HashMap子類，與HashMap不同的地方在於LinkedHashMap底層使用鏈表實現，因此LinkedHashMap能夠維護記錄插入順序，能夠按次序訪問，而HashMap的key是無序的，這一點和HashSet一致。

　　和TreeMap的區別：TreeMap實現了Map的同時也實現了SortedMap接口，底層基於RB-Tree（紅黑樹）實現，TreeMap能夠根據自然序或者給定的比較器維護記錄的存儲順序。需要注意的是，在使用TreeMap的時候key對象需要實現Comparable接口或者在構造TreeMap時傳入自定義Comparator，否則會在運行時拋出java.lang.ClassCastException異常。

　　在使用Map時，需要確保key對象是不可變的，也就是說key的hash是不會改變的，如果key的hash發生變化，就會出現key訪問不到value的情況。需要保證equals()方法和hashCode()方法所描述的對象是一致的，即兩個對象的equals()方法返回true那么這兩個對象的hashCode()方法也要返回相同的值。這也是重寫equals()方法通常也要重寫hashCode()方法的原因。

存儲結構

　　HashMap的結構是數組、鏈表和RB-Tree的組合，總體來說是數組用來進行hash尋址，用鏈表存儲hash沖突的Entry，在沖突多時用RB-Tree來提高存取效率。

　　　　在HashMap的結構中存儲的是key-value實體Entry<K,V>，更准確的說是存儲的Node<K,V>，Node<K,V>是HashMap的一個靜態內部類，實現了Map.Entry接口。是key-value的包裝類。

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) {...}

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {...}

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

　　HashMap中有一個Node[]類型的字段，用來當做hash桶，Node中hash字段用來快速定位hash桶的索引。

transient Node<K,V>[] table; //（transient關鍵字作用是在序列化時過濾掉此字段）

　　除此之外，HashMap還有幾個比較重要的字段。

//HashMap中所有key-value實體的集合
transient Set<Map.Entry<K,V>> entrySet;
//當前HashMap的大小（k-v實體個數）
transient int size;
//整個HashMap結構變化的次數
transient int modCount;
//在下次擴容之前能容納k-v實體的最大值，threshold=(capacity * load factor)。
int threshold;
//負載因子
final float loadFactor;

初始化和擴容

　　HashMap的初始化時把HashMap所需要的數據結構和字段構造出來，並給定初始字段值。比如構造Node數組，設定初始化容量和負載因子等。這些可以通過HashMap的構造方法來實現。如果構造HashMap時不指定initialCapacity和loadFactor就會使用默認值，initialCapacity的默認值是16，HashMap的最大容量是2^30；默認的loadFactor值為0.75，含義是在存儲數量達到當前Node[]數組長度的75%時進行下一次擴容。默認0.75也是hash沖突和空間利用率之間的權衡。

　　注意，loadFactor的值是可以大於1的，因為threshold=capacity * load factor，這里的capacity是Node[]數組的長度，除Node[]數組外使用鏈表和紅黑樹來存儲沖突的記錄，所以理論上整個HashMap對象存儲的記錄數可以大於capacity，也就是說size並不被capacity所限制。

　　當HashMap存儲的記錄數達到threshold=capacity * load factor后就要進行一次擴容，把容量擴大到之前的2倍，具體方法使創建一個新的長度為原來2倍的Node[]數組替換掉之前的Node[]數組。替換數組並不是簡單的拷貝而是要把記錄分散在新的數組中。在JDK1.8以前是采用rehash的方法，JDK1.8對此做了優化，避免了重新計算hash而且能將記錄均勻的分散在新的Node[]數組中。具體做法是，在Node[]數組擴容到原來的2倍時，key的hash長度在原來的基礎上多出一位，那么這一位可以是0也可以是1，當是0時索引不變，1時索引變為原索引+原容量。因為0和1是可以認為是隨機的所以均勻分布的效果和rehash理論上是一致的。

　　來欣賞一下JDK1.8優化后的resize代碼，簡直是藝術品。

    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) {
            //超過2^30就不能再擴容了，把threshold設置為int最大值，就不會再擴容。
            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
            //第一次初始化沒有指定容量，使用默認容量16
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            //計算新的threshold
            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;
                    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 { // 如果是鏈表節點，保留鏈表順序
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            //如果新增高位為0，索引位置不變
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            //如果新增高位為1，索引位置變為原索引+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;
                        }
                        //放置原索引+oldCap位置
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

 

put()方法分析

　　弄清楚了HashMap的結構和擴容機制，put()和get()操作直接按照步驟來分析就可以了。put()操作的主要是如下幾個步驟：

• 首先判斷Node[]數組table是否為空或null，如果是空那么進行一次resize，這次resize只是起到了一次初始化的作用。
• 根據key的值計算hash得到在table中的索引i，如果table[i]==null則添加新節點到table[i]，然后判斷size是否超過了容量限制threshold，如果超過進行擴容。
• 如果在上一步table[i]不為null時，判斷table[i]節點是否和當前添加節點相同（這里使用hash和equals判斷，因此需要保證hashCode()方法和equals()方法描述的一致性），如果相同則覆蓋該節點的value。
• 如果上一步判斷table[i]和當前節點不同，那么判斷table[i]是否為紅黑樹節點，如果是紅黑樹節點則在紅黑樹中添加此key-value。
• 如果上一步判斷table[i]不是紅黑樹節點則遍歷table[i]鏈表，判斷鏈表長度是否超過8，如果超過則轉為紅黑樹存儲，如果沒有超過則在鏈表中插入此key-value。（jdk1.8以前使用頭插法插入）。在遍歷過程中，如果發現有相同的節點（比較hash和equals）就覆蓋value。
• 維護modCount和size等其他字段。

    public V put(K key, V value) {
        //傳入key的hash值，對hashCode值做位運算
        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;
        //如果tab為null，則通過resize初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //計算key的索引，如果為當前位置為null，直接賦值
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //如果當前位置不為null
            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;
            }
        }
        //結構變化次數+1
        ++modCount;
        //如果size超過最大限制，擴容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

 

get()方法分析

　　明確了put()方法，get()方法的分析就變得非常容易了，首先看一下如何通過hash確定key在桶中的索引位置。

static final int hash(Object key) {   //jdk1.8 & jdk1.7
     int h;
     // h = key.hashCode() 為第一步 取hashCode值
     // h ^ (h >>> 16)  為第二步 高位參與運算
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//jdk1.8已經把這個方法省略了，但是在訪問時直接使用這個計算策略。
static int indexFor(int h, int length) {
     return h & (length-1);  //第三步 取模運算
}

　　如下就是get()方法的具體分析：

　　 public V get(Object key) {
        Node<K,V> e;
        //傳入key的hash
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //這里訪問(n - 1) & hash其實就是jdk1.7中indexFor方法的作用
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //判斷桶索引位置的節點是不是相同（通過hash和equals判斷），如果相同返回此節點
            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);
            }
        }
        //如果不存在返回null
        return null;
    }

 

補充

 　　除以上的分析以外，HashMap還有許多其他方法，包括判空、刪除、清空、替換、遍歷以及JDK1.8新增的函數式語法和Lambda表達式的內容。代碼總行數多達兩千多行，如果感興趣或遇到相應問題可以具體分析。已經了解了HashMap的存儲結構和關鍵操作的步驟，再去分析其他方法就比較容易了。

小結

　　從以上的對HashMap源碼的分析，可以得出一些使用上的技巧和有用的結論。

• HashMap不是線程安全的，多線程的場景推薦使用ConcurrentHashMap。
• JDK1.8對HashMap做了大量優化，值得嘗試。
• 在初始化時最好能夠給出估算的容量大小，避免頻繁擴容影響使用效率。
• 負載因子是可以修改的，但是0.75是容量和沖突之間的權衡，如果不是目的特別明確不要輕易修改。
• 重寫equals()方法的同時也要重寫hashCode()方法。
• HashMap源碼寫的真棒:）

 

　　參考資料：

　　Java 8系列之重新認識HashMap

　　Java™ Platform, Standard Edition 8 API Specification

　　java.util.HashMap源碼