1.概述

HashMap可以說是在java中應用最頻繁Map型別了。HashMap 是基於雜湊表的 Map 介面的非同步實現====>這裡可以說明，它不能保證對映的順序，特別是它不能保證該順序亙古不變，因為加入的元素是根據雜湊值來儲存的。HashMap允許儲存null的key值和null的value值。

由於HashMap是基於雜湊表來實現的，所以此實現假定雜湊函式將元素適當地分佈在各桶之間，可為基本操作（get 和 put）提供穩定的效能。迭代 collection 檢視所需的時間與 HashMap 例項的“容量”（桶的數量）及其大小（鍵-值對映關係數）成比例。所以，如果迭代效能很重要，則不要將初始容量設定得太高或將載入因子設定得太低。

需要注意的是：Hashmap 不是同步的，如果多個執行緒同時訪問一個 HashMap，而其中至少一個執行緒從結構上（指新增或者刪除一個或多個對映關係的任何操作）修改了，則必須保持外部同步，以防止對對映進行意外的非同步訪問。

2.實現原理

HashMap中的儲存方式是陣列+連結串列+紅黑樹。其中陣列的型別是Entry型別的陣列，當我們往HashMap內填充元素時，首先會計算其key的hashcode來重新計算key的hash值，並找到陣列中對應的下標，如果該位置目前並沒有元素，則直接把改元素放入陣列中；如果該位置目前已經有了元素，則把新的元素加入到連結串列中。當元素的長度超過閾值（目前為8）時，連結串列則會轉換為紅黑樹，這樣會大大提高我們查詢的效率。

HashMap的儲存結構圖。當連結串列過長時（>8），會轉換成紅黑樹來儲存，以便提高查詢效率：

使用這種儲存方式是為了解決雜湊碰撞的問題，換言之，連結串列中的每個key，都具有相同的雜湊值。最極端的情況就是，當所有的元素都具有相同的雜湊值，那麼HashMap會退化為一個連結串列，查詢時間也從O(1)上升到O（N）。當N越來越大時，get()方法的開銷也越來越大。因此，在JDK1.8裡面加入了一個紅黑樹：當某個桶內的記錄過大的話（>8），HashMap會動態的使用一個專門的treemap實現來替換掉它。這樣做的結果會更好，是O(logn)，而不是糟糕的O(n)。它是如何去工作的呢：

前面產生衝突的那些KEY對應的記錄只是簡單的追加到一個連結串列後面，這些記錄只能通過遍歷來進行查詢。但是超過這個閾值後HashMap開始將列表升級成一個二叉樹，使用雜湊值作為樹的分支變數，如果兩個雜湊值不等，但指向同一個桶的話，較大的那個會插入到右子樹裡。如果雜湊值相等，HashMap希望key值最好是實現了Comparable介面的，這樣它可以按照順序來進行插入。

3.原始碼及分析

首先看一下HashMap的資料域：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, 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;
    static final int TREEIFY_THRESHOLD = 8;
    transient Node<K,V>[] table;
    transient Set<Map.Entry<K,V>> entrySet;
    transient int size;
    transient int modCount;
    int threshold;
    final float loadFactor;

在這裡我們可以看到，HashMap是繼承於AbstractMap，並且實現了Map, Cloneable, Serializable介面。其預設的初始容量為16（DEFAULT_INITIAL_CAPACITY = 1 << 4），最大容量為2的30次冪（MAXIMUM_CAPACITY = 1 << 30），預設的載入因子為0.75（即當HashMap目前儲存的元素超過其初始值*載入因子，即16*0.75=12時，HashMap會進行擴容）。其他的我們可以看到TREEIFY_THRESHOLD = 8;表明當連結串列長度超過8時，會轉化為紅黑樹。

HashMap中涉及的資料結構：

  static class Node<K,V> implements Map.Entry<K,V> {
      //以下4行即為一個Entry 
       final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

HashMap的建構函式：

//建構函式1：指定初始容量和載入因子
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        /*指定的初始容量如果大於最大容量，則預設以最大容量座作為初始容 
         *量，則2的30次冪
          */   
        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);
    }


//建構函式2：指定初始容量
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }


//建構函式3：無引數
   /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
//可以通過註釋看到預設的初始值和載入因子
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }


//建構函式4：
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

我們可以看到，即便我們指定了初始容量，初始容量也未必就是我們指定的大小，因為HashMap的容量始終都是2的次冪，所以當我們傳入一個指定的容量時，還會呼叫一個tableSizeFor(int cap)方法來計算容量的大小：

    /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

HashMap的存取：

1）首先來看存：

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;
        //噹噹前陣列為空時，先進行擴容
        //可以看出，在我們第一次呼叫put方法往HashMap新增元素之和，HashMap的size才開始是初始容量
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //當陣列的當前位置為空時，直接建立一個新的節點並放進去
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //當前位置非空，產生雜湊衝突
        else {
            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) {
                    //當遍歷到連結串列的尾端時，則把需要put的元素加進去
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //判斷衝突的節點數是否已經達到閾值8
                        //如果達到8，則判斷HashMap的size是否已經>=64，如果沒有則只進行擴容
                        //當HashMap的size >= 64並且衝突的節點數達到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，則把新的value覆蓋舊的value，並把舊的value返回
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

通過原始碼可以看到，put(key, value)的過程為：

①檢查tab[]是否為空或null，如果是，則進行擴容

②根據鍵值計算其在陣列中的下標i，如果tab[i] == null，則直接插入新建的節點

③若tab[i]已經有元素儲存了，則判斷當前處理節點的方式為連結串列還是紅黑樹，分別處理

在儲存的時候，有一個細節需要注意一下：注意到p = tab[i = (n - 1) & hash]，其中的陣列下標是通過（n-1）&hash的方式來計算出來的，這裡處理的非常巧妙：

對於任意給定的物件，只要它的 hashCode() 返回值相同，那麼程式得到的 hash 碼值總是相同的。我們首先想到的就是把 hash 值對陣列長度取模運算，這樣一來，元素的分佈相對來說是比較均勻的。但是，“模”運算的消耗還是比較大的，而HashMap的底層陣列的大小總是為2的n次冪，此時，h& (length-1)運算等價於對 length 取模，也就是 h%length。

舉個例子說明：

我們可以看到，當陣列長度為15時，8或9與其相與，都會產生相同的結果，此時就會發生雜湊衝突，8和9都會放到陣列中的同一個位置，形成連結串列，這樣會降低了查詢的效率。同時，我們可以發現，當陣列長度不為2的n次冪時，table.length-1永遠會有0存在，而0無論是和1還是0相與，結果都為0。比如說，長度為15，那麼15-1=14，其二進位制為1110，此時，無論什麼數與1110相與，末尾都為0，這時候，0001，0011，0101，1001，1011，0111，1101 這幾個位置永遠都不能存放元素了，空間浪費相當大，更糟的是這種情況中，陣列可以使用的位置比陣列長度小了很多，這意味著進一步增加了碰撞的機率，減慢了查詢的效率！而當陣列的長度為2的n次冪時，table.length-1得到的二進位制數的每個位上的值都為 1，這使得在低位上&時，得到的和原 hash 的低位相同，就使得只有相同的 hash 值的兩個值才會被放到陣列中的同一個位置上形成連結串列。所以說，當陣列長度為 2 的 n 次冪的時候，不同的 key 算得得 index 相同的機率較小，那麼資料在陣列上分佈就比較均勻，也就是說碰撞的機率小，相對的，查詢的時候就不用遍歷某個位置上的連結串列，這樣查詢效率也就較高了

2）HashMap的取

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

    /**
     * Implements Map.get and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //找到第一個插入的node
        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;
            //當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值，並計算得到此key在陣列中的位置：first = tab[(n - 1) & hash]，如果first節點不是需要獲取的key，則往下遍歷，直到找到需要獲取的鍵值，並返回對應的value即可。

HashMap的擴容機制

    /**
     * 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<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;
            }
            //舊錶的長度不為0，則把新表的容量設定為舊錶容量的兩倍
            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;
        //如果舊錶的長度為0，則說明是第一次初始化
        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;
                    //e.next為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 { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        //遍歷連結串列
                        do {
                            next = e.next;
                            //將連結串列的節點拆分為兩隊，e.hash&oldCap結果為0的一隊，結果為1的為另一隊
                            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) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

當HashMap中的元素越來越多的時候，產生雜湊衝突的機率也就越來越大，畢竟陣列的長度是固定的。為了減小雜湊衝突的機率，同時也是為了提高查詢效率，我們需要對HashMap適當的進行擴容。而擴容也不是產生雜湊衝突之後就開始執行，而是要滿足一定條件之後才擴容：當HashMap中元素的個數已經達到閾值，則table.length * loadFactory，比如說採用無引數構造器去建立一個HashMap，那麼table.length * loadFactory = 16 * 0.75 == 12，即當HashMap中的元素個數達到12時，HashMap才開始擴容。擴容之後的大小為之前的兩倍。我們在原始碼中可以看到，擴容是一項很費時的操作，如果我們能夠預知HashMap中元素的個數，那麼在初始化時指定初始值以及載入因子來規避擴容，也是提高效能的一種方法。

Fail-Fast機制

原理

fail-fast 機制是 java 集合(Collection)中的一種錯誤機制。 當多個執行緒對同一個集合的內容進行操作時，就可能會產生 fail-fast 事件。

比如說，線上程A通過iterator去訪問集合時，如果有其他執行緒修改了該集合，那麼A執行緒這裡就會丟擲 ConcurrentModificationException 異常，產生 fail-fast 事件。

我們知道，java.util.HashMap不是執行緒安全的，在多執行緒的環境中，如果A執行緒正在通過iterator去訪問這個map，而其他執行緒則修改了該map，那麼A執行緒就會丟擲一個ConcurrentModificationException異常。

這個策略在原始碼中的實現則是通過modCount，每一次修改map中的內容，modCount的值都會增加，在迭代器開始的過程中，會把modCount的值賦給迭代器的 expectedModCount：

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

在迭代過程中，判斷 modCount 跟 expectedModCount 是否相等，如果不相等就表示已經有其他執行緒修改了 map：

       final Node<K,V> nextNode() {
            Node<K,V>[] t;
            Node<K,V> e = next;
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            ...
        }

注意，迭代器的快速失敗行為不能得到保證，一般來說，存在非同步的併發修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力丟擲 ConcurrentModificationException。因此，編寫依賴於此異常的程式的做法是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測程式錯誤。

解決方案

fail-fast 機制，是一種錯誤檢測機制。它只能被用來檢測錯誤，因為 JDK 並不保證 fail-fast 機制一定會發生。若在多執行緒環境下使用 fail-fast 機制的集合，建議使用“java.util.concurrent 包下的類”去取代“java.util 包下的類”。

參考：https://wiki.jikexueyuan.com/project/java-collection/hashmap.html