概念
HashMap是Java Collections Framework中Map集合的一種實現。HashMap提供了一種簡單實用的資料儲存和讀取方式。Map介面不同於List介面，屬於集合框架的另一條支線，Map提供了鍵值對K-V資料儲存模型，底層則是通過Hash表儲存。
本文分析基於JDK1.8。
類結構
HashMap實現了Map介面，Map介面設定一系列操作Map集合的方法，如：put、get、remove...等方法，而HashMap也針對此有其自身對應的實現。
HashMap繼承AbstractMap類。AbstractMap類對於Map介面做了基礎的實現，實現了containsKey、containsValue...等方法。
類成員
建構函式
HashMap提供四種建構函式。最為基礎是如下這種：
HashMap(int initialCapacity, float loadFactor)
public HashMap(int initialCapacity, float loadFactor) {
...
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}複製程式碼HashMap(int initialCapacity, float loadFactor)是最基礎的建構函式。該建構函式提供兩個引數initialCapacity(初始大小)、loadFactor(載入因子)。
initialCapacity預設值是16 (1 << 4),最大值是1073 741 824(1 << 30)，且大小必須是小於最大值的2的冪次方；loadFactor預設值是0.75，作用是擴容時使用；
初始化的過程中將傳入的引數loadFactor賦值給this.loadFactor，然後呼叫tableSizeFor(initialCapacity)方法將處理的結果值賦值給this.threshold;
threshold是HashMap判斷size是否需要擴容的閾值。這裡呼叫tableSizeFor(initialCapacity)來設定threshold;
tableSizeFor有啥用？
先丟擲答案：tableSizeFor方法保證函式返回值是大於等於給定引數initialCapacity最小的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;
}複製程式碼可以看出該方法是一系列的二進位制位操作。先說明 |=的作用：a |= b 等同於 a = a|b。逐行分析tableSizeFor方法：
int n = cap - 1- 給定的
cap減1，是為了避免引數cap本來就是2的冪次方，這樣一來，經過後續的未操作的，cap將會變成2 * cap,是不符合我們預期的。
- 給定的
n |= n >>> 1n >>> 1，n無符號右移1位，即n二進位制最高位的1右移一位；n | (n >>> 1)，導致的結果是n二進位制的高2位值為1;目前
n的高1~2位均為1。
n |= n >>> 2n繼續無符號右移2位。n | (n >>> 2)，導致n二進位制表示高3~4位經過運算值均為1；目前
n的高1~4位均為1。
n |= n >>> 4n繼續無符號右移4位。n | (n >>> 4)，導致n二進位制表示高5~8位經過運算值均為1；目前
n的高1~8位均為1。
n |= n >>> 8n繼續無符號右移8位。n | (n >>> 8)，導致n二進位制表示高9~16位經過運算值均為1；目前
n的高1~16位均為1。
n |= n >>> 16n繼續無符號右移16位。n | (n >>> 16)，導致n二進位制表示高17~32位經過運算值均為1；目前
n的高1~32位均為1。
可以看出，無論給定cap(cap < MAXIMUM_CAPACITY )的值是多少，經過以上運算，其值的二進位制所有位都會是1。再將其加1，這時候這個值一定是2的冪次方。當然如果經過運算值大於MAXIMUM_CAPACITY，直接選用MAXIMUM_CAPACITY。
這裡可以舉個栗子，假設給定的cap的值為20。
int n = cap - 1;—>n = 19(二進位制表示：0001 0011)n |= n >>> 1;
n -> 0001 0011
n >>> 1 -> 0000 1001
n |= n >>> 1 -> 0001 1011複製程式碼n |= n >>> 2;
n -> 0001 1011
n >>> 2 -> 0000 1101
n |= n >>> 2 -> 0001 1111複製程式碼此時n所有位均為1，後續的位操作均不再改變n的值。
...
n + 1 -> 0010 0000 (32)複製程式碼最終，tableSizeFor(20)的結果為32(2^5)。
至此tableSizeFor如何保證cap為2的冪次方已經顯而易見了。那麼問題來了，為什麼cap要保持為2的冪次方？
為什麼cap要保持為2的冪次方？
cap要保持為2的冪次方主要原因是HashMap中資料儲存有關。
在JDK1.8中，HashMap中key的Hash值由Hash(key)方法（後面會詳細分析）計算得來。
HashMap中儲存資料table的index是由key的Hash值決定的。在HashMap儲存資料的時候，我們期望資料能夠均勻分佈，以避免雜湊衝突。自然而然我們就會想到去用%取餘的操作來實現我們這一構想。
這裡要了解到一個知識：取餘(%)操作中如果除數是2的冪次方則等同於與其除數減一的與(&)操作。
這也就解釋了為啥一定要求cap要為2的冪次方。再來看看table的index的計算規則：
index = e.hash & (newCap - 1)
等同於：
index = e.hash % newCap複製程式碼採用二進位制位操作&，相對於%，能夠提高運算效率，這就是要求cap的值被要求為2冪次方的原因。
Node 類
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}複製程式碼Node<K,V> 類是HashMap中的靜態內部類，實現Map.Entry<K,V>介面。 定義了key鍵、value值、next節點，也就是說元素之間構成了單向連結串列。
Node[] table
Node<K,V>[] table是HashMap底層儲存的資料結構，是一個Node陣列。上面得知Node類為元素維護了一個單向連結串列。
至此，HashMap儲存的資料結構也就很清晰了：維護了一個陣列，每個陣列又維護了一個單向連結串列。之所以這麼設計，考慮到遇到雜湊衝突的時候，同index的value值就用單向連結串列來維護。
hash(K,V) 方法
HashMap中table的index是由Key的雜湊值決定的。HashMap並沒有直接使用key的hashcode()，而是經過如下的運算：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}複製程式碼而上面我們提到index的運算規則是e.hash & (newCap - 1)。由於newCap是2的冪次方，那麼newCap - 1的高位應該全部為0。如果e.hash值只用自身的hashcode的話，那麼index只會和e.hash低位做&操作。這樣一來，index的值就只有低位參與運算，高位毫無存在感，從而會帶來雜湊衝突的風險。所以在計算key的雜湊值的時候，用其自身hashcode值與其低16位做異或操作。這也就讓高位參與到index的計算中來了，即降低了雜湊衝突的風險又不會帶來太大的效能問題。
put(K,V) 方法
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)
// tab 為空,呼叫resize()初始化tab。
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// key沒有被佔用的情況下,將value封裝為Node並賦值
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))))
// 如果key相同,p賦值給e
e = p;
else if (p instanceof TreeNode)
// 如果p是紅黑樹型別，呼叫putTreeVal方式賦值
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// index 相同的情況下
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 如果p的next為空，將新的value值新增至連結串列後面
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果連結串列長度大於8，連結串列轉化為紅黑樹，執行插入
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;
//根據規則選擇是否覆蓋value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
// size大於載入因子,擴容
resize();
afterNodeInsertion(evict);
return null;
}複製程式碼在建構函式中最多也只是設定了initialCapacity、loadFactor的值，並沒有初始化table，table的初始化工作是在put方法中進行的。
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) {
// table已存在
if (oldCap >= MAXIMUM_CAPACITY) {
// oldCap大於MAXIMUM_CAPACITY,threshold設定為int的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//newCap設定為oldCap的2倍並小於MAXIMUM_CAPACITY，且大於預設值, 新的threshold增加為原來的2倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// threshold>0, 將threshold設定為newCap,所以要用tableSizeFor方法保證threshold是2的冪次方
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 預設初始化，cap為16，threshold為12。
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// newThr為0，newThr = newCap * 0.75
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 新生成一個table陣列
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// oldTab 複製到 newTab
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)
// e為紅黑樹的情況
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
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;
}複製程式碼remove(key) 方法 & remove(key, value) 方法
remove(key) 方法 和 remove(key, 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))))
// index 元素只有一個元素
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
// index處是一個紅黑樹
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// index處是一個連結串列，遍歷連結串列返回node
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;
}複製程式碼