終於來到比較複雜的HashMap，由於內部的變數，內部類，方法都比較多，沒法像ArrayList那樣直接平鋪開來說，因此準備從幾個具體的角度來切入。
桶結構
HashMap的每個儲存位置，又叫做一個桶，當一個Key&Value進入map的時候，依據它的hash值分配一個桶來儲存。
看一下桶的定義：table就是所謂的桶結構，說白了就是一個節點陣列。
transient Node<K,V>[] table;
transient int size;節點
HashMap是一個map結構，它不同於Collection結構，不是儲存單個物件，而是儲存鍵值對。
因此內部最基本的儲存單元是節點：Node。
節點的定義如下：
class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}可見節點除了儲存key,vaue,hash三個值之外，還有一個next指標，這樣一樣，多個Node可以形成一個單向列表。這是解決hash衝突的一種方式，如果多個節點被分配到同一個桶，可以組成一個連結串列。
HashMap內部還有另一種節點型別，叫做TreeNode：
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;
}TreeNode是從Node繼承的，它可以組成一棵紅黑樹。為什麼還有這個東東呢？上面說過，如果節點的被雜湊到同一個桶，那麼可能導致連結串列特別長，這樣一來訪問效率就會急劇下降。 此時如果key是可比較的(實現了Comparable介面），HashMap就將這個連結串列轉成一棵平衡二叉樹，來挽回一些效率。在實際使用中，我們期望這種現象永遠不要發生。
有了這個知識，就可以看看HashMap幾個相關常量定義了：
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;- TREEIFY_THRESHOLD，當某個桶裡面的節點數達到這個數量，連結串列可轉換成樹；
- UNTREEIFY_THRESHOLD，當某個桶裡面數低於這數量，樹轉換回連結串列；
- MIN_TREEIFY_CAPACITY，如果桶數量低於這個數，那麼優先擴充桶的數量，而不是將連結串列轉換成樹；
put方法：Key&Value
插入介面：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}put方法呼叫了私有方法putVal，不過值得注意的是，key的hash值不是直接用的hashCode，最終的hash=（hashCode右移16）^ hashCode。
在將hash值對映為桶位置的時候，取的是hash值的低位部分，這樣如果有一批key的僅高位部分不一致，就會聚集的同一個桶裡面。（如果桶數量比較少，key是Float型別，且是連續的整數，就會出現這種case）。
執行插入的過程：
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)
n = (tab = resize()).length;
//程式碼段1
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//程式碼段2
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//程式碼段3
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//程式碼段4
for (int binCount = 0; ; ++binCount) {
//程式碼段4.1
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//程式碼段4.2
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//程式碼段5
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//程式碼段6
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}- 最開始的一段處理桶陣列還沒有分配的情況；
- 程式碼段1： i = (n - 1) & hash，計算hash對應的桶位置，因為n是2的冥次，這是一種高效的取模操作；如果這個位置是空的，那麼直接建立Node放進去就OK了；否則這個衝突位置的節點記為P;
- 程式碼段2：如果節點P的key和傳入的key相等，那麼說明新的value要放入一個現有節點裡面，記為e;
- 程式碼段3：如果節點P是一棵樹，那麼將key&value插入到這個棵樹裡面；
- 程式碼段4：P是連結串列頭，或是單獨一個節點，兩種情況，都可以通過掃描連結串列的方式來做；
- 程式碼段4.1：如果連結串列到了尾部，插入一個新節點，同時如果有必要，將連結串列轉成樹；
- 程式碼段4.2：如果連結串列中找到了相等的key，和程式碼段2一樣處理；
- 程式碼段5：將value存入節點e
- 程式碼段6：如果size超過某個特定值，要調整桶的數量，關於resize的策略在下文會講
remove方法
瞭解了put方法，remove方法就容易了，直接講解私有方法removeNode吧。
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
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) {
//程式碼段2：
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;
//程式碼段3:
else if ((e = p.next) != null) {
//程式碼段3.1:
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//程式碼段3.2:
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//程式碼段4:
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//程式碼段4.1:
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//程式碼段4.2:
else if (node == p)
tab[index] = node.next;
//程式碼段4.3:
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}- 程式碼段1：這個if條件在判斷hash對應的桶是否空的，如果是話，那麼map裡面肯定就沒有這個key；否則第一個節點記為P；
- 程式碼段2：如果P節點的key與引數key相等，找到了要移除的節點，記為node；
- 程式碼段3：掃描桶裡面的其他節點
- 程式碼段3.1：如果桶裡面這是一顆樹，執行樹的查詢邏輯；
- 程式碼段3.2： 執行連結串列掃描邏輯；
- 程式碼段4：如果找到了node，那麼嘗試刪除它
- 程式碼段4.1：如果是樹節點，執行樹的節點刪除邏輯；
- 程式碼段4.2：node是連結串列頭結點，將node.next放入桶就ok；
- 程式碼段4.3：刪除連結串列中間節點
rehash
rehash就是重新分配桶，並將原有的節點重新hash到新的桶位置。
先看兩個和桶的數量相關的成員變數
final float loadFactor;
int threshold;- loadFactor 負載因子，是建立HashMap時設定的一個值，即map所包含的條目數量與桶數量的比值上限；一旦map的負載達到這個值，就需要擴充套件桶的數量；
- threshold map的數量達到這個值，就需要擴充套件桶，它的值基本上等於
桶的容量*loadFactor，我感覺就是一個快取值，加快相關的操作，不用每次都去計算；
桶的擴充套件策略，見下面的函式，如果需要的容量是cap，真實擴充套件的容量是大於cap的一個2的冥次。
這樣依賴，每次擴充套件，增加的容量都是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;
}這是具體的擴充套件邏輯
Node<K,V>[] resize() {
//此處省略了計算newCap的邏輯
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;
//分支1
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//分支2
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//分支3
else { // preserve order
//此處省略了連結串列拆分邏輯
}
}
}
return newTab;
}- 首先分配新的桶陣列；
- 掃描舊的桶，將元素遷移過來；
- 分支1：桶裡面只有一個新的節點，那麼放入到新桶對應的位置即可；
- 分支2：桶裡面是一棵樹，執行樹的拆分邏輯
- 分支3：桶裡面是一個連結串列，執行連結串列的拆分邏輯；
由於新桶的數量是舊桶的2的倍數，所以每個舊桶都能對應2個或更多的新桶，互不干擾。 所以上面的遷移邏輯，並不需要檢查新桶裡面是否有節點。
可見，rehash的代價是很大的，最好在初始化的時候，能夠設定一個合適的容量，避免rehash。
最後，雖然上面的程式碼沒有體現，在HashMap的生命週期內，桶的數量只會增加，不會減少。
迭代器
所有迭代器的核心就是這個HashIterator
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
}簡單起見，只保留了next部分的程式碼。原理很簡單，next指向下一個節點，肯定處在某個桶當中(桶的位置是index)。那麼如果同一個桶還有其他節點，那麼一定可以順著next.next來找到，無論這是一個連結串列還是一棵樹。否則掃描下一個桶。
有了上面的節點迭代器，其他使用者可見的迭代器都是通過它來實現的。
final class KeyIterator extends HashIterator
implements Iterator<K> {
public final K next() { return nextNode().key; }
}
final class ValueIterator extends HashIterator
implements Iterator<V> {
public final V next() { return nextNode().value; }
}
final class EntryIterator extends HashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() { return nextNode(); }
}檢視
KeySet的部分程式碼：這並不是一個獨立的Set，而是一個檢視，它的介面內部訪問的都是HashMap的資料。
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;
}
}EntrySet、Values和KeySet也是類似的，不再贅述。
要點總結
1、key&value儲存在節點中；
2、節點有可能是連結串列節點，也有可能是樹節點；
3、依據key雜湊值給節點分配桶；
4、如果桶裡面有多個節點，那麼要麼形成一個連結串列，要麼形成一顆樹；
5、裝載因子限制的了節點和桶的數量比例，必要時會擴充套件桶的數量；
6、桶數量必然是2的冥次，重新分配桶的過程叫做rehash，這是很昂貴的操作；