JDK1.8 HashMap原始碼解析（不分析紅黑樹部分）
阿新 • • 發佈：2019-01-01
一、HashMap資料結構
HashMap由 陣列+連結串列+紅黑樹實現，桶中元素可能為連結串列，也可能為紅黑樹。為了提高綜合（查詢、新增、修改）效率，當桶中元素數量超過TREEIFY_THRESHOLD（預設為8）時，連結串列儲存改為紅黑樹儲存，當桶中元素數量小於UNTREEIFY_THRESHOLD（預設為6）時，紅黑樹儲存改為連結串列儲存。
table即Node<k,v>[] table，Node有兩種，分別為連結串列節點Node和其子類TreeNode（紅黑樹節點）
每一個table槽稱為桶，用於裝hash%table.length的元素
table.length為2的整數冪，主要是為了提高取模運算效率，即對於2的整數冪n，hash%n可以轉化為hash&(n-1)
二、HashMap類屬性及建構函式
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { // 序列號 private static final long serialVersionUID = 362498820763181265L; // 預設的初始容量是16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 最大容量 static final int MAXIMUM_CAPACITY = 1 << 30; // 預設的填充因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; // 當桶(bucket)上的結點數大於這個值時會轉成紅黑樹 static final int TREEIFY_THRESHOLD = 8; // 當桶(bucket)上的結點數小於這個值時樹轉連結串列 static final int UNTREEIFY_THRESHOLD = 6; // 桶中結構轉化為紅黑樹對應的table的最小大小 static final int MIN_TREEIFY_CAPACITY = 64; // 儲存元素的陣列，總是2的冪次倍 transient Node<k,v>[] table; // 存放具體元素的集 transient Set<map.entry<k,v>> entrySet; // 存放元素的個數，注意這個不等於陣列的長度。 transient int size; // 每次擴容和更改map結構的計數器 transient int modCount; // 臨界值 當實際大小(容量*填充因子)超過臨界值時，會進行擴容 int threshold; // 填充因子 final float loadFactor; }
建構函式HashMap(int,flaot)
public HashMap(int initialCapacity, float loadFactor) { // 初始容量不能小於0，否則報錯 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); // 初始容量不能大於最大值，否則為最大值 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; // 填充因子不能小於或等於0，不能為非數字 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // 初始化填充因子 this.loadFactor = loadFactor; // 初始化threshold大小 this.threshold = tableSizeFor(initialCapacity); }
tableSizeFor為取不小於capacity的最小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;
}三、HashMap類的主要方法
putVal函式（put操作的基礎函式）
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值取模得到的桶為空，則直接把新生成的節點放入該桶
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {//以下為該桶不為空的邏輯
Node<K,V> e; K k;
//判斷桶的第一個元素的key值是否相同（hash值相同，且能equals）
//如果相同，則返回當前元素（函式末尾進行統一處理）
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) {
//如果遍歷到了連結串列末端，則直接在連結串列末端插入新元素
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入之後，檢查是否達到了轉成紅黑樹結構的標準
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果在遍歷過程中，發現了key值相同，則返回當前元素（函式末尾進行統一處理）
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//處理相同元素的情況
if (e != null) { // existing mapping for key
V oldValue = e.value;
//如果onlyIfAbsent為ture，則在oldValue為空時才替換
//否則直接替換
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//修改次數+1
//map的size加1，然後判斷是否達到了threshold，否則進行擴容
//threshold由Node[] table的長度及loadFactor控制
if (++size > threshold)
resize();
//執行回撥函式
afterNodeInsertion(evict);
return null;
}
put函式
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}hash函式的作用是使元素hash值更加發散，經過hash()處理之後，hash值的高16位沒變，低16為原來的低16與高16異或的結果，即用16位來綜合了高16位和低16位的影響，這樣能提高key的發散性的主要原因是table的長度通常小於2^16，通過hash%table.length就能更發散
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}getNode函式（get操作的基礎函式）
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//如果table不為空，則再進行查詢操作
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//先檢查第一個元素是否key相同
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;
}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) {
//如果擴容之前的容量已經達到了最大值
//則只把threshold變成Integer.MAX_VALUE，即不限制map的最大size，之後不管插入多少元素也不觸發resize
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) // 初始capacity（建構函式輸入的）被設定成了threshold
newCap = oldThr;
else { // oldThr=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);
}
//處理好newThr和newCap之後，開始resize()函式的真正邏輯
threshold = newThr;//設定threshold
@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 {
// 鏈式情況，此時會把原來的鏈分成兩個鏈loHead和hiHead
//loHead儲存(e.hash & oldCap) == 0的元素
//hiHead儲存(e.hash & oldCap) != 0的元素
//擴容之後，由於新的capacity為oldCap的2倍，且它們都為2的整數冪
//對於該鏈上的元素，如果(e.hash & oldCap) == 0，則新的槽位(hash%capacity)==舊的槽位(hash%oldCap)
//否則，它們新的槽位都一樣，且都為原來的槽位後移oldCap
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;
}
}
}
}
}
return newTab;
}鏈式情況的resize()圖解：
四、對擴容的理解
擴容觸發的條件是map中的元素個數達到threshold，threshold的一般值為table.length*loadFactor
擴容的作用是提高資料訪問效率，通過擴容，元素會更分散，可以減少單個桶中元素的個數，進而減少連結串列的長度或紅黑樹的深度，進而可以提高資料的訪問效率
擴容是一個很重的操作，需要遍歷所有的元素，因此當擴容帶來的效能提升優勢不明顯時，儘量避免擴容