HashMap底層原理及JDK8後的演算法改進
前言：
jdk 1.8之前，hasmap內部是由陣列+連結串列來實現的;
而jdk 1.8之後，對hashmap做了優化，對於連結串列長度超過8的連結串列將轉儲為紅黑樹，即採用陣列+連結串列+紅黑樹。
jdk1.8對於HashMap碰撞處理的優化-引入紅黑樹。 在2014年，jdk1.8釋出。Java8的HashMap對之前做了較大的優化，其中最重要的一個優化就是桶中的元素不再唯一按照連結串列組合，也可以使用紅黑樹進行儲存，總之，目標只有一個，那就是在安全和功能性完備的情況下讓其速度更快，提升效能。當連結串列長度太長（預設超過8）時，連結串列就轉換為紅黑樹； 針對超長鏈的檢查，時間複雜度從O(n)降到了O(log2n)
【*************** jdk 8之前***************】
HashMap中的資料結構
資料結構中有陣列和連結串列來實現對資料的儲存，但這兩者基本上是兩個極端。
- 陣列：陣列儲存區間是連續的，佔用記憶體嚴重，故空間複雜的很大但陣列的二分查詢時間複雜度小，為O（1）;陣列的特點是：定址容易，插入和刪除困難;
- 連結串列：連結串列儲存區間離散，佔用記憶體比較寬鬆，故空間複雜度很小，但時間複雜度很大，達O（N）連結串列的特點是：定址困難，插入和刪除容易。
雜湊表
那麼我們能不能綜合兩者的特性，一種做出定址容易，刪除插入容易也。的資料結構？
答案是肯定的，這就是我們要提起的雜湊表。
雜湊表（（雜湊表）既滿足了資料的查詢方便，同時不佔用太多的內容空間，使用也十分方便。
雜湊表有多種不同的實現方法，我接下來解釋的是最常用的一種方法 - 拉鍊法，我們可以理解為“ 連結串列的陣列 ”，如圖：
上從圖產品我們可以發現雜湊表的英文由【陣列+連結串列】組成的，一個長度為16的陣列中，每個元素儲存的是一個連結串列的頭結點。
那麼這些元素是按照什麼樣的規則儲存到陣列中呢？
一般情況是通過【雜湊（鍵）％LEN】獲得，就是也。元素的金鑰雜湊的值對陣列長度取模得到。
比如上述雜湊表中，12％= 16％12,28 16 = 12108％16 = 12140％16 = 12。所以12,28,108以及140都儲存在陣列下標為12的位置。
HashMap中也可以理解為其儲存資料的容器就是一個【線性陣列】。
這可能讓我們很不解，一個線性的陣列怎麼實現按鍵值對來存取資料呢？
這裡HashMap中有做一些處理。首先HashMap的實現裡面一個靜態內部類條目，其重要的屬性有鍵，值，下一個。從屬性鍵，值我們就能很明顯的看出來入口就是HashMap的鍵值對實現的一個基礎豆，我們上面說到的HashMap的基礎就是一個線性陣列，這個陣列就是入口[]，地圖裡面的內容都儲存在入口[]裡面。
/ **表格，根據需要調整大小。長度必須始終是2的冪。* /
transient Entry []表;
存資料的邏輯
？既然是線性陣列，為什麼能隨機存取這裡的HashMap用了一個小演算法，大致是這樣實現：
//儲存時：
int hash = key.hashCode（）; //每個key的hash是一個固定的int值
int index = hash％Entry [] .length; //去模運算，運算後的值肯定在0-length之間
輸入[index] =值; //以去模後的值為索引，把值存進去
疑問：如果兩個金鑰通過雜湊％條目[]長度得到的指數相同，會不會有覆蓋的危險？
這裡HashMap中用到裡面鏈式資料結構的一個概念。
上面我們提到過入門類裡面有一個下一個屬性，作用是指向下一個條目。
打個比方，第一個鍵值對A進來，通過計算其鍵的雜湊得到的索引= 0，記做：條目[0] = A.
一會後又進來一個鍵值對B，通過計算其指數也等於0，現在怎麼辦？
HashMap會這樣做:B.next = A,Entry[0] = B。
如果又進來C,index也等於0,那麼C.next = B,Entry[0] = C；
這樣我們發現index=0的地方其實存取了A,B,C三個鍵值對,他們通過next這個屬性連結在一起。
public V put(K key, V value) {
if (key == null) return putForNullKey(value); //null總是放在陣列的第一個連結串列中
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
//遍歷連結串列
for (Entry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
//如果key在連結串列中已存在，則替換為新value（不要誤解為是用新的值把舊的值覆蓋了！）
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K, V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K, V>(hash, key, value, e); //引數e, 是Entry.next
//如果size超過threshold，則擴充table大小。再雜湊
if (size++ >= threshold) resize(2 * table.length);
}
當然HashMap裡面也包含一些優化方面的實現，比如：Entry[]的長度一定後，隨著map裡面資料的越來越長，這樣同一個index的鏈就會很長，會不會影響效能？
HashMap裡面設定一個因子，隨著map的size越來越大，Entry[]會以一定的規則加長長度。
取資料的邏輯
//取值時:
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];
public V get(Object key) {
if (key == null) return getForNullKey();
int hash = hash(key.hashCode());
//先定位到陣列元素，再遍歷該元素處的連結串列
for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) return e.value;
}
return null;
}
其他邏輯
null key的存取
null key總是存放在Entry[]陣列的第一個元素。
private V putForNullKey(V value) {
for (Entry<K, V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
private V getForNullKey() {
for (Entry<K, V> e = table[0]; e != null; e = e.next) {
if (e.key == null) return e.value;
}
return null;
}
確定陣列index：hashcode % table.length取模
HashMap存取時，都需要計算當前key應該對應Entry[]陣列哪個元素，即計算陣列下標；演算法如下：
/** Returns index for hash code h. */
static int indexFor(int h, int length) {
return h & (length - 1);
}
按位取並，作用上相當於取模mod或者取餘%。
注意：不過的hashCode進行運算後的值可能相等，這意味著陣列下標相同；但是，不要錯誤的理解為陣列下標相同表示hashCode相同。
初始大小
public HashMap(int initialCapacity, float loadFactor) {
.....
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}
注意初始大小並不是建構函式中的initialCapacity！而是 >= initialCapacity的2的n次冪！！！！！
簡單來說，HashMap由陣列+連結串列組成的，陣列是HashMap的主體，連結串列則是主要為了解決雜湊衝突而存在的，如果定位到的陣列位置不含連結串列（當前entry的next指向null）,那麼對於查詢，新增等操作很快，僅需一次定址即可；如果定位到的陣列包含連結串列，對於新增操作，其時間複雜度為O(n)，首先遍歷連結串列，存在即覆蓋，否則新增；對於查詢操作來講，仍需遍歷連結串列，然後通過key物件的equals方法逐一比對查詢。所以，效能考慮，HashMap中的連結串列出現越少，效能才會越好。
【***************jdk 8 之後***************】
HashMap 作為一種容器型別，無論你是否瞭解過其內部的實現原理，它的大名已經頻頻出現在各種網際網路面試中了。從基本的使用角度來說，它很簡單，但從其內部的實現來看（尤其是 Java 8 的改進以來），它又並非想象中那麼容易。如果你一定要問了解其內部實現與否對於寫程式究竟有多大影響，我不能給出一個確切的答案。但是作為一名合格程式設計師，對於這種遍地都在談論的技術不應該不為所動。本篇文章主要從 jdk 1.8 的版本初步探尋 HashMap 的基本實現情況，主要涉及內容如下：
- HashMap 的基本組成成員
- put 方法的具體實現
- remove 方法的具體實現
- 其他一些基本方法的基本介紹
一、HashMap 的基本組成成員
首先，HashMap 是 Map 的一個實現類，它代表的是一種鍵值對的資料儲存形式。Key 不允許重複出現，Value 隨意。jdk 8 之前，其內部是由陣列+連結串列來實現的，而 jdk 8 對於連結串列長度超過 8 的連結串列將轉儲為紅黑樹。大致的資料儲存形式如下：
下面分別對其中的基本成員屬性進行說明：
//預設的容量，即預設的陣列長度 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大的容量，即陣列可定義的最大長度
static final int MAXIMUM_CAPACITY = 1 << 30;這就是上述提到的陣列，陣列的元素都是 Node 型別，陣列中的每個 Node 元素都是一個連結串列的頭結點，通過它可以訪問連線在其後面的所有結點。其實你也應該發現，上述的容量指的就是這個陣列的長度。
transient Node<K,V>[] table;
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}//實際儲存的鍵值對個數
transient int size;
//用於迭代防止結構性破壞的標量
transient int modCount;下面這三個屬性是相關的，threshold 代表的是一個閾值，通常小於陣列的實際長度。伴隨著元素不斷的被新增進陣列，一旦陣列中的元素數量達到這個閾值，那麼表明陣列應該被擴容而不應該繼續任由元素加入。而這個閾值的具體值則由負載因子（loadFactor）和陣列容量來決定，公式：threshold = capacity * loadFactor。
int threshold;
final float loadFactor;
//HashMap 中預設負載因子為 0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;好了，有關 HashMap 的基本屬性大致介紹如上。下面我們看看它的幾個過載的建構函式。
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);
}這是一個最基本的建構函式，需要呼叫方傳入兩個引數，initialCapacity 和 loadFactor。程式的大部分程式碼在判斷傳入引數的合法性，initialCapacity 小於零將丟擲異常，大於 MAXIMUM_CAPACITY 將被限定為 MAXIMUM_CAPACITY。loadFactor 如果小於等於零或者非數字型別也會丟擲異常。
整個建構函式的核心在對 threshold 的初始化操作：
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;
}這是一個小巧但精妙的方法，這裡通過異或的位運算將兩個位元組的 n 打造成比 cap 大但最接近 2 的 n 次冪的一個數值。例如：
這裡我們表示 n 的時候使用了 7 個 x，所以無論 x 為 0 或者 1，n 的值都是大於 2 的 7 次冪的。我們從最終結果可以看到，最後的 n 被打造為 8 個 1，也就是 2 的 8 次冪減一。
所以從巨集觀上看，傳入的容量無論是處於任何範圍，最終都會被打造成比該值大並且比最近的一個 2 的 n 次冪小一的值。為什麼這麼做？因為 2 的 n 次冪小一的值在二進位制角度看全為 1，將有利於 HashMap 中的元素搜尋，這一點我們後續將介紹。
那麼通過該方法，我們將獲得一個 2 的整數次冪的容量的值，此處存放至 threshold，實際上我們獲取的是一個有關陣列容量的值，不應該存放至閾值 threshold 中，但在後續實際初始化陣列的時候並不會受到影響，這裡可能是寫 jdk 的大神偷了一次懶吧。
那麼我們對於這個最基本的建構函式的介紹就已經結束了，當然，HashMap 中還有很多的過載建構函式，但幾乎都是基於上述的建構函式的。例如：
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}最後需要說明一點的是，以上的一些建構函式都沒有直接的建立一個切實存在的陣列，他們都是在為建立陣列需要的一些引數做初始化，所以有些在建構函式中並沒有被初始化的屬性都會在實際初始化陣列的時候用預設值替換。
二、put 方法的具體實現
put 方法的原始碼分析是本篇的一個重點，因為通過該方法我們可以窺探到 HashMap 在內部是如何進行資料儲存的，所謂的陣列+連結串列+紅黑樹的儲存結構是如何形成的，又是在何種情況下將連結串列轉換成紅黑樹來優化效能的。帶著一系列的疑問，我們看這個 put 方法：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
新增一個元素只需要傳入一個鍵和一個值即可，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;
//如果 table 還未被初始化，那麼初始化它
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根據鍵的 hash 值找到該鍵對應到陣列中儲存的索引
//如果為 null，那麼說明此索引位置並沒有被佔用
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//不為 null，說明此處已經被佔用，只需要將構建一個節點插入到這個連結串列的尾部即可
else {
Node<K,V> e; K k;
//當前結點和將要插入的結點的 hash 和 key 相同，說明這是一次修改操作
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果 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);
//如果插入後連結串列長度大於等於 8 ，將連結串列裂變成紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//遍歷的過程中，如果發現與某個結點的 hash和key，這依然是一次修改操作
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e 不是 null，說明當前的 put 操作是一次修改操作並且e指向的就是需要被修改的結點
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果新增後，陣列容量達到閾值，進行擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}從整體上來看，該方法的大致處理邏輯已如上述註釋說明，下面我們針對其中的細節進行詳細的解釋。
首先，我們看 resize 這個方法是如何對 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;
}
//未達到極限，將陣列容量擴大兩倍，閾值也擴大兩倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1;
}
//陣列未初始化，但閾值不為 0，為什麼不為 0 ？
//上述提到 jdk 大神偷懶的事情就指的這，建構函式根據傳入的容量打造了一個合適的陣列容量暫存在閾值中
//這裡直接使用
else if (oldThr > 0)
newCap = oldThr;
//陣列未初始化並且閾值也為0，說明一切都以預設值進行構造
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//這裡也是在他偷懶的後續彌補
//newCap = oldThr 之後並沒有計算閾值，所以 newThr = 0
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
****************後續程式碼......*******這一部分程式碼結束後，無論是初始化陣列還是擴容，總之，必需的陣列容量和閾值都已經計算完成了。下面看後續的程式碼：
************第一部分程式碼.....************
//根據新的容量初始化一個數組
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//舊陣列不為 null，這次的 resize 是一次擴容行為
if (oldTab != null) {
//將舊陣列中的每個節點位置相對靜止地拷貝值新陣列中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//獲取頭結點
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//說明連結串列或者紅黑樹只有一個頭結點，轉移至新表
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//如果 e 是紅黑樹結點，紅黑樹分裂，轉移至新表
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//這部分是將連結串列中的各個節點原序地轉移至新表中，我們後續會詳細說明
else {
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
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;
}
}
}
}
}
//不論你是擴容還是初始化，都可以返回 newTab
return newTab;對於第二部分的程式碼段來說，主要完成的是將舊連結串列中的各個節點按照原序地複製到新陣列中。關於頭結點是紅黑樹的情況我們暫時不去涉及，下面重點介紹下連結串列的拷貝和優化程式碼塊，這部分程式碼不再重複貼出，此處直接進行分析，有需要的可以參照上述列出的程式碼塊或者自己的 jdk 進行理解。
這部分其實是一個優化操作，將當前連結串列上的一些結點移出來向剛擴容的另一半儲存空間放。
一般我們有如下公式：
index = e.hash & (oldCap - 1)
隨便舉個例子，此時的 e 在容量擴大兩倍以後的索引值沒有變化，所以這部分結點是不需要移動的，那麼程式如何判斷擴容前後的 index 是否相等呢？
//oldCap 一定是 100...000 的形式
if ((e.hash & oldCap) == 0)如果原 oldCap 為 10000 的話，那麼擴容後的 newCap 則為 100000，會比原來多出一位。所以我們只要知道原索引值的前一位是 0 還是 1 即可，如果是 0，那麼它和新容量與後還是 0 並不改變索引的值，如果是 1 的話，那麼索引值會增加 oldCap。
這樣就分兩步拆分當前連結串列，一條連結串列是不需要移動的，依然儲存在當前索引值的結點上，另一條則需要變動到 index + oldCap 的索引位置上。
這裡我們只介紹了普通連結串列的分裂情況，至於紅黑樹的裂變其實是類似的，依然分出一些結點到 index + oldCap 的索引位置上，只不過遍歷的方式不同而已。
這樣，我們對於 resize 這個擴容的方法已經解析完成了，下面接著看 putVal 方法，篇幅比較長，該方法的原始碼已經在介紹 resize 之前貼出，建議讀者根據自己的 jdk 對照著理解。
上面我們說到，如果在 put 一個元素的時候判斷內部的 table 陣列還未初始化，那麼呼叫 resize 根據相應的引數資訊初始化陣列。接下來的這個判斷語句就很簡單了：
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);根據鍵的 hash 值找到對應的索引位置，如果該位置為 null，說明還沒有頭結點，於是 newNode 並存儲在該位置上。
否則的話說明該位置已經有頭結點了，或者說已經存在一個連結串列或紅黑樹了，那麼我們要做的只是新建一個節點新增到連結串列或者紅黑樹的最後位置即可。
第一步，
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p;p 指向當前節點，如果我們要插入的節點的鍵以及鍵所對應的 hash 值和 p 節點完全一樣的話，那麼說明這次 put 是一次修改操作，新建一個引用指向這個需要修改的節點。
第二步，
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);如果當前 p 節點是紅黑樹結點，那麼需要呼叫不同於連結串列的的新增節點的方法來新增一個節點到紅黑樹中。（主要是維持平衡，建議讀者去了解下紅黑樹，此處沒有深談是限於它的複雜度和文章篇幅）。
第三步，
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}這裡主要處理的是向普通連結串列的末尾新增一個新的結點，e 不斷地往後移動，如果發現 e 為 null，那麼說明已經到連結串列的末尾了，那麼新建一個節點新增到連結串列的末尾即可，因為 p 是 e 的父節點，所以直接讓 p.next 指向新節點即可。新增之後，如果發現連結串列長度超過 8，那麼將連結串列轉儲成紅黑樹。
在遍歷的過程中，如果發現 e 所指向的當前結點和我們即將插入的節點資訊完全匹配，那麼也說明這是一次修改操作，由於 e 已經指向了該需要被修改的結點，所以直接 break 即可。
那麼最終，無論是第一步中找到的頭節點即需要被修改的節點，還是第三步在遍歷中找到的需要被修改的節點，它們的引用都是 e，此時我們只需要用傳入的 Value 值替換 e 指向的節點的 value 即可。正如這段程式碼一樣：
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}如果 e 為 null，那更簡單了，說明此次 put 是新增新元素並且新元素也已經在上述程式碼中被新增到 HashMap 中了，我們只需要關心下，新加入一個元素後是否達到陣列的閾值，如果是則呼叫 resize 方法擴大陣列容量。該方法已經詳細闡述過，此處不再贅述。
所以，這個 put 方法是集新增與修改一體的一個方法，如果執行的是新增操作則會返回 null，是修改操作則會返回舊結點的 value 值。
那麼至此，我們對新增操作的內部實現想必已經瞭解的不錯了，接下來看看刪除操作的內部實現。
三、remove 方法的具體實現
刪除操作就是一個查詢+刪除的過程，相對於新增操作其實容易一些，但那是你基於上述新增方法理解的不錯的前提下。
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}根據鍵值刪除指定節點，這是一個最常見的操作了。顯然，removeNode 方法是核心。
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;
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;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||(value != null && value.equals(v)))) {
if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}刪除操作需要保證在表不為空的情況下進行，並且 p 節點根據鍵的 hash 值對應到陣列的索引，在該索引處必定有節點，如果為 null ，那麼間接說明此鍵所對應的結點並不存在於整個 HashMap 中，這是不合法的，所以首先要在這兩個大前提下才能進行刪除結點的操作。
第一步，
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
node = p;需要刪除的結點就是這個頭節點，讓 node 引用指向它。否則說明待刪除的結點在當前 p 所指向的頭節點的連結串列或紅黑樹中，於是需要我們遍歷查詢。
第二步，
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&((k = e.key) == key ||(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}如果頭節點是紅黑樹結點，那麼呼叫紅黑樹自己的遍歷方法去得到這個待刪結點。否則就是普通連結串列，我們使用 do while 迴圈去遍歷找到待刪結點。找到節點之後，接下來就是刪除操作了。
第三步，
if (node != null && (!matchValue || (v = node.value) == value ||(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}刪除操作也很簡單，如果是紅黑樹結點的刪除，直接呼叫紅黑樹的刪除方法進行刪除即可，如果是待刪結點就是一個頭節點，那麼用它的 next 結點頂替它作為頭節點存放在 table[index] 中，如果刪除的是普通連結串列中的一個節點，用該結點的前一個節點直接跳過該待刪結點指向它的 next 結點即可。
最後，如果 removeNode 方法刪除成功將返回被刪結點，否則返回 null。
這樣，相對複雜的 put 和 remove 方法的內部實現，我們已經完成解析了。下面看看其他常用的方法實現，它們或多或少都於這兩個方法有所關聯。
四、其他常用的方法介紹
除了常用的 put 和 remove 兩個方法外，HashMap 中還有一些好用的方法，下面我們簡單的學習下它們。
1、clear
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 中儲存的所有元素。
2、keySet
//例項屬性 keySet
transient volatile Set<K> keySet;
public Set<K> keySet() {
Set<K> ks;
return (ks = keySet) == null ? (keySet = new KeySet()) : ks;
}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);
}
}HashMap 中定義了一個 keySet 的例項屬性，它儲存的是整個 HashMap 中所有鍵的集合。上述所列出的 KeySet 類是 Set 的一個實現類，它負責為我們提供有關 HashMap 中所有對鍵的操作。
可以看到，KeySet 中的所有的例項方法都依賴當前的 HashMap 例項，也就是說，我們對返回的 keySet 集中的任意一個操作都會直接對映到當前 HashMap 例項中，例如你執行刪除一個鍵的操作，那麼 HashMap 中將會少一個節點。
3、values
public Collection<V> values() {
Collection<V> vs;
return (vs = values) == null ? (values = new Values()) : vs;
}values 方法其實和 keySet 方法類似，它返回了所有節點的 value 屬性所構成的 Collection 集合，此處不再贅述。
4、entrySet
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}它返回的是所有節點的集合，或者說是所有的鍵值對集合。
5、get
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}get 方法的內部實現其實是我們介紹過的 put 方法中的一部分，所以此處也不再贅述。
三、為何HashMap的陣列長度一定是2的次冪？
陣列進行擴容，陣列長度發生變化，而儲存位置 index = h&(length-1),index也可能會發生變化，需要重新計算index：
將老陣列中的資料逐個連結串列地遍歷，扔到新的擴容後的陣列中，我們的陣列索引位置的計算是通過 對key值的hashcode進行hash函式運算後，再通過和 length-1進行與運算。
1、保證得到的新的陣列索引和老陣列索引一致
16的二進位制表示為 10000，那麼length-1就是15，二進位制為01111，同理擴容後的陣列長度為32，二進位制表示為100000，length-1為31，二進位制表示為011111。從下圖可以我們也能看到這樣會保證低位全為1，而擴容後只有一位差異，也就是多出了最左位的1，這樣在通過 h & (length-1)的時候，只要h對應的最左邊的那一個差異位為0，就能保證得到的新的陣列索引和老陣列索引一致(大大減少了之前已經雜湊良好的老陣列的資料位置重新調換)。
2、獲得的陣列索引index更加均勻
陣列長度保持2的次冪，length-1的低位都為1
3、唯一性
&運算，高位是不會對結果產生影響的，所以只關注低位，如果低位全部為1，那麼對於h低位部分來說，任何一位的變化都會對結果產生影響，也就是說，要得到index=21這個儲存位置，h的低位只有這一種組合。
如果不是2的次冪，也就是低位不是全為1此時，要使得index=21，h的低位部分不再具有唯一性了，雜湊衝突的機率會變的更大，同時，index對應的這個bit位無論如何不會等於1了，而對應的那些陣列位置也就被白白浪費了
我們現在可以回答開始的幾個問題，加深對HashMap的理解：
-
什麼時候會使用HashMap？他有什麼特點？
是基於Map介面的實現，儲存鍵值對時，它可以接收null的鍵值，是非同步的，HashMap儲存著Entry(hash, key, value, next)物件。 -
你知道HashMap的工作原理嗎？
通過hash的方法，通過put和get儲存和獲取物件。儲存物件時，我們將K/V傳給put方法時，它呼叫hashCode計算hash從而得到bucket位置，進一步儲存，HashMap會根據當前bucket的佔用情況自動調整容量(超過Load Facotr則resize為原來的2倍)。獲取物件時，我們將K傳給get，它呼叫hashCode計算hash從而得到bucket位置，並進一步呼叫equals()方法確定鍵值對。如果發生碰撞的時候，Hashmap通過連結串列將產生碰撞衝突的元素組織起來，在Java 8中，如果一個bucket中碰撞衝突的元素超過某個限制(預設是8)，則使用紅黑樹來替換連結串列，從而提高速度。 -
你知道get和put的原理嗎？equals()和hashCode()的都有什麼作用？
通過對key的hashCode()進行hashing，並計算下標( n-1 & hash)，從而獲得buckets的位置。如果產生碰撞，則利用key.equals()方法去連結串列或樹中去查詢對應的節點 -
你知道hash的實現嗎？為什麼要這樣實現？
在Java 1.8的實現中，是通過hashCode()的高16位異或低16位實現的：(h = k.hashCode()) ^ (h >>> 16)，主要是從速度、功效、質量來考慮的，這麼做可以在bucket的n比較小的時候，也能保證考慮到高低bit都參與到hash的計算中，同時不會有太大的開銷。 -
如果HashMap的大小超過了負載因子(load factor)定義的容量，怎麼辦？
如果超過了負載因子(預設0.75)，則會重新resize一個原來長度兩倍的HashMap，並且重新呼叫hash方法。
關於Java的的集合小抄中的英文這樣描述的：
- 以輸入[]陣列實現的雜湊桶陣列，用金鑰的雜湊值取模桶陣列的大小可得到陣列下標。
- 插入元素時，如果兩條重點落在同一個桶（比如雜湊值1和17取模16後都屬於第一個雜湊桶），我們稱之為雜湊衝突。
- JDK的做法是連結串列法，輸入用一個下一個屬性實現多個入口以單向連結串列存放。查詢雜湊值為17的鑰匙時，先定位到雜湊桶，然後連結串列遍歷桶裡所有元素，逐個比較其雜湊值然後關鍵值。
- 在JDK8裡，新增預設為8的閾值，當一個桶裡的入境超過閥值，就不以單向連結串列而以紅黑樹來存放以加快重點的查詢速度。
- 當然，最好還是桶裡只有一個元素，不用去比較。所以預設當條目數量達到桶數量的75％時，雜湊衝突已比較嚴重，就會成倍擴容桶陣列，並重新分配所有原來的條目。擴容成本不低，所以也最好有個預估值。
- 取模用與操作（hash＆（arrayLength-1））會比較快，所以陣列的大小永遠是2的N次方，你隨便給一個初始值比如17會轉為32.預設第一次放入元素時的初始值是16。
- 迭代器（）時順著雜湊桶陣列來遍歷，看起來是個亂序