@Test
public void test01() {
    HashMap<String, Integer> hashMap = new HashMap();
    hashMap.put("a", 3);
    hashMap.put("b", 4);
    hashMap.put("c", 5);
    hashMap.put("a", 88888);// 修改
    System.out.println(hashMap);
}

{a=88888, b=456, c=789}

/*
 * 序列化版本號
 */
private static final long serialVersionUID = 362498820763181265L;
/**
 * HashMap的初始化容量（必須是 2 的 n 次冪）默認(rèn)的初始容量為16
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
/**
 * 最大的容量為2的30次方
 */
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
 * 默認(rèn)的裝載因子
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
 * 樹化閾值，當(dāng)一個(gè)桶中的元素個(gè)數(shù)大于等于8時(shí)進(jìn)行樹化
 */
static final int TREEIFY_THRESHOLD = 8;
/**
 * 樹降級為鏈表的閾值，當(dāng)一個(gè)桶中的元素個(gè)數(shù)小于等于6時(shí)把樹轉(zhuǎn)化為鏈表
 */
static final int UNTREEIFY_THRESHOLD = 6;
/**
 * 當(dāng)桶的個(gè)數(shù)達(dá)到64的時(shí)候才進(jìn)行樹化
 */
static final int MIN_TREEIFY_CAPACITY = 64;
/**
 * Node數(shù)組，又叫作桶（bucket）
 */
transient Node<K,V>[] table;
/**
 * 作為entrySet()的緩存
 */
transient Set<Map.Entry<K,V>> entrySet;
/**
 * 元素的數(shù)量
 */
transient int size;
/**
 * 修改次數(shù)，用于在迭代的時(shí)候執(zhí)行快速失敗策略
 */
transient int modCount;
/**
 * 當(dāng)桶的使用數(shù)量達(dá)到多少時(shí)進(jìn)行擴(kuò)容，threshold = capacity * loadFactor
 */
int threshold;
/**
 * 裝載因子
 */
final float loadFactor;

// 默認(rèn)的初始容量是16	1 << 4 相當(dāng)于 1*2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

// 構(gòu)造一個(gè)帶指定初始容量和默認(rèn)負(fù)載因子（0.75)的空 HashMap。
HashMap(int initialCapacity)

HashMap<String, Integer> hashMap = new HashMap(10);

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

static final float DEFAULT_LOAD_FACTOR = 0.75f;

static final int MAXIMUM_CAPACITY = 1 << 30; // 2的30次冪

// 當(dāng)桶（bucket）上的結(jié)點(diǎn)數(shù)大于這個(gè)值時(shí)會(huì)轉(zhuǎn)為紅黑樹
static final int TREEIFY_THRESHOLD = 8;

Because TreeNodes are about twice the size of regular nodes, we use them only when bins
contain enough nodes to warrant use (see TREEIFY_THRESHOLD). And when they become too
small (due to removal or resizing) they are converted back to plain bins.  In usages with
well-distributed user hashCodes, tree bins are rarely used.  Ideally, under random hashCodes, 
the frequency of nodes in bins follows a Poisson distribution 
(http://en.wikipedia.org/wiki/Poisson_distribution) 
with a parameter of about 0.5 on average for the default resizing
threshold of 0.75, although with a large variance because of resizing granularity. Ignoring variance, 
the expected occurrences of list size k are (exp(-0.5) * pow(0.5, k) / factorial(k)). The first values are:
翻譯：因?yàn)闃浣Y(jié)點(diǎn)的大小大約是普通結(jié)點(diǎn)的兩倍，所以我們只在箱子包含足夠的結(jié)點(diǎn)時(shí)才使用樹結(jié)點(diǎn)(參見TREEIFY_THRESHOLD)。
當(dāng)它們變得太?。ㄓ捎趧h除或調(diào)整大?。r(shí)，就會(huì)被轉(zhuǎn)換回普通的桶。在使用分布良好的用戶 hashCode 時(shí)，很少使用樹箱。
理想情況下，在隨機(jī)哈希碼下，箱子中結(jié)點(diǎn)的頻率服從泊松分布。
默認(rèn)調(diào)整閾值為0.75，平均參數(shù)約為0.5，盡管由于調(diào)整粒度的差異很大。忽略方差，列表大小k的預(yù)朗出現(xiàn)次數(shù)是(exp(-0.5)*pow(0.5, k) / factorial(k)
第一個(gè)值是：
0:    0.60653066
1:    0.30326533
2:    0.07581633
3:    0.01263606
4:    0.00157952
5:    0.00015795
6:    0.00001316
7:    0.00000094
8:    0.00000006
more: less than 1 in ten million

// 當(dāng)桶（bucket）上的結(jié)點(diǎn)數(shù)小于這個(gè)值，樹轉(zhuǎn)為鏈表 
static final int UNTREEIFY_THRESHOLD = 6;

// 桶中結(jié)構(gòu)轉(zhuǎn)化為紅黑樹對應(yīng)的數(shù)組長度最小的值 
static final int MIN_TREEIFY_CAPACITY = 64;

// 存儲(chǔ)元素的數(shù)組 
transient Node<K,V>[] table;

// 存放具體元素的集合
transient Set<Map.Entry<K,V>> entrySet;

// 存放元素的個(gè)數(shù)，注意這個(gè)不等于數(shù)組的長度
 transient int size;

// 每次擴(kuò)容和更改 map 結(jié)構(gòu)的計(jì)數(shù)器
 transient int modCount;  

// 臨界值 當(dāng)實(shí)際大?。ㄈ萘?負(fù)載因子）超過臨界值時(shí)，會(huì)進(jìn)行擴(kuò)容
int threshold;

// 負(fù)載因子
final float loadFactor;// 0.75f

// 構(gòu)造方法，構(gòu)造一個(gè)帶指定初始容量和負(fù)載因子的空HashMap
HashMap(int initialCapacity, float loadFactor);

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;// hash用來存儲(chǔ)key計(jì)算得來的hash值
    final K key;// 鍵
    V value;// 值
    Node<K,V> next;// 下一個(gè)node節(jié)點(diǎn)
    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() {// 調(diào)用底層c++ 返回Key/Value的哈希碼值，如果此對象為null,則返回0
        return Objects.hashCode(key) ^ Objects.hashCode(value);// 將Key/Vaule
    }
    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;
    }
}

// 位于HashMap中,文章接下來會(huì)逐步分析
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // red-black tree links
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;
}
// 位于LinkedHashMap中，典型的雙向鏈表節(jié)點(diǎn)，這個(gè)類之后會(huì)單獨(dú)發(fā)文章論述
static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

public HashMap() {
   // 將默認(rèn)的負(fù)載因子0.75賦值給loadFactor，并沒有創(chuàng)建數(shù)組
   this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

// 指定“容量大小”的構(gòu)造函數(shù)
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/*
	 指定“容量大小”和“負(fù)載因子”的構(gòu)造函數(shù)
	 initialCapacity：指定的容量
	 loadFactor:指定的負(fù)載因子
*/
public HashMap(int initialCapacity, float loadFactor) {
    	// 判斷初始化容量initialCapacity是否小于0
        if (initialCapacity < 0)
            // 如果小于0，則拋出非法的參數(shù)異常IllegalArgumentException
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    	// 判斷初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY
        if (initialCapacity > MAXIMUM_CAPACITY)
            // 如果超過MAXIMUM_CAPACITY，會(huì)將MAXIMUM_CAPACITY賦值給initialCapacity
            initialCapacity = MAXIMUM_CAPACITY;
    	// 判斷負(fù)載因子loadFactor是否小于等于0或者是否是一個(gè)非數(shù)值
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            // 如果滿足上述其中之一，則拋出非法的參數(shù)異常IllegalArgumentException
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
     	// 將指定的負(fù)載因子賦值給HashMap成員變量的負(fù)載因子loadFactor
        this.loadFactor = loadFactor;// 一般不建議修改默認(rèn)的負(fù)載因子
        this.threshold = tableSizeFor(initialCapacity);
    }
	// 最后調(diào)用了tableSizeFor，來看一下方法實(shí)現(xiàn)：
     /*
     	返回比指定cap容量大的最小2的n次冪數(shù)：
     	前面第一遍講述的應(yīng)該有些小伙伴難以理解，這里我在舉例解析一下：
     	-------------------------------------------------------
     	首先假定傳入的cap = 10
     	則，n = 10 -1 => 9
     	n |= n >>> 1 就等同于 n = (n | n >>> 1),所以：
     	(位運(yùn)算不懂的可以去看我的《Java基礎(chǔ)提高之位運(yùn)算》這篇文章)
     	9 => 0b1001    9 >>> 1 => 0b0100 
     	n |= n >>> 1;  ===>  0b1001 | 0b0100 => 0b1101
     	n |= n >>> 2;  ===>  0b1101 | 0b0011 => 0b1111
        n |= n >>> 4;  ===>  0b1111 | 0b0000 => 0b1111
        n |= n >>> 8;  ===>  0b1111 | 0b0000 => 0b1111
        n |= n >>> 16; ===>  0b1111 | 0b0000 => 0b1111
        得到：
        0b1111 => 15
        返回：
        return 15 + 1 => 16
        -------------------------------------------------------
        如果cap 不減去1，即直接使n等于cap的話，int n = cap;
        我們繼續(xù)用上邊返回的cap => 16 傳入tableSizeFor(int cap)：
        cap = 16
        n = 16
        16 => 0b10000  16 >>> 1 => 0b01000
        n |= n >>> 1;  ===>  0b10000 | 0b01000 => 0b11000
        n |= n >>> 2;  ===>  0b11000 | 0b00110 => 0b11110
        n |= n >>> 4;  ===>  0b11110 | 0b00001 => 0b11111
        n |= n >>> 8;  ===>  0b11111 | 0b00000 => 0b11111
        n |= n >>> 16; ===>  0b11111 | 0b00000 => 0b11111
        得到：
        0b11111 => 31
        返回 return 31 +1 => 32
        而實(shí)際情況是應(yīng)該傳入cap = 16 , n = cap -1 = 15
        15 => 0b1111 
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        經(jīng)過上面運(yùn)算后得到：還是15
        返回結(jié)果：
        return 15 + 1 = 16
        所以我們得出結(jié)果：
        防止 cap 已經(jīng)是 2 的冪數(shù)情況下。沒有這個(gè)減 1 操作，
        則執(zhí)行完幾條無符號位移或位運(yùn)算操作之后，返回的cap(32)將是實(shí)際所需cap(16)的 2倍。
     */
    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;
    }

this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;

// 構(gòu)造一個(gè)映射關(guān)系與指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) {
    	// 負(fù)載因子loadFactor變?yōu)槟J(rèn)的負(fù)載因子0.75
         this.loadFactor = DEFAULT_LOAD_FACTOR;
         putMapEntries(m, false);
 }

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    //獲取參數(shù)集合的長度
    int s = m.size();
    if (s > 0) {//判斷參數(shù)集合的長度是否大于0
        if (table == null) { // 判斷table是否已經(jīng)初始化
                // 未初始化，s為m的實(shí)際元素個(gè)數(shù)
                float ft = ((float)s / loadFactor) + 1.0F;// 得到新的擴(kuò)容閾值
                int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);// 新的擴(kuò)容閾值float自動(dòng)向下轉(zhuǎn)型為int
                // 計(jì)算得到的t大于閾值，則初始化閾值，將其變?yōu)榉弦蟮?的n次冪數(shù)
                if (t > threshold)
                    threshold = tableSizeFor(t);
        }
        // 如果table已初始化過了，并且m元素個(gè)數(shù)大于閾值，進(jìn)行擴(kuò)容處理
        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();
            // 得到的key 和 value 放入 hashmap
            putVal(hash(key), key, value, false, evict);
        }
    }
}

public V put(K key, V value) {
    // 調(diào)用hash(key)計(jì)算出key的hash值
    return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
    int h;
    // 如果key為null，則hash值為0,
    // 否則調(diào)用key的hashCode()方法計(jì)算出key的哈希值然后賦值給h,
    // 后與h無符號右移16位后的二進(jìn)制進(jìn)行按位異或得到最后的hash值,
    // 這樣做是為了使計(jì)算出的hash更分散
    // 為什么要更分散呢？因?yàn)樵椒稚?，某個(gè)桶的鏈表長度就越短，之后生成的紅黑樹越少，效率越高
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
	...
	if ((p = tab[i = (n - 1) & hash]) == null) // 這里的n表示數(shù)組長度16 ，公式
    // (length - 1) & hash = 桶位下標(biāo) 當(dāng)數(shù)組長度為2的n次冪數(shù)時(shí)，
    // 該公式相當(dāng)于：hash % length 哈希值對數(shù)組長度取余
    // 例如：hash % 32 = hash & (32-1)
	...
}

public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
    int h;// 如果key是null 則hash值為0,否則調(diào)用key的hashCode()方法,并讓高16位參與整個(gè)hash異或，如果數(shù)組長度比較小的情況下，讓高16位也參與尋址，
    // 尋址公式：(length - 1) & hash 
    // 這樣可以使計(jì)算出的結(jié)果更分散，不容易產(chǎn)生哈希沖突
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    /*
    	1）transient Node<K,V>[] table; 表示存儲(chǔ)Map集合中元素的數(shù)組。
    	2）(tab = table) == null 表示將空的table賦值給tab，然后判斷tab是否等于null，第一次肯定是null。
    	3）(n = tab.length) == 0 表示將數(shù)組的長度0賦值給n，然后判斷n是否等于0，n等于0，由于if判斷使用雙或，滿足一個(gè)即可，則執(zhí)行代碼 n = (tab = resize()).length; 進(jìn)行數(shù)組初始化，并將初始化好的數(shù)組長度賦值給n。
    	4）執(zhí)行完n = (tab = resize()).length，數(shù)組tab每個(gè)空間都是null。
    */
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    /*
    	1）i = (n - 1) & hash 表示計(jì)算數(shù)組的索引賦值給i，即確定元素存放在哪個(gè)桶中。
    	2）p = tab[i = (n - 1) & hash]表示獲取計(jì)算出的位置的數(shù)據(jù)賦值給結(jié)點(diǎn)p。
    	3) (p = tab[i = (n - 1) & hash]) == null 判斷結(jié)點(diǎn)位置是否等于null，如果為null，則執(zhí)行代碼：tab[i] = newNode(hash, key, value, null);根據(jù)鍵值對創(chuàng)建新的結(jié)點(diǎn)放入該位置的桶中。
        小結(jié)：如果當(dāng)前桶沒有哈希碰撞沖突，則直接把鍵值對插入空間位置。
    */ 
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 創(chuàng)建一個(gè)新的結(jié)點(diǎn)存入到桶中
        tab[i] = newNode(hash, key, value, null);
    else {
         // 執(zhí)行else說明tab[i]不等于null，表示這個(gè)位置已經(jīng)有值了
        Node<K,V> e; K k;
        /*
        	比較桶中第一個(gè)元素(數(shù)組中的結(jié)點(diǎn))的hash值和key是否相等
        	1）p.hash == hash ：p.hash表示原來存在數(shù)據(jù)的hash值  hash表示后添加數(shù)據(jù)的hash值 比較兩個(gè)hash值是否相等。
                 說明：p表示tab[i]，即 newNode(hash, key, value, null)方法返回的Node對象。
                    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
                        return new Node<>(hash, key, value, next);
                    }
                    而在Node類中具有成員變量hash用來記錄著之前數(shù)據(jù)的hash值的。
             2）(k = p.key) == key ：p.key獲取原來數(shù)據(jù)的key賦值給k  key 表示后添加數(shù)據(jù)的key比較兩個(gè)key的地址值是否相等。
             3）key != null && key.equals(k)：能夠執(zhí)行到這里說明兩個(gè)key的地址值不相等，那么先判斷后添加的key是否等于null，如果不等于null再調(diào)用equals方法判斷兩個(gè)key的內(nèi)容是否相等。
        */
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                /*
                	說明：兩個(gè)元素哈希值相等，并且key的值也相等，
                	將舊的元素整體對象賦值給e，用e來記錄
                */ 
                e = p;
        // hash值不相等或者key不相等；判斷p是否為紅黑樹結(jié)點(diǎn)
        else if (p instanceof TreeNode)
            // 放入樹中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 說明是鏈表結(jié)點(diǎn)
        else {
            /*
            	1)如果是鏈表的話需要遍歷到最后結(jié)點(diǎn)然后插入
            	2)采用循環(huán)遍歷的方式，判斷鏈表中是否有重復(fù)的key
            */
            for (int binCount = 0; ; ++binCount) {
                /*
                	1)e = p.next 獲取p的下一個(gè)元素賦值給e。
                	2)(e = p.next) == null 判斷p.next是否等于null，等于null，說明p沒有下一個(gè)元素，那么此時(shí)到達(dá)了鏈表的尾部，還沒有找到重復(fù)的key,則說明HashMap沒有包含該鍵，將該鍵值對插入鏈表中。
                */
                if ((e = p.next) == null) {
                    /*
                    	1）創(chuàng)建一個(gè)新的結(jié)點(diǎn)插入到尾部
                    	 p.next = newNode(hash, key, value, null);
                    	 Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
                                return new Node<>(hash, key, value, next);
                         }
                         注意第四個(gè)參數(shù)next是null，因?yàn)楫?dāng)前元素插入到鏈表末尾了，那么下一個(gè)結(jié)點(diǎn)肯定是null。
                         2）這種添加方式也滿足鏈表數(shù)據(jù)結(jié)構(gòu)的特點(diǎn)，每次向后添加新的元素。
                    */
                    p.next = newNode(hash, key, value, null);
                    /*
                    	1)結(jié)點(diǎn)添加完成之后判斷此時(shí)結(jié)點(diǎn)個(gè)數(shù)是否大于TREEIFY_THRESHOLD臨界值8，如果大于則將鏈表轉(zhuǎn)換為紅黑樹。
                    	2）int binCount = 0 ：表示for循環(huán)的初始化值。從0開始計(jì)數(shù)。記錄著遍歷結(jié)點(diǎn)的個(gè)數(shù)。值是0表示第一個(gè)結(jié)點(diǎn)，1表示第二個(gè)結(jié)點(diǎn)。。。。7表示第八個(gè)結(jié)點(diǎn)，加上數(shù)組中的的一個(gè)元素，元素個(gè)數(shù)是9。
                    	TREEIFY_THRESHOLD - 1 --》8 - 1 ---》7
                    	如果binCount的值是7(加上數(shù)組中的的一個(gè)元素，元素個(gè)數(shù)是9)
                    	TREEIFY_THRESHOLD - 1也是7，此時(shí)轉(zhuǎn)換紅黑樹。
                    */
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        // 轉(zhuǎn)換為紅黑樹
                        treeifyBin(tab, hash);
                    // 跳出循環(huán)
                    break;
                }
                /*
                	執(zhí)行到這里說明e = p.next 不是null，不是最后一個(gè)元素。繼續(xù)判斷鏈表中結(jié)點(diǎn)的key值與插入的元素的key值是否相等。
                */
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循環(huán)
                    /*
                		要添加的元素和鏈表中的存在的元素的key相等了，則跳出for循環(huán)。不用再繼續(xù)比較了
                		直接執(zhí)行下面的if語句去替換去 if (e != null) 
                	*/
                    break;
                /*
                	說明新添加的元素和當(dāng)前結(jié)點(diǎn)不相等，繼續(xù)查找下一個(gè)結(jié)點(diǎn)。
                	用于遍歷桶中的鏈表，與前面的e = p.next組合，可以遍歷鏈表
                */
                p = e;
            }
        }
        /*
        	表示在桶中找到key值、hash值與插入元素相等的結(jié)點(diǎn)
        	也就是說通過上面的操作找到了重復(fù)的鍵，所以這里就是把該鍵的值變?yōu)樾碌闹担⒎祷嘏f值
        	這里完成了put方法的修改功能
        */
        if (e != null) { 
            // 記錄e的value
            V oldValue = e.value;
            // onlyIfAbsent為false或者舊值為null
            if (!onlyIfAbsent || oldValue == null)
                // 用新值替換舊值
                // e.value 表示舊值  value表示新值 
                e.value = value;
            // 訪問后回調(diào)
            afterNodeAccess(e);
            // 返回舊值
            return oldValue;
        }
    }
    // 修改記錄次數(shù)
    ++modCount;
    // 判斷實(shí)際大小是否大于threshold閾值，如果超過則擴(kuò)容
    if (++size > threshold)
        resize();
    // 插入后回調(diào)
    afterNodeInsertion(evict);
    return null;
}

/**
 * 為什么需要擴(kuò)容呢？
 * 為了解決哈希沖突導(dǎo)致的鏈化影響查詢效率問題，擴(kuò)容會(huì)緩解該問題
 */
final Node<K,V>[] resize() {
    // oldTab：表示擴(kuò)容前的哈希表數(shù)組
    Node<K,V>[] oldTab = table;
    // oldCap：表示擴(kuò)容之前table數(shù)組長度
    // 如果當(dāng)前哈希表數(shù)組等于null 長度返回0，否則返回當(dāng)前哈希表數(shù)組的長度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // oldThr：表示擴(kuò)容之前的閥值(觸發(fā)本次擴(kuò)容的閾值) 默認(rèn)是12(16*0.75)
    int oldThr = threshold;
    // newCap：擴(kuò)容之后的table散列表數(shù)組長度
    // newThr: 擴(kuò)容之后，下次再出發(fā)擴(kuò)容的條件(新的擴(kuò)容閾值)
    int newCap, newThr = 0;
    // 如果老的哈希表數(shù)組長度oldCap > 0
    // 如果該條件成立，說明hashMap 中的散列表數(shù)組已經(jīng)初始化過了，是一次正常擴(kuò)容
    // 開始計(jì)算擴(kuò)容后的大小
    if (oldCap > 0) {
        // 擴(kuò)容之前的table數(shù)組大小已經(jīng)達(dá)到 最大閾值后，則不再擴(kuò)容
        // 且設(shè)置擴(kuò)容條件為：int的最大值
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 修改閾值為int的最大值
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 擴(kuò)容之前的table數(shù)組大小沒超過最大值，則擴(kuò)充為原來的2倍
        // (newCap = oldCap << 1) < MAXIMUM_CAPACITY 擴(kuò)大到2倍之后容量要小于最大容量
        // oldCap >= DEFAULT_INITIAL_CAPACITY 原哈希表數(shù)組長度大于等于數(shù)組初始化長度16
        // 如果oldCap 小于默認(rèn)初始容量16，比如傳入的默認(rèn)容量為8，則不執(zhí)行下面代碼
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 新的擴(kuò)容閾值擴(kuò)大一倍
            newThr = oldThr << 1; // double threshold
    }
    // 如果老的哈希表數(shù)組長度oldCap == 0
    // 說明hashMap中的散列表還沒有初始化，這時(shí)候是null
    // 如果老閾值oldThr大于0 直接賦值
    /*
    	以下三種情況會(huì)直接進(jìn)入該判斷：(即，這時(shí)候oldThr擴(kuò)容閾值已存在)
    	1.new HashMap(initCap,loadFactor);
    	2.new HashMap(initCap);
    	3.new HashMap(Map);// 這個(gè)傳入的map中已經(jīng)有數(shù)據(jù)
    */
    else if (oldThr > 0) // 老閾值賦值給新的數(shù)組長度
        newCap = oldThr;
    // 如果老的哈希表數(shù)組長度oldCap == 0
    // 說明hashMap中的散列表還沒有初始化，這時(shí)候是null
    // 此時(shí)，老擴(kuò)容閾值oldThr == 0
    else { // 直接使用默認(rèn)值
        newCap = DEFAULT_INITIAL_CAPACITY;//16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12
    }
    // 如果執(zhí)行到這個(gè)位置新的擴(kuò)容閾值newThr還沒有得到賦值，則
    // 需要計(jì)算新的resize最大上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 將新的閥值newThr賦值給threshold
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    // 創(chuàng)建新的散列表
    // newCap是新的數(shù)組長度---> 32
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // 說明：hashMap本次擴(kuò)容之前，table不為null
    if (oldTab != null) {
        // 把每個(gè)bucket桶的數(shù)據(jù)都移動(dòng)到新的散列表中
        // 遍歷舊的哈希表的每個(gè)桶，重新計(jì)算桶里元素的新位置
        for (int j = 0; j < oldCap; ++j) {
            // 當(dāng)前node節(jié)點(diǎn)
            Node<K,V> e;
            // 說明：此時(shí)的當(dāng)前桶位中有數(shù)據(jù)，但是數(shù)據(jù)具體是 
            // 1.單個(gè)數(shù)據(jù) 、 2.還是鏈表 、 3.還是紅黑樹 并不能確定
            if ((e = oldTab[j]) != null) {
                // 原來的數(shù)據(jù)賦值為null 便于GC回收
                oldTab[j] = null;
                // 第一種情況：判斷數(shù)組是否有下一個(gè)引用(是否是單個(gè)數(shù)據(jù))
                if (e.next == null)
                    // 沒有下一個(gè)引用，說明不是鏈表，
                    // 當(dāng)前桶上只有單個(gè)數(shù)據(jù)的鍵值對，
                    // 可以將數(shù)據(jù)直接放入新的散列表中
                    // e.hash & (newCap - 1) 尋址公式得到的索引結(jié)果有兩種：
                    // 1.和原來舊散列表中的索引位置相同，
                    // 2.原來舊散列表中的索引位置i + 舊容量oldCap
                    newTab[e.hash & (newCap - 1)] = e;
                //第二種情況：桶位已經(jīng)形成紅黑樹
                else if (e instanceof TreeNode)
                    // 說明是紅黑樹來處理沖突的，則調(diào)用相關(guān)方法把樹分開
                    // 紅黑樹這塊，我會(huì)單獨(dú)寫一篇博客給大家詳細(xì)分析一下
                    // 紅黑樹相關(guān)可以先跳過
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                // 第三種情況：桶位已經(jīng)形成鏈表
                else { // 采用鏈表處理沖突
                    // 低位鏈表：
                    // 擴(kuò)容之后數(shù)組的下標(biāo)位置，與當(dāng)前數(shù)組的下標(biāo)位置一致 時(shí)使用
                    Node<K,V> loHead = null, loTail = null;
                    // 高位鏈表：擴(kuò)容之后數(shù)組的下標(biāo)位置等于
                    // 當(dāng)前數(shù)組下標(biāo)位置 + 擴(kuò)容之前數(shù)組的長度oldCap 時(shí)使用
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 通過上述講解的原理來計(jì)算結(jié)點(diǎn)的新位置
                    do {
                        // 原索引
                        next = e.next;
                     	// 這里來判斷如果等于true 
                        // e這個(gè)結(jié)點(diǎn)在resize之后不需要移動(dòng)位置
                        // 舉例：
                        // 假如hash1     -> ...... 0 1111
                        // 假如oldCap=16 -> ...... 1 0000
                        // e.hash & oldCap 結(jié)果為0，則
                        // 擴(kuò)容之后數(shù)組的下標(biāo)位置j，與當(dāng)前數(shù)組的下標(biāo)位置一致
                        // 使用低位鏈表
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 舉例：
                        // 假如hash2     -> ...... 1 1111
                        // 假如oldCap=16 -> ...... 1 0000
                        // e.hash & oldCap 結(jié)果不為0，則
                        // 擴(kuò)容之后數(shù)組的下標(biāo)位置為：
                        // 當(dāng)前數(shù)組下標(biāo)位置j + 擴(kuò)容之前數(shù)組的長度oldCap
                        // 使用高位鏈表
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 將低位鏈表放到bucket桶里
                    if (loTail != null) {
                        loTail.next = null;
                        // 索引位置=當(dāng)前數(shù)組下標(biāo)位置j
                        newTab[j] = loHead;
                    }
                    // 將高位鏈表放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        // 索引位置=當(dāng)前數(shù)組下標(biāo)位置j + 擴(kuò)容之前數(shù)組的長度oldCap
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    // 返回新散列表
    return newTab;
}

// remove方法的具體實(shí)現(xiàn)在removeNode方法中，所以我們重點(diǎn)看下removeNode方法
// 根據(jù)key刪除
public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
// 根據(jù)key,value 刪除
@Override
public boolean remove(Object key, Object value) {
    return removeNode(hash(key), key, value, true, true) != null;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    // 參數(shù)：
    // matchValue 當(dāng)根據(jù) key和value 刪除的時(shí)候該參數(shù)為true
    // movable 可以先不用考慮這個(gè)參數(shù) 
    // tab：引用當(dāng)前haashMap中的散列表
    // p：當(dāng)前node元素
    // n：當(dāng)前散列表數(shù)組長度
    // index：表示尋址結(jié)果
    Node<K,V>[] tab; Node<K,V> p; int n, index;
	// 根據(jù)hash找到位置 
	// 如果當(dāng)前key映射到的桶不為空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        // 進(jìn)入這個(gè)if判斷內(nèi)部，說明桶位是有數(shù)據(jù)的，需要進(jìn)行查詢操作，并且執(zhí)行刪除
        // node：通過查找得到的要?jiǎng)h除的元素
        // e：表示當(dāng)前node的下一個(gè)元素
        // k,v 鍵 值
        Node<K,V> node = null, e; K k; V v;
        // 第一種情況：當(dāng)前桶位中的元素 即為我們要?jiǎng)h除的元素
        // 如果桶上的結(jié)點(diǎn)就是要找的key，則將node指向該結(jié)點(diǎn)
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        // 如果桶位中的頭一個(gè)元素不是我們要找的元素，且桶位中的e = p.next不為null
        // 說明該桶位中的節(jié)點(diǎn)存在下一個(gè)節(jié)點(diǎn)
        else if ((e = p.next) != null) {
            // 說明：當(dāng)前桶位，要么是 鏈表，要么是 紅黑樹
            // 第二種情況：判斷桶位中是否已經(jīng)形成了紅黑樹
            if (p instanceof TreeNode)
                // 說明是以紅黑樹來處理的沖突，則獲取紅黑樹要?jiǎng)h除的結(jié)點(diǎn)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            // 第三種情況：桶位中已經(jīng)形成鏈表
            else {
                // 判斷是否以鏈表方式處理hash沖突
                // 是的話則通過遍歷鏈表來尋找要?jiǎng)h除的結(jié)點(diǎn)
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 比較找到的key的value和要?jiǎng)h除的是否匹配
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            // 第一種情況：如果桶位中是紅黑樹，通過調(diào)用紅黑樹的方法來刪除結(jié)點(diǎn)
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            // 第二種情況：如果桶位中是鏈表
            else if (node == p)
                // 鏈表刪除
                tab[index] = node.next;
            // 如果桶位中
            else
                // 第三種情況：將當(dāng)前元素p的下一個(gè)元素設(shè)置為 要?jiǎng)h除元素的 下一個(gè)元素
                p.next = node.next;
            // 記錄修改次數(shù)
            ++modCount;
            // 變動(dòng)的數(shù)量
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

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

final Node<K,V> getNode(int hash, Object key) {
    // tab：引用當(dāng)前hashMap的散列表
    // first：桶位中的頭元素
    // e：臨時(shí)node元素
    // n：table數(shù)組的長度
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 如果哈希表不為空，并且key對應(yīng)的桶不為空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        /* 
        	判斷數(shù)組元素是否相等
        	根據(jù)索引的位置檢查第一個(gè)元素
        	注意：總是檢查第一個(gè)元素
        */
        // 第一種情況：定位出來的桶位元素 就是我們要get的數(shù)據(jù)
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶位第一個(gè)元素不是我們要找的目標(biāo)元素，且first.next不為null
        // 說明當(dāng)前桶位不止一個(gè)元素，可能是鏈表，也可能是紅黑樹
        if ((e = first.next) != null) {
            // 第二種情況：桶位已經(jīng)升級成了紅黑樹
            // 判斷是否是紅黑樹，是的話調(diào)用紅黑樹中的getTreeNode方法獲取結(jié)點(diǎn)
            if (first instanceof TreeNode)
                // 調(diào)用與樹相關(guān)的方法得到目標(biāo)元素
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 第三種情況：桶位已經(jīng)形成鏈表
            do {
                // 不是紅黑樹的話，那就是鏈表結(jié)構(gòu)了
                // 通過循環(huán)的方法判斷鏈表中是否存在該key
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    // 如果沒找到返回null
    return null;
}

for (String key : map.keySet()) {
	System.out.println(key);
}
for (Object vlaue : map.values() {
	System.out.println(value);
}

Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Object> mapEntry = iterator.next();
    System.out.println(mapEntry.getKey() + "---" + mapEntry.getValue());
}

Set<String> keySet = map.keySet();
for (String str : keySet) {
	System.out.println(str + "---" + map.get(str));
}

default void forEach(BiConsumer<? super K,? super V> action) 
// BiConsumer接口中的方法：
	void accept(T t, U u) 對給定的參數(shù)執(zhí)行此操作。  
		參數(shù) 
            t - 第一個(gè)輸入?yún)?shù) 
            u - 第二個(gè)輸入?yún)?shù) 

HashMap<String,String> map = new HashMap();
map.put("001", "zhangsan");
map.put("002", "lisi");
map.forEach((key, value) -> {
    System.out.println(key + "---" + value);
});