作者：炸雞可樂
原文出處：www.pzblog.cn
一、摘要
在集合系列的第一章，咱們了解到，Map的實現類有HashMap、LinkedHashMap、TreeMap、IdentityHashMap、WeakHashMap、Hashtable、Properties等等。
關於HashMap，一直都是一個非常熱門的話題，只要你出去面試，我保證一定少不了它！
本文主要結合JDK1.7和JDK1.8的區別，就HashMap的數據結構和實現功能，進行深入探討，廢話也不多說了，直奔主題！
二、簡介
在程序編程的時候，HashMap是一個使用非常頻繁的容器類，它允許鍵值都放入null元素。除該類方法未實現同步外，其余跟Hashtable大致相同，但跟TreeMap不同，該容器不保證元素順序，根據需要該容器可能會對元素重新哈希，元素的順序也會被重新打散，因此不同時間迭代同一個HashMap的順序可能會不同。
HashMap容器，實質還是一個哈希數組結構，但是在元素插入的時候，存在發生hash沖突的可能性；
對於發生Hash沖突的情況，沖突有兩種實現方式，一種開放地址方式（當發生hash沖突時，就繼續以此繼續尋找，直到找到沒有沖突的hash值），另一種是拉鏈方式（將沖突的元素放入鏈表）。Java HashMap采用的就是第二種方式，拉鏈法。
在jdk1.7中，HashMap主要是由數組+鏈表組成，當發生hash沖突的時候，就將沖突的元素放入鏈表中。
從jdk1.8開始，HashMap主要是由數組+鏈表+紅黑樹實現的，相比jdk1.7而言，多了一個紅黑樹實現。當鏈表長度超過8的時候，就將鏈表變成紅黑樹，如圖所示。
關於紅黑樹的實現，因為篇幅太長，在《集合系列》文章中紅黑樹設計，也有所介紹，這里就不在詳細介紹了。
三、源碼解析
直接打開HashMap的源碼分析，可以看到，主要有5個關鍵參數：
- threshold：表示容器所能容納的key-value對極限。
- loadFactor：負載因子。
- modCount：記錄修改次數。
- size：表示實際存在的鍵值對數量。
- table：一個哈希桶數組，鍵值對就存放在里面。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//所能容納的key-value對極限
int threshold;
//負載因子
final float loadFactor;
//記錄修改次數
int modCount;
//實際存在的鍵值對數量
int size;
//哈希桶數組
transient Node<K,V>[] table;
}
接着來看看Node這個類，Node是HashMap的一個內部類，實現了Map.Entry接口，本質是就是一個映射(鍵值對)
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//hash值
final K key;//k鍵
V value;//value值
Node<K,V> next;//鏈表中下一個元素
}
在HashMap的數據結構中，有兩個參數可以影響HashMap的性能：初始容量（inital capacity）和負載因子（load factor）。
初始容量（inital capacity）是指table的初始長度length（默認值是16）；
負載因子（load factor）用指自動擴容的臨界值（默認值是0.75）；
threshold是HashMap所能容納的最大數據量的Node(鍵值對)個數，計算公式threshold = capacity * Load factor。當entry的數量超過capacity*load_factor時，容器將自動擴容並重新哈希，擴容后的HashMap容量是之前容量的兩倍，所以數組的長度總是2的n次方。
初始容量和負載因子也可以修改，具體實現方式，可以在對象初始化的時候，指定參數，比如：
Map map = new HashMap(int initialCapacity, float loadFactor);
但是，默認的負載因子0.75是對空間和時間效率的一個平衡選擇，建議大家不要修改，除非在時間和空間比較特殊的情況下，如果內存空間很多而又對時間效率要求很高，可以降低負載因子Load factor的值；相反，如果內存空間緊張而對時間效率要求不高，可以增加負載因子loadFactor的值，這個值可以大於1。 同時，對於插入元素較多的場景，可以將初始容量設大，減少重新哈希的次數。
HashMap的內部功能實現有很多，本文主要從以下幾點，進行逐步分析。
- 通過K獲取數組下標；
- put方法的詳細執行；
- resize擴容過程；
- get方法獲取參數值；
- remove刪除元素；
3.1、通過K獲取數組下標
不管增加、刪除還是查找鍵值對，定位到數組的位置都是很關鍵的第一步，打開hashMap的任意一個增加、刪除、查找方法，從源碼可以看出，通過key獲取數組下標，主要做了3步操作，其中length指的是容器數組的大小。
源碼部分：
/**獲取hash值方法*/
static final int hash(Object key) {
int h;
// h = key.hashCode() 為第一步 取hashCode值（jdk1.7）
// h ^ (h >>> 16) 為第二步 高位參與運算（jdk1.7）
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//jdk1.8
}
/**獲取數組下標方法*/
static int indexFor(int h, int length) {
//jdk1.7的源碼，jdk1.8沒有這個方法，但是實現原理一樣的
return h & (length-1); //第三步 取模運算
}
3.2、put方法的詳細執行
put(K key, V value)方法是將指定的key, value對添加到map里。該方法首先會對map做一次查找，看是否包含該K，如果已經包含則直接返回；如果沒有找到，則將元素插入容器。具體插入過程如下：
具體執行步驟
- 1、判斷鍵值對數組table[i]是否為空或為null，否則執行resize()進行擴容；
- 2、根據鍵值key計算hash值得到插入的數組索引i，如果table[i]==null，直接新建節點添加；
- 3、當table[i]不為空，判斷table[i]的首個元素是否和傳入的key一樣，如果相同直接覆蓋value；
- 4、判斷table[i] 是否為treeNode，即table[i] 是否是紅黑樹，如果是紅黑樹，則直接在樹中插入鍵值對；
- 5、遍歷table[i]，判斷鏈表長度是否大於8，大於8的話把鏈表轉換為紅黑樹，在紅黑樹中執行插入操作，否則進行鏈表的插入操作；遍歷過程中若發現key已經存在直接覆蓋value即可；
- 6、插入成功后，判斷實際存在的鍵值對數量size是否超多了最大容量threshold，如果超過，進行擴容操作；
put方法源碼部分
/**
* put方法
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
插入元素方法
/**
* 插入元素方法
*/
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、判斷數組table是否為空或為null
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//2、判斷數組下標table[i]==null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//3、判斷table[i]的首個元素是否和傳入的key一樣
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//4、判斷table[i] 是否為treeNode
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//5、遍歷table[i]，判斷鏈表長度是否大於8
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//長度大於8，轉紅黑樹結構
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//傳入的K元素已經存在，直接覆蓋value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//6、判斷size是否超出最大容量
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
其中，與jdk1.7有區別的地方，第4步新增了紅黑樹插入方法，源碼部分：
/**
* 紅黑樹的插入操作
*/
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
//dir:遍歷的方向， ph:p節點的hash值
int dir, ph; K pk;
//紅黑樹是根據hash值來判斷大小
// -1:左孩子方向 1:右孩子方向
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
//如果key存在的話就直接返回當前節點
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//如果當前插入的類型和正在比較的節點的Key是Comparable的話，就直接通過此接口比較
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
//嘗試在p的左子樹或者右子樹中找到了目標元素
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
//獲取遍歷的方向
dir = tieBreakOrder(k, pk);
}
//上面的所有if-else判斷都是在判斷下一次進行遍歷的方向，即dir
TreeNode<K,V> xp = p;
//當下面的if判斷進去之后就代表找到了目標操作元素,即xp
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
//插入新的元素
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
//因為TreeNode今后可能退化成鏈表，在這里需要維護鏈表的next屬性
xp.next = x;
//完成節點插入操作
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
//插入操作完成之后就要進行一定的調整操作了
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
3.3、resize擴容過程
在說jdk1.8的HashMap動態擴容之前，我們先來了解一下jdk1.7的HashMap擴容實現，因為jdk1.8代碼實現比Java1.7復雜了不止一倍，主要是Java1.8引入了紅黑樹設計，但是實現思想大同小異！
3.3.1、jdk1.7的擴容實現
源碼部分
/**
* JDK1.7擴容方法
* 傳入新的容量
*/
void resize(int newCapacity) {
//引用擴容前的Entry數組
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//擴容前的數組大小如果已經達到最大(2^30)了
if (oldCapacity == MAXIMUM_CAPACITY) {
//修改閾值為int的最大值(2^31-1)，這樣以后就不會擴容了
threshold = Integer.MAX_VALUE;
return;
}
//初始化一個新的Entry數組
Entry[] newTable = new Entry[newCapacity];
//將數據轉移到新的Entry數組里，這里包含最重要的重新定位
transfer(newTable);
//HashMap的table屬性引用新的Entry數組
table = newTable;
threshold = (int) (newCapacity * loadFactor);//修改閾值
}
transfer復制數組方法，源碼部分：
//遍歷每個元素，按新的容量進行rehash，放到新的數組上
void transfer(Entry[] newTable) {
//src引用了舊的Entry數組
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
//遍歷舊的Entry數組
Entry<K, V> e = src[j];
//取得舊Entry數組的每個元素
if (e != null) {
//釋放舊Entry數組的對象引用（for循環后，舊的Entry數組不再引用任何對象）
src[j] = null;
do {
Entry<K, V> next = e.next;
//重新計算每個元素在數組中的位置
//實現邏輯，也是上文那個取模運算方法
int i = indexFor(e.hash, newCapacity);
//標記數組
e.next = newTable[i];
//將元素放在數組上
newTable[i] = e;
//訪問下一個Entry鏈上的元素，循環遍歷
e = next;
} while (e != null);
}
}
}
jdk1.7擴容總結：newTable[i]的引用賦給了e.next，也就是使用了單鏈表的頭插入方式，同一位置上新元素總會被放在鏈表的頭部位置；這樣先放在一個索引上的元素終會被放到Entry鏈的尾部(如果發生了hash沖突的話），這一點和Jdk1.8有區別。在舊數組中同一條Entry鏈上的元素，通過重新計算索引位置后，有可能被放到了新數組的不同位置上。
3.3.2、jdk1.8的擴容實現
源碼如下
final Node<K,V>[] resize() {
//引用擴容前的node數組
Node<K,V>[] oldTab = table;
//舊的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//舊的閾值
int oldThr = threshold;
//新的容量、閾值初始化為0
int newCap, newThr = 0;
if (oldCap > 0) {
//如果舊容量已經超過最大容量，讓閾值也等於最大容量，以后不再擴容
threshold = Integer.MAX_VALUE;
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 沒超過最大值，就擴充為原來的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果舊容量翻倍沒有超過最大值，且舊容量不小於初始化容量16，則翻倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
//初始化容量設置為閾值
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//0的時候使用默認值初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//計算新閾值，如果新容量或新閾值大於等於最大容量，則直接使用最大值作為閾值，不再擴容
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//設置新閾值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//創建新的數組，並引用
table = newTab;
//如果老的數組有數據，也就是是擴容而不是初始化，才執行下面的代碼，否則初始化的到這里就可以結束了
if (oldTab != null) {
//輪詢老數組所有數據
for (int j = 0; j < oldCap; ++j) {
//以一個新的節點引用當前節點，然后釋放原來的節點的引用
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果e沒有next節點，證明這個節點上沒有hash沖突，則直接把e的引用給到新的數組位置上
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//！！！如果是紅黑樹，則進行分裂
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
// 鏈表優化重hash的代碼塊
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//從這條鏈表上第一個元素開始輪詢，如果當前元素新增的bit是0，則放在當前這條鏈表上，如果是1，則放在"j+oldcap"這個位置上，生成“低位”和“高位”兩個鏈表
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
//元素是不斷的加到尾部的，不會像1.7里面一樣會倒序
loTail.next = e;
//新增的元素永遠是尾元素
loTail = e;
}
else {
//高位的鏈表與低位的鏈表處理邏輯一樣，不斷的把元素加到鏈表尾部
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//低位鏈表放到j這個索引的位置上
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//高位鏈表放到(j+oldCap)這個索引的位置上
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
1.7與1.8處理邏輯大同小異，區別主要還是在樹節點的分裂((TreeNode<K,V>)e).split() 這個方法上
/**
* 紅黑樹分裂方法
*/
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
//當前這個節點的引用，即這個索引上的樹的根節點
TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
//高位低位的初始樹節點個數都設成0
int lc = 0, hc = 0;
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
//bit=oldcap,這里判斷新bit位是0還是1，如果是0就放在低位樹上，如果是1就放在高位樹上，這里先是一個雙向鏈表
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
//！！！如果低位的鏈表長度小於閾值6，則把樹變成鏈表，並放到新數組中j索引位置
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
//高位不為空，進行紅黑樹轉換
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
untreeify方法，將樹轉變為單向鏈表
/**
* 將樹轉變為單向鏈表
*/
final Node<K,V> untreeify(HashMap<K,V> map) {
Node<K,V> hd = null, tl = null;
for (Node<K,V> q = this; q != null; q = q.next) {
Node<K,V> p = map.replacementNode(q, null);
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
treeify方法，將鏈表轉換為紅黑樹，會根據紅黑樹特性進行顏色轉換、左旋、右旋等
/**
* 鏈表轉換為紅黑樹，會根據紅黑樹特性進行顏色轉換、左旋、右旋等
*/
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
if (root == null) {
x.parent = null;
x.red = false;
root = x;
}
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
//進行左旋、右旋調整
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}
jdk1.8在進行重新擴容之后，會重新計算hash值，因為n變為2倍，假設初始 tableSize = 4 要擴容到 8 來說就是 0100 到 1000 的變化（左移一位就是 2 倍），在擴容中只用判斷原來的 hash 值與左移動的一位（newtable 的值）按位與操作是 0 或 1 就行，0 的話索引就不變，1 的話索引變成原索引 + oldCap；
其實現如下流程圖所示：
可以看見，因為 hash 值本來就是隨機性的，所以 hash 按位與上 newTable 得到的 0（擴容前的索引位置）和 1（擴容前索引位置加上擴容前數組長度的數值索引處）就是隨機的，所以擴容的過程就能把之前哈希沖突的元素再隨機的分布到不同的索引去，這算是 JDK1.8 的一個優化點。
此外，JDK1.7中rehash的時候，舊鏈表遷移新鏈表的時候，如果在新表的數組索引位置相同，則鏈表元素會倒置，但是從上圖可以看出，JDK1.8不會倒置。
同時，由於 JDK1.7 中發生哈希沖突時僅僅采用了鏈表結構存儲沖突元素，所以擴容時僅僅是重新計算其存儲位置而已。而 JDK1.8 中為了性能在同一索引處發生哈希沖突到一定程度時，鏈表結構會轉換為紅黑數結構存儲沖突元素，故在擴容時如果當前索引中元素結構是紅黑樹且元素個數小於鏈表還原閾值時就會把樹形結構縮小或直接還原為鏈表結構（其實現就是上面代碼片段中的 split() 方法）。
3.4、get方法獲取參數值
get(Object key)方法根據指定的key值返回對應的value，getNode(hash(key), key))得到相應的Node對象e，然后返回e.value。因此getNode()是算法的核心。
get方法源碼部分：
/**
* JDK1.8 get方法
* 通過key獲取參數值
*/
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
通過hash值和key獲取節點Node方法，源碼部分：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//1、判斷第一個元素是否與key匹配
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
//2、判斷鏈表是否紅黑樹結構
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//3、如果不是紅黑樹結構，直接循環判斷
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
在紅黑樹中找到指定k的TreeNode，源碼部分：
/**
* 這里面情況分很多中，主要是因為考慮了hash相同但是key值不同的情況，查找的最核心還是落在key值上
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
//判斷要查詢元素的hash是否在樹的左邊
if ((ph = p.hash) > h)
p = pl;
//判斷要查詢元素的hash是否在樹的右邊
else if (ph < h)
p = pr;
//查詢元素的hash與當前樹節點hash相同情況
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//上面的三步都是正常的在二叉查找樹中尋找對象的方法
//如果hash相等，但是內容卻不相等
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
//如果可以根據compareTo進行比較的話就根據compareTo進行比較
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
//根據compareTo的結果在右孩子上繼續查詢
else if ((q = pr.find(h, k, kc)) != null)
return q;
//根據compareTo的結果在左孩子上繼續查詢
else
p = pl;
} while (p != null);
return null;
}
get方法，首先通過hash()函數得到對應數組下標，然后依次判斷。
- 1、判斷第一個元素與key是否匹配，如果匹配就返回參數值；
- 2、判斷鏈表是否紅黑樹，如果是紅黑樹，就進入紅黑樹方法獲取參數值；
- 3、如果不是紅黑樹結構，直接循環判斷，直到獲取參數為止；
3.5、remove刪除元素
remove(Object key)的作用是刪除key值對應的Node，該方法的具體邏輯是在removeNode(hash(key), key, null, false, true)里實現的。
remove方法，源碼部分：
/**
* JDK1.8 remove方法
* 通過key移除對象
*/
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
通過key移除Node節點方法，源碼部分：
/**
* 通過key移除Node節點
*/
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;
//1、判斷要刪除的元素，是否存在
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;
//2、判斷第一個元素是不是我們要找的元素
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
//3、判斷當前沖突鏈表是否紅黑樹結構
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//4、循環在鏈表中找到需要刪除的元素
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)))) {
//5、如果當前沖突鏈表結構是紅黑樹，執行紅黑樹刪除方法
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;
}
removeTreeNode移除紅黑樹節點方法，源碼部分：
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable) {
int n;
if (tab == null || (n = tab.length) == 0)
return;
int index = (n - 1) & hash;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
if (pred == null)
tab[index] = first = succ;
else
pred.next = succ;
if (succ != null)
succ.prev = pred;
if (first == null)
return;
if (root.parent != null)
root = root.root();
if (root == null || root.right == null ||
(rl = root.left) == null || rl.left == null) {
tab[index] = first.untreeify(map); // too small
return;
}
TreeNode<K,V> p = this, pl = left, pr = right, replacement;
if (pl != null && pr != null) {
TreeNode<K,V> s = pr, sl;
while ((sl = s.left) != null) // find successor
s = sl;
boolean c = s.red; s.red = p.red; p.red = c; // swap colors
TreeNode<K,V> sr = s.right;
TreeNode<K,V> pp = p.parent;
if (s == pr) { // p was s's direct parent
p.parent = s;
s.right = p;
}
else {
TreeNode<K,V> sp = s.parent;
if ((p.parent = sp) != null) {
if (s == sp.left)
sp.left = p;
else
sp.right = p;
}
if ((s.right = pr) != null)
pr.parent = s;
}
p.left = null;
if ((p.right = sr) != null)
sr.parent = p;
if ((s.left = pl) != null)
pl.parent = s;
if ((s.parent = pp) == null)
root = s;
else if (p == pp.left)
pp.left = s;
else
pp.right = s;
if (sr != null)
replacement = sr;
else
replacement = p;
}
else if (pl != null)
replacement = pl;
else if (pr != null)
replacement = pr;
else
replacement = p;
if (replacement != p) {
TreeNode<K,V> pp = replacement.parent = p.parent;
if (pp == null)
root = replacement;
else if (p == pp.left)
pp.left = replacement;
else
pp.right = replacement;
p.left = p.right = p.parent = null;
}
//判斷是否需要進行紅黑樹結構調整
TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);
if (replacement == p) { // detach
TreeNode<K,V> pp = p.parent;
p.parent = null;
if (pp != null) {
if (p == pp.left)
pp.left = null;
else if (p == pp.right)
pp.right = null;
}
}
if (movable)
moveRootToFront(tab, r);
}
jdk1.8的刪除邏輯實現比較復雜，相比jdk1.7而言，多了紅黑樹節點刪除和調整：
- 1、默認判斷鏈表第一個元素是否是要刪除的元素；
- 2、如果第一個不是，就繼續判斷當前沖突鏈表是否是紅黑樹，如果是，就進入紅黑樹里面去找；
- 3、如果當前沖突鏈表不是紅黑樹，就直接在鏈表中循環判斷，直到找到為止；
- 4、將找到的節點，刪除掉，如果是紅黑樹結構，會進行顏色轉換、左旋、右旋調整，直到滿足紅黑樹特性為止；
四、總結
1、如果key是一個對象，記得在對象實體類里面，要重寫equals和hashCode方法，不然在查詢的時候，無法通過對象key來獲取參數值！
2、相比JDK1.7，JDK1.8引入紅黑樹設計，當鏈表長度大於8的時候，鏈表會轉化為紅黑樹結構，發生沖突的鏈表如果很長，紅黑樹的實現很大程度優化了HashMap的性能，使查詢效率比JDK1.7要快一倍！
3、對於大數組的情況，可以提前給Map初始化一個容量，避免在插入的時候，頻繁的擴容，因為擴容本身就比較消耗性能！
五、參考
1、JDK1.7&JDK1.8 源碼