繼承關係
資料結構
HashMap 1.8在1.7的基礎之上增加了紅黑樹，所以資料結構為：陣列 + 連結串列 + 紅黑樹 連結串列結點:
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
複製程式碼紅黑樹結點：
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;
}
複製程式碼簡單的說，HashMap 是以 key-value 的形式儲存資料，當加入新的資料時，利用 key 計算出該結點的下標（陣列），把結點插入該位置上的連結串列，當連結串列達到一定大小，這時候可能影響查詢效率，所以將連結串列轉化為樹。
HashMap 成員變數：
//預設陣列長度
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/預設/陣列最大長度
static final int MAXIMUM_CAPACITY = 1 << 30;
//預設負載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//預設連結串列->紅黑樹的閾值
static final int TREEIFY_THRESHOLD = 8;
//預設紅黑樹->連結串列的閾值
static final int UNTREEIFY_THRESHOLD = 6;
//預設/連結串列->紅黑樹的最小容量（針對陣列）
static final int MIN_TREEIFY_CAPACITY = 64;
//所有的鍵值對個數
transient int size;
//修改次數
transient int modCount;
//調整陣列大小的閾值， = loadfactor * length
int threshold;
//載入因子
final float loadFactor;
複製程式碼ps：TREEIFY_THRESHOLD 和 MIN_TREEIFY_CAPACITY 有什麼不同？ TREEIFY_THRESHOLD表示當連結串列長度大於這個值時執行樹化函式，但是要不要樹化還要看陣列長度是否大於 MIN_TREEIFY_CAPACITY，不大於將不進行樹化，只是對陣列進行擴容。也就是說當連結串列長度大於 TREEIFY_THRESHOLD 並且 陣列長度大於 MIN_TREEIFY_CAPACITY 時才會進行樹化操作。
方法的實現
四個方法：
- hash()
- put()
- resize()
- get()
hash()
在對陣列進行 put() 和 get()之前，都會先使用hash()函式對 key 進行計算，得到 key 的 hash 值，再用 hash & 陣列length-1 得出該結點所在的陣列的下標。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
複製程式碼可以看出，HashMap 中是可以有 key 為 null 的結點的，並且它處於陣列下標為 0 的位置。當 key 不為空時，計算出 key 的 hashCode，然後用 hashCode 和 hashCode >>> 16 （即高 16 位和低 16 位進行異或）為進行異或計算出 hash 值。
PS：為什麼要用 hashCode ^ (hashCode >>> 16)？
為了讓 hashCode 的高位和低位都參與到陣列下標的計算中來，使得計算出的下標更加均勻，從而減少衝突（避免連結串列過長）。
陣列下標的計算是這樣的：
index = hash & (length - 1);
複製程式碼hash 是個 32 位的二進位制數，所以當 length 比較小（陣列長度小）時，比如初始長度 16，則 length - 1 的二進位制數為 1111，所以整個 32 位的 hash 值只有最後面的 4 位數參與了下標的計算， 這將會導致更多的衝突產生，所以在進行下標計算之前，先使用 hash ^ (hash >>> 16)，讓 hash 值的高 16 位和低 16 位進行異或，使得 hash 值本身隨機性就比較大，從而減少了衝突的產生。
++：JDK 原始碼中 HashMap 的 hash 方法原理是什麼？ - 胖胖的回答 - 知乎
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;
//陣列為空先進行擴容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//該插入的陣列位置為null，直接放入
if ((p = tab[i = (n - 1) & hash]) == null)
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))))
e = p;
//否則，插入到紅黑樹中
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//插入連結串列中
else {
for (int binCount = 0; ; ++binCount) {
//連結串列中不存在該相同的 key，生成新結點插入尾部
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;
}
//該連結串列中存在相同的 key，break
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//存在key相同的舊結點
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//訪問結點之後，LinkedHashMap中會重寫來達到重排序的目的
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//結點總是大於閾值，擴容
if (++size > threshold)
resize();
//插入結點之後，LinkedHashMap中會重寫來達到重排序的目的
afterNodeInsertion(evict);
return null;
}
複製程式碼執行過程：
- 陣列為空先進行擴容
- 通過 key 的 hash 值計算出陣列下標，陣列中改位置為空，直接插入
- 否則，如果陣列中該下標位置是紅黑樹，將結點插入到紅黑樹中
- 如果陣列中該下標位置是連結串列，進行連結串列的插入，如果連結串列長度大於閾值，則進行樹化
- 判斷總結點數是否已經大於閾值，大於則擴容
上述在執行樹化函式的時候，還會判斷陣列的長度是否大於MIN_TREEIFY_CAPACITY 所設的閾值，如果不大於會進行陣列的擴容而不是樹化。所以說樹化的條件有兩個：
- 連結串列長度大於 TREEIFY_THRESHOLD（預設8）
- 陣列長度大於 MIN_TREEIFY_CAPACITY（預設64）
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
//樹化
}
}
複製程式碼resize()
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) {
//陣列的最大長度不超過 1<<30
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//新容量 = 舊容量 * 2
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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;
//只有一個結點的位置
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 { // preserve order
//lo...是重新計算過後還在原雜湊桶的所有結點所連成的連結串列
Node<K,V> loHead = null, loTail = null;
//hi...為重新計算過後在新雜湊桶的所有結點所連成的連結串列
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//把還在原來位置的結點連線成新連結串列
//oldCap = 1000...，可驗證和 1000... 的 1 相與的數是 0 還是 1
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;
}
}
}
}
}
return newTab;
}
複製程式碼對上面的程式碼提出兩個：
- 為什麼陣列擴容後的大小都是 2 的整數冪？或者說為什麼都是 * 2？
- 為什麼重新計算過後位置有變化的連結串列是放在 原位置+舊陣列length 的位置？
-
為什麼陣列擴容後的大小都是 2 的整數冪？或者說為什麼都是 * 2？ 在使用 key 的 hash 值計算陣列 index 的時候，使用的程式碼是
hash & length-1，為什麼不是 length 而是 length - 1？因為陣列的length總是 2 的整數次冪，而 2^n - 1 的二進位制數總是 1111...，x & 1111...的結果都取決於 x 本身，假設使用的是 length，length = 1000...，那麼x & 1000...的結果只有和 1 匹配的哪一位數決定，這將導致更多的衝突產生，結點分佈不均勻，影響效能。 -
為什麼重新計算過後位置有變化的連結串列是放在 原位置+舊陣列length 的位置？ 因為陣列擴容 length << 1 之後，length 二進位制數的最高位的 1 向左移動了一位（比如 1000 變成了 10000），這使得 length - 1 的最高位也多了個 1（111 變成了 1111）， 所以在進行下標運算
hash & length - 1時，只會產生兩個結果：不變 或者 原位置+舊陣列length，這取決於和 length 最高位相與的 hash 值得二進位制數。比如：
get()
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) {
//hash桶的第一個結點是不是該結點
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
//從紅黑樹中查詢
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//從連結串列中查詢
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
複製程式碼