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源碼