一、HashMap簡介 

基於雜湊表的 Map 介面的實現。此實現提供所有可選的對映操作，並允許key和value為null(但是隻能有一個key為null，且key不能重複，value可以重複)。(除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。)此類不保證對映的順序，特別是它不保證該順序恆久不變。 此實現假定雜湊函式將元素適當地分佈在各桶之間，可為基本操作(get 和 put)提供穩定的效能。迭代 collection 檢視所需的時間與 HashMap 例項的"容量"(桶的數量)及其大小(鍵-值對映關係數)成比例。所以，如果迭代效能很重要，則不要將初始容量設定得太高(或將載入因子設定得太低)。HashMap 的例項有兩個引數影響其效能:初始容量 和載入因子。容量是

二、HashMap資料結構

　　說明：上圖很形象的展示了HashMap的資料結構（陣列+連結串列+紅黑樹），桶中的結構可能是連結串列，也可能是紅黑樹，紅黑樹的引入是為了提高效率。所以可見，在分析原始碼的時候我們不知不覺就溫習了資料結構的知識點，一舉兩得。我希望你接下來能花上2個小時靜靜的看完下面的原始碼分析，我相信看完之後你就知道HashMap原始碼原來寫的這麼好！！！

三、HashMap原始碼分析

package java.util;

import sun.misc.SharedSecrets;

import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * HashMap是常用的Java集合之一，是基於雜湊表的Map介面的實現。與HashTable主要區別為不支援同步和允許null作為key和value。
 * HashMap非執行緒安全，即任一時刻可以有多個執行緒同時寫HashMap，可能會導致資料的不一致。
 * 如果需要滿足執行緒安全，可以用 Collections的synchronizedMap方法使HashMap具有執行緒安全的能力，或者使用ConcurrentHashMap。
 * 在JDK1.6中，HashMap採用陣列+連結串列實現，即使用連結串列處理衝突，同一hash值的連結串列都儲存在一個連結串列裡。
 * 但是當位於一個數組中的元素較多，即hash值相等的元素較多時，通過key值依次查詢的效率較低。
 * 而JDK1.8中，HashMap採用陣列+連結串列+紅黑樹實現，當連結串列長度超過閾值8時，將連結串列轉換為紅黑樹，這樣大大減少了查詢時間。
 * 原本Map.Entry介面的實現類Entry改名為了Node。轉化為紅黑樹時改用另一種實現TreeNode。
 */
public class HashMap<K, V> extends AbstractMap<K, V>
        implements Map<K, V>, Cloneable, Serializable {

    private static final long serialVersionUID = 362498820763181265L;


    /**
     * 預設的初始容量（容量為HashMap中槽的數目）是16，且實際容量必須是2的整數次冪。
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 最大容量（必須是2的冪且小於2的30次方，傳入容量過大將被這個值替換）
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 預設裝填因子0.75，如果當前鍵值對個數 >= HashMap最大容量*裝填因子，進行rehash操作
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * JDK1.8 新加，Entry連結串列最大長度，當桶中節點數目大於該長度時，將連結串列轉成紅黑樹儲存；
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * JDK1.8 新加，當桶中節點數小於該長度，將紅黑樹轉為連結串列儲存；
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 桶可能被轉化為樹形結構的最小容量。當雜湊表的大小超過這個閾值，才會把鏈式結構轉化成樹型結構，否則僅採取擴容來嘗試減少衝突。
     * 應該至少4*TREEIFY_THRESHOLD來避免擴容和樹形結構化之間的衝突。
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

    /**
     * JDK1.6用Entry描述鍵值對，JDK1.8中用Node代替Entry
     */
    static class Node<K, V> implements Map.Entry<K, V> {
        // hash儲存key的hashCode
        final int hash;
        // final:一個鍵值對的key不可改變
        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;
        }

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

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

    /* ---------------- Static utilities -------------- */

    /**
     * HashMap中鍵值對的儲存形式為連結串列節點，hashCode相同的節點（位於同一個桶）用連結串列組織
     * hash方法分為三步:
     * 1.取key的hashCode
     * 2.key的hashCode高16位異或低16位
     * 3.將第一步和第二步得到的結果進行取模運算。
     */
    static final int hash(Object key) {
        int h;
        //計算key的hashCode, h = Objects.hashCode(key)
        //h >>> 16表示對h無符號右移16位，高位補0，然後h與h >>> 16按位異或
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    /**
     * 如果引數x實現了Comparable介面，返回引數x的類名，否則返回null
     */
    static Class<?> comparableClassFor(Object x) {
        if (x instanceof Comparable) {
            Class<?> c;
            Type[] ts, as;
            Type t;
            ParameterizedType p;
            if ((c = x.getClass()) == String.class) // bypass checks
                return c;
            if ((ts = c.getGenericInterfaces()) != null) {
                for (int i = 0; i < ts.length; ++i) {
                    if (((t = ts[i]) instanceof ParameterizedType) &&
                            ((p = (ParameterizedType) t).getRawType() ==
                                    Comparable.class) &&
                            (as = p.getActualTypeArguments()) != null &&
                            as.length == 1 && as[0] == c) // type arg is c
                        return c;
                }
            }
        }
        return null;
    }

    /**
     * 如果x的型別為kc，則返回k.compareTo(x)，否則返回0
     */
    @SuppressWarnings({"rawtypes", "unchecked"}) // for cast to Comparable
    static int compareComparables(Class<?> kc, Object k, Object x) {
        return (x == null || x.getClass() != kc ? 0 :
                ((Comparable) k).compareTo(x));
    }

    /**
     * 結果為>=cap的最小2的自然數冪
     */
    static final int tableSizeFor(int cap) {
        //先移位再或運算，最終保證返回值是2的整數冪
        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;
    }

    /* ---------------- Fields -------------- */

    /**
     * 雜湊桶陣列，分配的時候，table的長度總是2的冪
     */
    transient Node<K, V>[] table;

    /**
     * HashMap將資料轉換成set的另一種儲存形式，這個變數主要用於迭代功能
     */
    transient Set<Map.Entry<K, V>> entrySet;

    /**
     * 實際儲存的數量，則HashMap的size()方法，實際返回的就是這個值，isEmpty()也是判斷該值是否為0
     */
    transient int size;

    /**
     * hashmap結構被改變的次數，fail-fast機制
     */
    transient int modCount;

    /**
     * HashMap的擴容閾值，在HashMap中儲存的Node鍵值對超過這個數量時，自動擴容容量為原來的二倍
     *
     * @serial
     */
    int threshold;

    /**
     * HashMap的負載入因子，可計算出當前table長度下的擴容閾值：threshold = loadFactor * table.length
     *
     * @serial
     */
    final float loadFactor;

    /* ---------------- Public operations -------------- */

    /**
     * 使用指定的初始化容量initial capacity 和載入因子load factor構造一個空HashMap
     *
     * @param initialCapacity 初始化容量
     * @param loadFactor      載入因子
     * @throws IllegalArgumentException 如果指定的初始化容量為負數或者載入因子為非正數
     */
    public 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);
    }

    /**
     * 使用指定的初始化容量initial capacity和預設載入因子DEFAULT_LOAD_FACTOR（0.75）構造一個空HashMap
     *
     * @param initialCapacity 初始化容量
     * @throws IllegalArgumentException 如果指定的初始化容量為負數
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * 使用指定的初始化容量（16）和預設載入因子DEFAULT_LOAD_FACTOR（0.75）構造一個空HashMap
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    /**
     * 使用指定Map m構造新的HashMap。使用指定的初始化容量（16）和預設載入因子DEFAULT_LOAD_FACTOR（0.75）
     *
     * @param m 指定的map
     * @throws NullPointerException 如果指定的map是null
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

    /**
     * Map.putAll and Map constructor的實現需要的方法
     * 將m的鍵值對插入本map中
     *
     * @param m     指定的map
     * @param evict 初始化map時使用false，否則使用true
     */
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        //如果引數map不為空
        if (s > 0) {
            // 判斷table是否已經初始化
            if (table == null) { // pre-size
                // 未初始化，s為m的實際元素個數
                float ft = ((float) s / loadFactor) + 1.0F;
                int t = ((ft < (float) MAXIMUM_CAPACITY) ?
                        (int) ft : MAXIMUM_CAPACITY);
                // 計算得到的t大於閾值，則初始化閾值
                if (t > threshold)
                    //根據容量初始化臨界值
                    threshold = tableSizeFor(t);
                // 已初始化，並且m元素個數大於閾值，進行擴容處理
            } else if (s > threshold)
                //擴容處理
                resize();
            // 將m中的所有元素新增至HashMap中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

    /**
     * 返回map中鍵值對對映的個數
     *
     * @return map中鍵值對對映的個數
     */
    public int size() {
        return size;
    }

    /**
     * 如果map中沒有鍵值對對映，返回true
     *
     * @return 如果map中沒有鍵值對對映，返回true
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 返回指定的key對映的value，如果value為null，則返回null
     * get可以分為三個步驟：
     * 1.通過hash(Object key)方法計算key的雜湊值hash。
     * 2.通過getNode( int hash, Object key)方法獲取node。
     * 3.如果node為null，返回null，否則返回node.value。
     *
     * @see #put(Object, Object)
     */
    public V get(Object key) {
        Node<K, V> e;
        //根據key及其hash值查詢node節點，如果存在，則返回該節點的value值
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    /**
     * 根據key的雜湊值和key獲取對應的節點
     * getNode可分為以下幾個步驟：
     * 1.如果雜湊表為空，或key對應的桶為空，返回null
     * 2.如果桶中的第一個節點就和指定引數hash和key匹配上了，返回這個節點。
     * 3.如果桶中的第一個節點沒有匹配上，而且有後續節點
     * 3.1如果當前的桶採用紅黑樹，則呼叫紅黑樹的get方法去獲取節點
     * 3.2如果當前的桶不採用紅黑樹，即桶中節點結構為鏈式結構，遍歷連結串列，直到key匹配
     * 4.找到節點返回null，否則返回null。
     *
     * @param hash 指定引數key的雜湊值
     * @param key  指定引數key
     * @return 返回node，如果沒有則返回null
     */
    final Node<K, V> getNode(int hash, Object key) {
        Node<K, V>[] tab;
        Node<K, V> first, e;
        int n;
        K k;
        //如果雜湊表不為空，而且key對應的桶上不為空
        if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & hash]) != null) {
            //如果桶中的第一個節點就和指定引數hash和key匹配上了
            if (first.hash == hash && // always check first node
                    ((k = first.key) == key || (key != null && key.equals(k))))
                //返回桶中的第一個節點
                return first;
            //如果桶中的第一個節點沒有匹配上，而且有後續節點
            if ((e = first.next) != null) {
                //如果當前的桶採用紅黑樹，則呼叫紅黑樹的get方法去獲取節點
                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);
            }
        }
        //如果雜湊表為空，或者沒有找到節點，返回null
        return null;
    }

    /**
     * 如果map中含有key為指定引數key的鍵值對，返回true
     *
     * @param key 指定引數key
     * @return 如果map中含有key為指定引數key的鍵值對，返回true
     * key.
     */
    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }

    /**
     * 將指定引數key和指定引數value插入map中，如果key已經存在，那就替換key對應的value
     * put(K key, V value)可以分為三個步驟：
     * 1.通過hash(Object key)方法計算key的雜湊值。
     * 2.通過putVal(hash(key), key, value, false, true)方法實現功能。
     * 3.返回putVal方法返回的結果。
     *
     * @param key   指定key
     * @param value 指定value
     * @return 如果value被替換，則返回舊的value，否則返回null。當然，可能key對應的value就是null
     */
    public V put(K key, V value) {
        // 倒數第二個引數false：表示允許舊值替換
        // 最後一個引數true：表示HashMap不處於建立模式
        return putVal(hash(key), key, value, false, true);
    }

    /**
     * Map.put和其他相關方法的實現需要的方法
     * putVal方法可以分為下面的幾個步驟:
     * 1.如果雜湊表為空，呼叫resize()建立一個雜湊表。
     * 2.如果指定引數hash在表中沒有對應的桶，即為沒有碰撞，直接將鍵值對插入到雜湊表中即可。
     * 3.如果有碰撞，遍歷桶，找到key對映的節點
     * 3.1桶中的第一個節點就匹配了，將桶中的第一個節點記錄起來。
     * 3.2如果桶中的第一個節點沒有匹配，且桶中結構為紅黑樹，則呼叫紅黑樹對應的方法插入鍵值對。
     * 3.3如果不是紅黑樹，那麼就肯定是連結串列。遍歷連結串列，如果找到了key對映的節點，就記錄這個節點，退出迴圈。如果沒有找到，在連結串列尾部插入節點。插入後，如果鏈的長度大於TREEIFY_THRESHOLD這個臨界值，則使用treeifyBin方法把連結串列轉為紅黑樹。
     * 4.如果找到了key對映的節點，且節點不為null
     * 4.1記錄節點的vlaue。
     * 4.2如果引數onlyIfAbsent為false，或者oldValue為null，替換value，否則不替換。
     * 4.3返回記錄下來的節點的value。
     * 5.如果沒有找到key對映的節點（2、3步中講了，這種情況會插入到hashMap中），插入節點後size會加1，這時要檢查size是否大於臨界值threshold，如果大於會使用resize方法進行擴容。
     *
     * @param hash         指定引數key的雜湊值
     * @param key          指定引數key
     * @param value        指定引數value
     * @param onlyIfAbsent 如果為true，即使指定引數key在map中已經存在，也不會替換value
     * @param evict        如果為false，陣列table在建立模式中
     * @return 如果value被替換，則返回舊的value，否則返回null。當然，可能key對應的value就是null。
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K, V>[] tab;
        Node<K, V> p;
        int n, i;
        //如果雜湊表為空，呼叫resize()建立一個雜湊表，並用變數n記錄雜湊表長度
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**
         * 如果指定引數hash在表中沒有對應的桶，即為沒有碰撞
         * Hash函式，(n - 1) & hash 計算key將被放置的槽位
         * (n - 1) & hash 本質上是hash % n，位運算更快
         */
        if ((p = tab[i = (n - 1) & hash]) == null)
            //直接將鍵值對插入到map中即可
            tab[i] = newNode(hash, key, value, null);
        else {// 桶中已經存在元素
            Node<K, V> e;
            K k;
            // 比較桶中第一個元素(陣列中的結點)的hash值相等，key相等
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 將第一個元素賦值給e，用e來記錄
                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;
                    }
                    // 連結串列節點的<key, value>與put操作<key, value>相同時，不做重複操作，跳出迴圈
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 找到或新建一個key和hashCode與插入元素相等的鍵值對，進行put操作
            if (e != null) { // existing mapping for key
                // 記錄e的value
                V oldValue = e.value;
                /**
                 * onlyIfAbsent為false或舊值為null時，允許替換舊值
                 * 否則無需替換
                 */
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                // 訪問後回撥
                afterNodeAccess(e);
                // 返回舊值
                return oldValue;
            }
        }
        // 更新結構化修改資訊
        ++modCount;
        // 鍵值對數目超過閾值時，進行rehash
        if (++size > threshold)
            resize();
        // 插入後回撥
        afterNodeInsertion(evict);
        return null;
    }

    /**
     * 對table進行初始化或者擴容。
     * 如果table為null，則對table進行初始化
     * 如果對table擴容，因為每次擴容都是翻倍，與原來計算（n-1）&hash的結果相比，節點要麼就在原來的位置，要麼就被分配到“原位置+舊容量”這個位置
     * resize的步驟總結為:
     * 1.計算擴容後的容量，臨界值。
     * 2.將hashMap的臨界值修改為擴容後的臨界值
     * 3.根據擴容後的容量新建陣列，然後將hashMap的table的引用指向新陣列。
     * 4.將舊陣列的元素複製到table中。
     *
     * @return the table
     */
    final Node<K, V>[] resize() {
        //新建oldTab陣列儲存擴容前的陣列table
        Node<K, V>[] oldTab = table;
        //獲取原來陣列的長度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //原來陣列擴容的臨界值
        int oldThr = threshold;
        int newCap, newThr = 0;
        //如果擴容前的容量 > 0
        if (oldCap > 0) {
            //如果原來的陣列長度大於最大值(2^30)
            if (oldCap >= MAXIMUM_CAPACITY) {
                //擴容臨界值提高到正無窮
                threshold = Integer.MAX_VALUE;
                //無法進行擴容，返回原來的陣列
                return oldTab;
                //如果現在容量的兩倍小於MAXIMUM_CAPACITY且現在的容量大於DEFAULT_INITIAL_CAPACITY
            } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                //臨界值變為原來的2倍
                newThr = oldThr << 1;
        } else if (oldThr > 0) //如果舊容量 <= 0，而且舊臨界值 > 0
            //陣列的新容量設定為老陣列擴容的臨界值
            newCap = oldThr;
        else { //如果舊容量 <= 0，且舊臨界值 <= 0，新容量擴充為預設初始化容量，新臨界值為DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY
            newCap = DEFAULT_INITIAL_CAPACITY;//新陣列初始容量設定為預設值
            newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//計算預設容量下的閾值
        }
        // 計算新的resize上限
        if (newThr == 0) {//在當上面的條件判斷中，只有oldThr > 0成立時，newThr == 0
            //ft為臨時臨界值，下面會確定這個臨界值是否合法，如果合法，那就是真正的臨界值
            float ft = (float) newCap * loadFactor;
            //當新容量< MAXIMUM_CAPACITY且ft < (float)MAXIMUM_CAPACITY，新的臨界值為ft，否則為Integer.MAX_VALUE
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
                    (int) ft : Integer.MAX_VALUE);
        }
        //將擴容後hashMap的臨界值設定為newThr
        threshold = newThr;
        //建立新的table，初始化容量為newCap
        @SuppressWarnings({"rawtypes", "unchecked"})
        Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
        //修改hashMap的table為新建的newTab
        table = newTab;
        //如果舊table不為空，將舊table中的元素複製到新的table中
        if (oldTab != null) {
            //遍歷舊雜湊表的每個桶，將舊雜湊表中的桶複製到新的雜湊表中
            for (int j = 0; j < oldCap; ++j) {
                Node<K, V> e;
                //如果舊桶不為null，使用e記錄舊桶
                if ((e = oldTab[j]) != null) {
                    //將舊桶置為null
                    oldTab[j] = null;
                    //如果舊桶中只有一個node
                    if (e.next == null)
                        //將e也就是oldTab[j]放入newTab中e.hash & (newCap - 1)的位置
                        newTab[e.hash & (newCap - 1)] = e;
                        //如果舊桶中的結構為紅黑樹
                    else if (e instanceof TreeNode)
                        //將樹中的node分離
                        ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                    else {  //如果舊桶中的結構為連結串列,連結串列重排，jdk1.8做的一系列優化
                        Node<K, V> loHead = null, loTail = null;
                        Node<K, V> hiHead = null, hiTail = null;
                        Node<K, V> next;
                        //遍歷整個連結串列中的節點
                        do {
                            next = e.next;
                            // 原索引
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            } else {// 原索引+oldCap
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 原索引放到bucket裡
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // 原索引+oldCap放到bucket裡
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

    /**
     * 將連結串列轉化為紅黑樹
     */
    final void treeifyBin(Node<K, V>[] tab, int hash) {
        int n, index;
        Node<K, V> e;
        //如果桶陣列table為空，或者桶陣列table的長度小於MIN_TREEIFY_CAPACITY，不符合轉化為紅黑樹的條件
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            //擴容
            resize();
            //如果符合轉化為紅黑樹的條件，而且hash對應的桶不為null
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            // 紅黑樹的頭、尾節點
            TreeNode<K, V> hd = null, tl = null;
            //遍歷連結串列
            do {
                //替換連結串列node為樹node，建立雙向連結串列
                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);
        }
    }

    /**
     * 將引數map中的所有鍵值對對映插入到hashMap中，如果有碰撞，則覆蓋value。
     *
     * @param m 引數map
     * @throws NullPointerException 如果map為null
     */
    public void putAll(Map<? extends K, ? extends V> m) {
        putMapEntries(m, true);
    }

    /**
     * 刪除hashMap中key對映的node
     * remove方法的實現可以分為三個步驟：
     * 1.通過 hash(Object key)方法計算key的雜湊值。
     * 2.通過 removeNode 方法實現功能。
     * 3.返回被刪除的node的value。
     *
     * @param key 引數key
     * @return 如果沒有對映到node，返回null，否則返回對應的value
     */
    public V remove(Object key) {
        Node<K, V> e;
        //根據key來刪除node。removeNode方法的具體實現在下面
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
                null : e.value;
    }

    /**
     * Map.remove和相關方法的實現需要的方法
     * removeNode方法的步驟總結為:
     * 1.如果陣列table為空或key對映到的桶為空，返回null。
     * 2.如果key對映到的桶上第一個node的就是要刪除的node，記錄下來。
     * 3.如果桶內不止一個node，且桶內的結構為紅黑樹，記錄key對映到的node。
     * 4.桶內的結構不為紅黑樹，那麼桶內的結構就肯定為連結串列，遍歷連結串列，找到key對映到的node，記錄下來。
     * 5.如果被記錄下來的node不為null，刪除node，size-1被刪除。
     * 6.返回被刪除的node。
     *
     * @param hash       key的雜湊值
     * @param key        key的雜湊值
     * @param value      如果 matchValue 為true，則value也作為確定被刪除的node的條件之一，否則忽略
     * @param matchValue 如果為true，則value也作為確定被刪除的node的條件之一
     * @param movable    如果為false，刪除node時不會刪除其他node
     * @return 返回被刪除的node，如果沒有node被刪除，則返回null（針對紅黑樹的刪除方法）
     */
    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;
        //如果陣列table不為空且key對映到的桶不為空
        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;
            //如果桶上第一個node的就是要刪除的node
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                //記錄桶上第一個node
                node = p;
            else if ((e = p.next) != null) {//如果桶內不止一個node
                //如果桶內的結構為紅黑樹
                if (p instanceof TreeNode)
                    //記錄key對映到的node
                    node = ((TreeNode<K, V>) p).getTreeNode(hash, key);
                else {//如果桶內的結構為連結串列
                    do {//遍歷連結串列，找到key對映到的node
                        if (e.hash == hash &&
                                ((k = e.key) == key ||
                                        (key != null && key.equals(k)))) {
                            //記錄key對映到的node
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            //如果得到的node不為null且(matchValue為false||node.value和引數value匹配)
            if (node != null && (!matchValue || (v = node.value) == value ||
                    (value != null && value.equals(v)))) {
                //如果桶內的結構為紅黑樹
                if (node instanceof TreeNode)
                    //使用紅黑樹的刪除方法刪除node
                    ((TreeNode<K, V>) node).removeTreeNode(this, tab, movable);
                else if (node == p)//如果桶的第一個node的就是要刪除的node
                    //刪除node
                    tab[index] = node.next;
                else//如果桶內的結構為連結串列，使用連結串列刪除元素的方式刪除node
                    p.next = node.next;
                ++modCount;//結構性修改次數+1
                --size;//雜湊表大小-1
                afterNodeRemoval(node);
                return node;//返回被刪除的node
            }
        }
        return null;//如果陣列table為空或key對映到的桶為空，返回null。
    }

    /**
     * 刪除map中所有的鍵值對
     */
    public void clear() {
        Node<K, V>[] tab;
        modCount++;
        if ((tab = table) != null && size > 0) {
            size = 0;
            for (int i = 0; i < tab.length; ++i)
                tab[i] = null;
        }
    }

    /**
     * 如果hashMap中的鍵值對有一對或多對的value為引數value，返回true
     *
     * @param value 引數value
     * @return 如果hashMap中的鍵值對有一對或多對的value為引數value，返回true
     */
    public boolean containsValue(Object value) {
        Node<K, V>[] tab;
        V v;
        if ((tab = table) != null && size > 0) {
            //遍歷陣列table
            for (int i = 0; i < tab.length; ++i) {
                //遍歷桶中的node
                for (Node<K, V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                            (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

    /**
     * 返回hashMap中所有key的檢視。
     * 改變hashMap會影響到set，反之亦然。
     * 如果當迭代器迭代set時，hashMap被修改(除非是迭代器自己的remove()方法)，迭代器的結果是不確定的。
     * set支援元素的刪除，通過Iterator.remove、Set.remove、removeAll、retainAll、clear操作刪除hashMap中對應的鍵值對。
     * 不支援add和addAll方法。
     *
     * @return 返回hashMap中所有key的set檢視
     */
    public Set<K> keySet() {
        Set<K> ks = keySet;
        if (ks == null) {
            ks = new KeySet();
            keySet = ks;
        }
        return ks;
    }

    /**
     * 內部類KeySet
     */
    final class KeySet extends AbstractSet<K> {
        public final int size() {
            return size;
        }

        public final void clear() {
            HashMap.this.clear();
        }

        public final Iterator<K> iterator() {
            return new KeyIterator();
        }

        public final boolean contains(Object o) {
            return containsKey(o);
        }

        public final boolean remove(Object key) {
            return removeNode(hash(key), key, null, false, true) != null;
        }

        public final Spliterator<K> spliterator() {
            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }

        public final void forEach(Consumer<? super K> action) {
            Node<K, V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K, V> e = tab[i]; e != null; e = e.next)
                        action.accept(e.key);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }

    /**
     * 返回hashMap中所有value的collection檢視
     * 改變hashMap會改變collection，反之亦然。
     * 如果當迭代器迭代collection時，hashMap被修改（除非是迭代器自己的remove()方法），迭代器的結果是不確定的。
     * collection支援元素的刪除，通過Iterator.remove、Collection.remove、removeAll、retainAll、clear操作刪除hashMap中對應的鍵值對。
     * 不支援add和addAll方法。
     *
     * @return 返回hashMap中所有key的collection檢視
     */
    public Collection<V> values() {
        Collection<V> vs = values;
        if (vs == null) {
            vs = new Values();
            values = vs;
        }
        return vs;
    }

    /**
     * 內部類Values
     */
    final class Values extends AbstractCollection<V> {
        public final int size() {
            return size;
        }

        public final void clear() {
            HashMap.this.clear();
        }

        public final Iterator<V> iterator() {
            return new ValueIterator();
        }

        public final boolean contains(Object o) {
            return containsValue(o);
        }

        public final Spliterator<V> spliterator() {
            return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
        }

        public final void forEach(Consumer<? super V> action) {
            Node<K, V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K, V> e = tab[i]; e != null; e = e.next)
                        action.accept(e.value);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }

    /**
     * 返回hashMap中所有鍵值對的set檢視
     * 改變hashMap會影響到set，反之亦然。
     * 如果當迭代器迭代set時，hashMap被修改(除非是迭代器自己的remove()方法)，迭代器的結果是不確定的。
     * set支援元素的刪除，通過Iterator.remove、Set.remove、removeAll、retainAll、clear操作刪除hashMap中對應的鍵值對。
     * 不支援add和addAll方法。
     *
     * @return 返回hashMap中所有鍵值對的set檢視
     */
    public Set<Map.Entry<K, V>> entrySet() {
        Set<Map.Entry<K, V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

    /**
     * 內部類EntrySet
     */
    final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
        public final int size() {
            return size;
        }

        public final void clear() {
            HashMap.this.clear();
        }

        public final Iterator<Map.Entry<K, V>> iterator() {
            return new EntryIterator();
        }

        public final boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
            Object key = e.getKey();
            Node<K, V> candidate = getNode(hash(key), key);
            return candidate != null && candidate.equals(e);
        }

        public final boolean remove(Object o) {
            if (o instanceof Map.Entry) {
                Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
                Object key = e.getKey();
                Object value = e.getValue();
                return removeNode(hash(key), key, value, true, true) != null;
            }
            return false;
        }

        public final Spliterator<Map.Entry<K, V>> spliterator() {
            return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }

        public final void forEach(Consumer<? super Map.Entry<K, V>> action) {
            Node<K, V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K, V> e = tab[i]; e != null; e = e.next)
                        action.accept(e);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }

    // JDK8重寫的方法

    /**
     * 通過key對映到對應node，如果沒對映到則返回預設值defaultValue
     *
     * @param key
     * @param defaultValue
     * @return key對映到對應的node，如果沒對映到則返回預設值defaultValue
     */
    @Override
    public V getOrDefault(Object key, V defaultValue) {
        Node<K, V> e;
        return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
    }

    /**
     * 在hashMap中插入引數key和value組成的鍵值對，如果key在hashMap中已經存在，不替換value
     *
     * @param key
     * @param value
     * @return 如果key在hashMap中不存在，返回舊value
     */
    @Override
    public V putIfAbsent(K key, V value) {
        return putVal(hash(key), key, value, true, true);
    }

    /**
     * 刪除hashMap中key為引數key，value為引數value的鍵值對。如果桶中結構為樹，則級聯刪除
     *
     * @param key
     * @param value
     * @return 刪除成功，返回true
     */
    @Override
    public boolean remove(Object key, Object value) {
        return removeNode(hash(key), key, value, true, true) != null;
    }

    /**
     * 使用newValue替換key和oldValue對映到的鍵值對中的value
     *
     * @param key
     * @param oldValue
     * @param newValue
     * @return 替換成功，返回true
     */
    @Override
    public boolean replace(K key, V oldValue, V newValue) {
        Node<K, V> e;
        V v;
        if ((e = getNode(hash(key), key)) != null &&
                ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
            e.value = newValue;
            afterNodeAccess(e);
            return true;
        }
        return false;
    }

    /**
     * 使用引數value替換key對映到的鍵值對中的value
     *
     * @param key
     * @param value
     * @return 替換成功，返回true
     */
    @Override
    public V replace(K key, V value) {
        Node<K, V> e;
        if ((e = getNode(hash(key), key)) != null) {
            V oldValue = e.value;
            e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
        return null;
    }

   

    @Override
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        Node<K, V>[] tab;
        if (function == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K, V> e = tab[i]; e != null; e = e.next) {
                    e.value = function.apply(e.key, e.value);
                }
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }

    /* ------------------------------------------------------------ */
    // 克隆和序列化

    /**
     * 淺拷貝。
     * clone方法雖然生成了新的HashMap物件，新的HashMap中的table陣列雖然也是新生成的，但是陣列中的元素還是引用以前的HashMap中的元素。
     * 這就導致在對HashMap中的元素進行修改的時候，即對陣列中元素進行修改，會導致原物件和clone物件都發生改變，但進行新增或刪除就不會影響對方，因為這相當於是對陣列做出的改變，clone物件新生成了一個數組。
     *
     * @return hashMap的淺拷貝
     */
    @SuppressWarnings("unchecked")
    @Override
    public Object clone() {
        HashMap<K, V> result;
        try {
            result = (HashMap<K, V>) super.clone();
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
        result.reinitialize();
        result.putMapEntries(this, false);
        return result;
    }

    // These methods are also used when serializing HashSets
    final float loadFactor() {
        return loadFactor;
    }

    final int capacity() {
        return (table != null) ? table.length :
                (threshold > 0) ? threshold :
                        DEFAULT_INITIAL_CAPACITY;
    }

    /**
     * 序列化hashMap到ObjectOutputStream中
     * 將hashMap的總容量capacity、實際容量size、鍵值對對映寫入到ObjectOutputStream中。鍵值對對映序列化時是無序的。
     *
     * @serialData The <i>capacity</i> of the HashMap (the length of the
     * bucket array) is emitted (int), followed by the
     * <i>size</i> (an int, the number of key-value
     * mappings), followed by the key (Object) and value (Object)
     * for each key-value mapping.  The key-value mappings are
     * emitted in no particular order.
     */
    private void writeObject(java.io.ObjectOutputStream s)
            throws IOException {
        int buckets = capacity();
        // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();
        //寫入總容量
        s.writeInt(buckets);
        //寫入實際容量
        s.writeInt(size);
        //寫入鍵值對
        internalWriteEntries(s);
    }

    /**
     * 到ObjectOutputStream中讀取hashMap
     * 將hashMap的總容量capacity、實際容量size、鍵值對對映讀取出來
     */
    private void readObject(java.io.ObjectInputStream s)
            throws IOException, ClassNotFoundException {
        // 將hashMap的總容量capacity、實際容量size、鍵值對對映讀取出來
        s.defaultReadObject();
        //重置hashMap
        reinitialize();
        //如果載入因子不合法，丟擲異常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new InvalidObjectException("Illegal load factor: " +
                    loadFactor);
        s.readInt();                //讀出桶的數量，忽略
        int mappings = s.readInt(); //讀出實際容量size
        //如果讀出的實際容量size小於0，丟擲異常
        if (mappings < 0)
            throw new InvalidObjectException("Illegal mappings count: " +
                    mappings);
        else if (mappings > 0) { // (if zero, use defaults)
            // Size the table using given load factor only if within
            // range of 0.25...4.0
            //調整hashMap大小
            float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);            // 載入因子
            float fc = (float) mappings / lf + 1.0f;         //初步得到的總容量，後續還會處理
            //處理初步得到的容量，確認最終的總容量
            int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                    DEFAULT_INITIAL_CAPACITY :
                    (fc >= MAXIMUM_CAPACITY) ?
                            MAXIMUM_CAPACITY :
                            tableSizeFor((int) fc));
            //計算臨界值，得到初步的臨界值
            float ft = (float) cap * lf;
            //得到最終的臨界值
            threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                    (int) ft : Integer.MAX_VALUE);

            // Check Map.Entry[].class since it's the nearest public type to
            // what we're actually creating.
            SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
            //新建桶陣列table
            @SuppressWarnings({"rawtypes", "unchecked"})
            Node<K, V>[] tab = (Node<K, V>[]) new Node[cap];
            table = tab;

            // 讀出key和value，並組成鍵值對插入hashMap中
            for (int i = 0; i < mappings; i++) {
                @SuppressWarnings("unchecked")
                K key = (K) s.readObject();
                @SuppressWarnings("unchecked")
                V value = (V) s.readObject();
                putVal(hash(key), key, value, false, false);
            }
        }
    }

   
 

看完原始碼分析後我們來看看HashMap中幾個常見的問題和一些優化。

四、HashMap常見問題及核心方法。

1.先來看下計算hash的函式 

     static final int hash(Object key) {
         int h;
         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
     }

這個hash演算法實現的是：獲取key的hashCode()，然後高16bit不變，低16bit和高16bit異或結果作為低16bit。

在put和get方法時計算下標採用：

(n - 1) & hash

據程式碼註釋解釋，這種計算下標方式是綜合考慮效率、作用和質量的結果。通常hash table的計算下標方式為模%，但是模%運算很容易發生碰撞，為什麼這麼說呢？不妨思考一下，在n - 1為15(0x1111)時，其實雜湊真正生效的只是低4bit的有效位，當然容易碰撞了。因此，設計者想了一個顧全大局的方法(綜合考慮了速度、作用、質量)，就是把高16bit和低16bit異或了一下。設計者還解釋到因為現在大多數的hashCode的分佈已經很不錯了，就算是發生了碰撞也用O(logn)的tree去做了。僅僅異或一下，既減少了系統的開銷，也不會造成的因為高位沒有參與下標的計算(table長度比較小時)，從而引起的碰撞。

整個過程圖示如下：

在Java 8中使用了連結串列和紅黑樹來解決hash碰撞問題。連結串列法get一個key的時間複雜度是O(1) + O(n)，紅黑樹get一個key的時間複雜度為O(1) + O(logn)。從二者時間複雜度也能看出如果只使用連結串列解決hash碰撞，當碰撞非常嚴重的時候，效率並不理想，因此設定了一個連結串列的長度閾值，當長度超過該閾值（預設為8）則將連結串列轉換為紅黑樹。

2.再來看下put方法，put方法的核心是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;
        if ((tab = table) == null || (n = tab.length) == 0)
            // table還未建立，則新建之
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            // Hash 位置無資料，則直接插入
            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))))
                // hash 位置上已經存在該key，則後續判斷是否需要修改value
                e = p;
            else if (p instanceof TreeNode)
                // 紅黑樹節點，則將待插入節點插入到紅黑樹
                // 如果插入過程中發現key已經存在於紅黑樹中，則後續判斷是否需要修改value
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // 連結串列，則插入連結串列末尾
                // 遍歷連結串列過程中如果發現key已經存在，則後續判斷是否需要修改value
                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
                            // 連結串列長度超過一定長度（預設為8）則將連結串列轉換為紅黑樹
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    // 發現key已經存在於連結串列中了
                    p = e;
                }
            }
            // table中已經存在該key了，根據onlyIfAbsent判斷是否需要修改value
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount; 
        // 判斷是否需要resize
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

上面程式碼為JDK 1.8 HashMap put方法的核心部分。當呼叫putVal方法的時候，先按照hash演算法(n - 1) & hash去table中取資料，如果取出來的是null，則新建一個newNode(hash, key, value, null)存入到下標為(n - 1) & hash的位置。

如果取出來的不是null，則說明table中以(n - 1) & hash為下標的位置上已經有資料了，這個時候有兩種情況：有可能是該key已經存在於table中了，或者發生了hash衝突。

如果確實key已經存在於table中了p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))），那麼則檢視onlyIfAbsent引數，如果為true則不修改該key的value，否則就更新value。

如果發生了hash衝突，此時有兩種解決方法，一種是紅黑樹，一種是連結串列。

如果是連結串列，也很好解決，迴圈遍歷連結串列，如果找到了某個節點的key等於待存入的key，則根據onlyIfAbsent決定是否需要更新value；找不到則新建一個節點存入到連結串列的結尾。當然這個連結串列不能無限制的擴充套件的，程式中設定連結串列最長為REEIFY_THRESHOLD - 1，也即為7。長度超過7則需要將連結串列構建為一顆紅黑樹。

如果不是連結串列，則需要在紅黑樹中處理，紅黑樹中同樣需要先檢視key是否存在，存在則根據onlyIfAbsent決定是否更新value，不存在則new一個放入到紅黑樹中。

整個putVal方法流程圖如下圖所示。

每次呼叫putVal方法，如果key不存在於table中則會增加modCount，table修改次數加1。

3.HashMap是如何rehash的

當table的size超過threshold = capacity * loadFactor時，需要對HashMap進行resize操作。capacity表示table的總容量，size表示已經存入了多少node。threshold為閾值，超過該閾值則需要進行resize操作。

resize的時候，通常情況為capacity << 1， threshold << 1，也即擴充套件為之前的兩倍（超過MAXIMUM_CAPACITY情況另當別論）。無論是連結串列還是紅黑樹，其中節點在resize過後都需要重新重新hash，但是Java8中重新Hash設計的非常巧妙。舉例說明，假設table從16擴充套件為32，具體變化為：

元素在重新計算hash之後，因為n變為2倍(capacity << 1)，那麼n-1的mask範圍在高位多1bit(紅色)，因此新的index就會發生這樣的變化：

因此，我們在擴充HashMap的時候，不需要重新計算hash，只需要看看原來的hash值新增的那個bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap”。可以看看下圖為16擴充為32的resize示意圖： 

這個設計確實非常的巧妙，既省去了重新計算hash值的時間，而且同時，由於新增的1bit是0還是1可以認為是隨機的，因此resize的過程，均勻的把之前的衝突的節點分散到新的table中。牛逼！

4.為什麼HashMap的預設容量為16並且容量應該為2的n次冪？

如果兩個元素不相同,但是hash函式的值相同,這兩個元素就是一個碰撞。因為把任意長度的字串變成固定長度的字串,所以存在一個hash對應多個字串的情況,所以碰撞必然存在。為了減少hash值的碰撞,需要實現一個儘量均勻分佈的hash函式,在HashMap中通過利用key的hashcode值,來進行位運算
公式:index = e.hash & (newCap - 1)

舉個例子:
1.計算"book"的hashcode
    十進位制 : 3029737
    二進位制 : 101110001110101110 1001

2.HashMap長度是預設的16，length - 1的結果
    十進位制 : 15
    二進位制 : 1111
3.把以上兩個結果做與運算
    101110001110101110 1001 & 1111 = 1001
    1001的十進位制 : 9,所以 index=9

hash演算法最終得到的index結果,取決於hashcode值的最後幾位

為了推斷HashMap的預設長度為什麼是16
現在,我們假設HashMap的長度是10,重複剛才的運算步驟:
hashcode : 101110001110101110 1001
length - 1 :                                     1001
index :                                            1001
再換一個hashcode 101110001110101110 1111 試試:
hashcode : 101110001110101110 1111
length - 1 :                                     1001
index :                                            1001

從結果可以看出,雖然hashcode變化了,但是運算的結果都是1001,也就是說,當HashMap長度為10的時候,有些index結果的出現機率
會更大而有些index結果永遠不會出現(比如0111),這樣就不符合hash均勻分佈的原則

反觀長度16或者其他2的冪，length - 1的值是所有二進位制位全為1。這種情況下,index的結果等同於hashcode後幾位的值只要輸入的hashcode本身分佈均勻,hash演算法的結果就是均勻的。所以,HashMap的預設長度為16並且容量必須為2的n次冪，這是為了降低hash碰撞的機率。

5.如何使用執行緒安全的HashMap

• 在外部包裝HashMap，實現同步機制
• 使用Map m = Collections.synchronizedMap(new HashMap(...));，這裡就是對HashMap做了一次包裝
• 使用java.util.HashTable，效率最低
• 使用java.util.concurrent.ConcurrentHashMap，相對安全，效率較高

6.HashMap和HashTable的區別：

• HashMap是非執行緒安全的，Hashtable是執行緒安全的，所以Hashtable重量級一些，因為使用了synchronized關鍵字來保證執行緒安全。
• HashMap允許key和value都為null，而Hashtable都不能為null。
• Hashtable繼承自 JDK 1.0 的 Dictionary 虛擬類，而HashMap是 JDK 1.2 引進的 Map 介面的一個實現。
• Hashtable和HashMap擴容的方法不一樣，Hashtable中陣列預設大小11，擴容方式是 old*2+1。HashMap中陣列的預設大小是16，而且一定是2的指數，增加為原來的2倍。
• 兩者通過hash值雜湊到ha