HashMap底層實現原理__hashmap

在JDK1.6，JDK1.7中，HashMap採用位桶+鏈表實現，即使用鏈表處理衝突，同一hash值的鏈表都儲存在一個鏈表裡。但是當位於一個桶中的元素較多，即hash值相等的元素較多時，通過key值依次尋找的效率較低。而JDK1.8中，HashMap採用位桶+鏈表+紅/黑樹狀結構實現，當鏈表長度超過閾值（8）時，將鏈錶轉換為紅/黑樹狀結構，這樣大大減少了尋找時間。

簡單說下HashMap的實現原理：

首先有一個每個元素都是鏈表（可能表述不準確）的數組，當添加一個元素（key-value）時，就首先計算元素key的hash值，以此確定插入數組中的位置，但是可能存在同一hash值的元素已經被放在數組同一位置了，這時就添加到同一hash值的元素的後面，他們在數組的同一位置，但是形成了鏈表，同一各鏈表上的Hash值是相同的，所以說數組存放的是鏈表。而當鏈表長度太長時，鏈表就轉換為紅/黑樹狀結構，這樣大大提高了尋找的效率。

當鏈表數組的容量超過初始容量的0.75時，再散列將鏈表數組擴大2倍，把原鏈表數組的搬移到新的數組中

即HashMap的原理圖是：

一，JDK1.8中的涉及到的資料結構

1，位桶數組

transient Node[] table;//儲存（位桶）的數組

2，數組元素Node實現了Entry介面

//Node是單向鏈表，它實現了Map.Entry介面

static class Node implements Map.Entry {    final int hash;    final K key;    V value;    Node next;    //建構函式Hash值 鍵 值 下一個節點    Node(int hash, K key, V value, Node next) {        this.hash = hash;        this.key = key;        this.value = value;        this.next = 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) {        V oldValue = value;        value = newValue;        return oldValue;    }//判斷兩個node是否相等,若key和value都相等，返回true。可以與自身比較為true    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;    }

3，紅/黑樹狀結構

//紅/黑樹狀結構static final class TreeNode extends LinkedHashMap.Entry {    TreeNode parent;  // 父節點    TreeNode left; //左子樹    TreeNode right;//右子樹    TreeNode prev;    // needed to unlink next upon deletion    boolean red;    //顏色屬性    TreeNode(int hash, K key, V val, Node next) {        super(hash, key, val, next);    }  //返回當前節點的根節點    final TreeNode root() {        for (TreeNode r = this, p;;) {            if ((p = r.parent) == null)                return r;            r = p;        }    }

二，源碼中的資料域

載入因子（預設0.75）：為什麼需要使用載入因子，為什麼需要擴容呢。因為如果填充比很大，說明利用的空間很多，如果一直不進行擴容的話，鏈表就會越來越長，這樣尋找的效率很低，因為鏈表的長度很大（當然最新版本使用了紅/黑樹狀結構後會改進很多），擴容之後，將原來鏈表數組的每一個鏈表分成奇偶兩個子鏈表分別掛在新鏈表數組的散列位置，這樣就減少了每個鏈表的長度，增加尋找效率

HashMap本來是以空間換時間，所以填充比沒必要太大。但是填充比太小又會導致空間浪費。如果關注記憶體，填充比可以稍大，如果主要關注尋找效能，填充比可以稍小。

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable {    private static final long serialVersionUID = 362498820763181265L;    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16    static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量    static final float DEFAULT_LOAD_FACTOR = 0.75f;//填充比    //當add一個元素到某個位桶，其鏈表長度達到8時將鏈錶轉換為紅/黑樹狀結構    static final int TREEIFY_THRESHOLD = 8;    static final int UNTREEIFY_THRESHOLD = 6;    static final int MIN_TREEIFY_CAPACITY = 64;    transient Node[] table;//儲存元素的數組    transient Set> entrySet;    transient int size;//存放元素的個數    transient int modCount;//被修改的次數fast-fail機制    int threshold;//臨界值 當實際大小(容量*填充比)超過臨界值時，會進行擴容     final float loadFactor;//填充比（......後面略）

三，HashMap的建構函式
HashMap的構造方法有4種，主要涉及到的參數有，指定初始容量，指定填充比和用來初始化的Map

//建構函式1public 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);//新的擴容臨界值}//建構函式2public HashMap(int initialCapacity) {    this(initialCapacity, DEFAULT_LOAD_FACTOR);}//建構函式3public HashMap() {    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}//建構函式4用m的元素初始化散列映射public HashMap(Map m) {    this.loadFactor = DEFAULT_LOAD_FACTOR;    putMapEntries(m, false);}

四，HashMap的存取機制

public V put(K key, V value) {        return putVal(hash(key), key, value, false, true);    }/**     * Implements Map.put and related methods     *     * @param hash hash for key     * @param key the key     * @param value the value to put     * @param onlyIfAbsent if true, don't change existing value     * @param evict if false, the table is in creation mode.     * @return previous value, or null if none     */ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {        Node<K,V>[] tab; Node<K,V> p; int n, i;        如果tal還未初始化或者table的長度為0先調用resize初始化table        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;             //如果table的在（n-1）&hash的值是空，就建立一個節點插入在該位置        if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);            //否則存在衝突，開始處理衝突        else {            Node<K,V> e; K k;             //檢查第一個Node，p是不是要找的值            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);                        //如果衝突的節點數已經達到TREEIFY_THRESHOLD（8）個，看是否需要改變衝突節點的儲存結構，　　　　　　　　　　　　　　　　　　　　　　　　　//treeifyBin首先判斷當前hashMap的長度，如果不足64，只進行                        //resize，擴容table，如果達到64，那麼將衝突的儲存結構為紅/黑樹狀結構                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            treeifyBin(tab, hash);                        break;                    }                    //如果有相同的key值就結束遍曆                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    p = e;                }            }            //就是鏈表上有相同的key值            if (e != null) { // existing mapping for key                V oldValue = e.value;                //onlyIfAbsent為true那麼久不執行重複key的value的替換，                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                //返回存在的Value值                return oldValue;            }        }        ++modCount;        //如果當前大小大於門限，門限原本是初始容量*0.75        if (++size > threshold)        //擴容兩倍            resize();        afterNodeInsertion(evict);        return null;    }

/**     * Replaces all linked nodes in bin at index for given hash unless     * table is too small, in which case resizes instead.     */    final void treeifyBin(Node<K,V>[] tab, int hash) {        int n, index; Node<K,V> e;        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)        //如果table的長度不超過MIN_TREEIFY_CAPACITY（=64）個，那麼直接進行resize            resize();        else if ((e = tab[index = (n - 1) & hash]) != null) {            TreeNode<K,V> hd = null, tl = null;            do {                TreeNode<K,V> p = replacementTreeNode(e, null);                if (tl == null)                    hd = p;                else {                    p.prev = tl;                    tl.next = p;                }                tl = p;            } while ((e = e.next) != null);            if ((tab[index] = hd) != null)                hd.treeify(tab);        }    }

下面簡單說下添加索引值對put(key,value)的過程：
1，判斷索引值對數組tab[]是否為空白或為null，否則以預設大小resize()；
2，根據索引值key計算hash值得到插入的數組索引i，如果tab[i]==null，直接建立節點添加，否則轉入3
3，判斷當前數組中處理hash衝突的方式為鏈表還是紅/黑樹狀結構(check第一個節點類型即可),分別處理

五，HasMap的擴容機制resize();

構造hash表時，如果不指明初始大小，預設大小為16（即Node數組大小16），如果Node[]數組中的元素達到（填充比*Node.length）重新調整HashMap大小 變為原來2倍大小,擴容很耗時

 /**     * Initializes or doubles table size.  If null, allocates in     * accord with initial capacity target held in field threshold.     * Otherwise, because we are using power-of-two expansion, the     * elements from each bin must either stay at same index, or move     * with a power of two offset in the new table.     *     * @return the table     */    final Node[] resize() {        Node[] 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;            }    /*把新表的長度設定為舊錶長度的兩倍，newCap=2*oldCap*/            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)          /*把新表的門限設定為舊錶門限的兩倍，newThr=oldThr*2*/                newThr = oldThr << 1; // double threshold        }     /*如果舊錶的長度的是0，就是說第一次初始化表*/        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[] newTab = (Node[])new Node[newCap];        table = newTab;//把新表賦值給table        if (oldTab != null) {//原表不是空要把原表中資料移動到新表中               /*遍曆原來的舊錶*/                 for (int j = 0; j < oldCap; ++j) {                Node e;                if ((e = oldTab[j]) != null) {                    oldTab[j] = null;                    if (e.next == null)//說明這個node沒有鏈表直接放在新表的e.hash & (newCap - 1)位置                        newTab[e.hash & (newCap - 1)] = e;                    else if (e instanceof TreeNode)                        ((TreeNode)e).split(this, newTab, j, oldCap);    /*如果e後邊有鏈表,到這裡表示e後面帶著個單鏈表，需要遍曆單鏈表，將每個結點重*/                    else { // preserve order保證順序                    ////新計算在新表的位置，並進行搬運                        Node loHead = null, loTail = null;                        Node hiHead = null, hiTail = null;                        Node next;                        do {                            next = e.next;//記錄下一個結點              //新表是舊錶的兩倍容量，執行個體上就把單鏈表拆分為兩隊，　　　　　　　　　　　　　　//e.hash&oldCap為偶數一隊，e.hash&oldCap為奇數一對                            if ((e.hash & oldCap) == 0) {                                if (loTail == null)                                    loHead = e;                                else                                    loTail.next = e;                                loTail = e;                            }                            else {                                if (hiTail == null)                                    hiHead = e;                                else                                    hiTail.next = e;                                hiTail = e;                            }                        } while ((e = next) != null);                        if (loTail != null) {//lo隊不為null，放在新表原位置                            loTail.next = null;                            newTab[j] = loHead;                        }                        if (hiTail != null) {//hi隊不為null，放在新表j+oldCap位置                            hiTail.next = null;                            newTab[j + oldCap] = hiHead;                        }                    }                }            }        }        return newTab;    }

六，JDK1.8使用紅/黑樹狀結構的改進

在java jdk8中對HashMap的源碼進行了最佳化，在jdk7中，HashMap處理“碰撞”的時候，都是採用鏈表來儲存，當碰撞的結點很多時，查詢時間是O（n）。
在jdk8中，HashMap處理“碰撞”增加了紅/黑樹狀結構這種資料結構，當碰撞結點較少時，採用鏈表格儲存體，當較大時（>8個），採用紅/黑樹狀結構（特點是查詢時間是O（logn））儲存（有一個閥值控制，大於閥值(8個)，將鏈表格儲存體轉換成紅/黑樹狀結構儲存）

問題分析：

你可能還知道雜湊碰撞會對hashMap的效能帶來災難性的影響。如果多個hashCode()的值落到同一個桶內的時候，這些值是儲存到一個鏈表中的。最壞的情況下，所有的key都映射到同一個桶中，這樣hashmap就退化成了一個鏈表——尋找時間從O(1)到O(n)。

隨著HashMap的大小的增長，get()方法的開銷也越來越大。由於所有的記錄都在同一個桶裡的超長鏈表內，平均查詢一條記錄就需要遍曆一半的列表。

JDK1.8HashMap的紅/黑樹狀結構是這樣解決的：

如果某個桶中的記錄過大的話（當前是TREEIFY_THRESHOLD = 8），HashMap會動態使用一個專門的treemap實現來替換掉它。這樣做的結果會更好，是O(logn)，而不是糟糕的O(n)。

它是如何工作的。前面產生衝突的那些KEY對應的記錄只是簡單的追加到一個鏈表後面，這些記錄只能通過遍曆來進行尋找。但是超過這個閾值後HashMap開始將列表升級成一個二叉樹，使用雜湊值作為樹的分支變數，如果兩個雜湊值不等，但指向同一個桶的話，較大的那個會插入到右子樹裡。如果雜湊值相等，HashMap希望key值最好是實現了Comparable介面的，這樣它可以按照順序來進行插入。這對HashMap的key來說並不是必須的，不過如果實現了當然最好。如果沒有實現這個介面，在出現嚴重的雜湊碰撞的時候，你就並別指望能獲得效能提升了。

總之就是一句話：HashMap的底層通過位桶實現，位桶裡面存的是鏈表（1.7以前）或者紅/黑樹狀結構（有序，1.8開始） ，其實就是數組加鏈表（或者紅/黑樹狀結構）的格式，通過判斷hashCode定位位桶中的下標，通過equals定位目標值在鏈表中的位置，所以如果你使用的key使用可變類（非final修飾的類），那麼你在自訂hashCode和equals的時候一定要注意要滿足：如果兩個對象equals那麼一定要hashCode相同，如果是hashCode相同的話不一定要求equals。所以一般來說不要自訂hashCode和equls，推薦使用不可變類對象做key，比如Integer、String等等。

大家也可以看看這個文章：http://www.cnblogs.com/beatIteWeNerverGiveUp/p/5709841.html