HashMap概述
HashMap實現了Map介面，我們常用HashMap進行put和get操作讀存鍵值對資料。下面介紹基於jdk1.8深入瞭解HashMap底層原理。
HashMap資料結構
HashMap實際是一種“陣列+連結串列”資料結構。在put操作中，通過內部定義演算法尋止找到陣列下標，將資料直接放入此陣列元素中，若通過演算法得到的該陣列元素已經有了元素（俗稱hash衝突，連結串列結構出現的實際意義也就是為了解決hash衝突的問題）。將會把這個陣列元素上的連結串列進行遍歷，將新的資料放到連結串列末尾。
儲存資料的物件
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}複製程式碼我們從jdk1.8原始碼看出儲存物件Node實際是實現Map.Entry物件介面。
hash：通過hash演算法的出來的值。hash值的演算法我們看下HashMap原始碼的實現
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}複製程式碼不同的資料型別的hashCode計算的方法不一樣，我們看下String和Integer兩種資料型別的hashCode演算法
String.hashCode()
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}複製程式碼通過將字串轉換成char陣列，使用公式s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]進行計算得出最後的值。val[i]值是對應字元的ASCII值.在看到這裡的時候，這裡為什麼使用了一個31作為相乘因子（能為啥，還不是為了效能考慮，那為什麼使用31效能能得到優化呢），這裡可以延伸討論。
Integer.hashCode()
public static int hashCode(int value) {
return value;
}複製程式碼直接返回值.
key：儲存資料的key
value：儲存資料的value
next：下一個資料，出現雜湊衝突時，該陣列元素會出現連結串列結構，會使用next指向連結串列中下一個元素物件
連結串列結構導致的問題
通過雜湊演算法從尋止上能夠高效的找到對應的下標，但是隨著資料的增長，雜湊衝突碰撞過多。在尋找資料上，找到該來連結串列，會通過遍歷在尋找對應資料，如此將會使得get資料效率越來越低。在jdk1.8中，連結串列元素數量大於等於8將會重組該連結串列結構形成為“紅黑樹結構”，這種結構使得在hash衝突碰撞過多情況下，get效率比連結串列的效率高很多。
HashMap put儲存資料是如何處理的
HashMap有幾個重要的變數
transient Node<K,V>[] table;
int threshold;
final float loadFactor;
int modCount;
int size;複製程式碼table：儲存陣列的變數，初始長度為16通過原始碼看出在第一次進行resize擴容（java是靜態語言，在定義陣列初始化時，需要定義陣列的長度，在map資料增長後，內部機制會進行重新定義一個陣列做到擴容的操作）初始化時，會將預設靜態變數
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;複製程式碼賦給陣列長度進行初始化。
loadFactor：資料的增長因子，預設為0.75。在進行擴容操作會使用到。
threshold：允許的最大的儲存的元素數量，通過length陣列長度*loadFactor增長因子得出
modCount：記錄內部結構發生變化的次數，put操作（覆蓋值不計算）以及其他...
size：實際儲存的元素數量
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;
// 判斷陣列是否為空，長度是否為0，是則進行擴容陣列初始化
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;
// 找到陣列元素，hash相等同時key相等，則直接覆蓋
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 該陣列元素在連結串列長度>8後形成紅黑樹結構的物件
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 該陣列元素hash相等，key不等，同時連結串列長度<8.進行遍歷尋找元素，有就覆蓋無則新建
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
// 連結串列長度>=8 結構轉為 紅黑樹
treeifyBin(tab, hash);
break;
}
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;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}複製程式碼便於理解，花了一下圖。如下圖示（畫工不是很好，見諒見諒）
下圖是一位大神級別畫的圖，引用一下便於理解
1、首選判斷table是否為空，陣列長度為空，將會進行第一次初始化。（在例項化HashMap是，並不會進行初始化陣列）
2、進行第一次resize()擴容之後。開始通過hash演算法定址找到陣列下標。若陣列元素為空，則建立新的陣列元素。若陣列元素不為空，同時hash相等，key不相等，同時不是TreeNode資料物件，將遍歷該陣列元素下的連結串列元素。若找到對應的元素，則覆蓋，如果沒有找到，就新建元素，放入上一個連結串列元素的next中，在放入元素之後，如果條件滿足"連結串列元素長度>8"，則將該連結串列結構轉為"紅黑樹結構"。
3、找到對應的陣列元素或者連結串列元素，同時建立新的資料元素或者覆蓋元素之後。如果條件滿足元素大小size>允許的最大元素數量threshold，則再一次進行擴容操作。每次擴容操作，新的陣列大小將是原始的陣列長度的兩倍。
4、put操作完成。
呼叫put方法示例
下面通過使用例子介紹這個過程
HashMap<Integer, String> hashMap = new HashMap<Integer, String>(4, 0.75f);// 1
int a1 = 1;
int a2 = 2;
int a3 = 5;
System.out.println(String.valueOf(a1&3) + " " + String.valueOf(a2&3)+ " " + String.valueOf(a3&3));// 1 2 1 陣列下標
hashMap.put(a1, "1");// 2
hashMap.put(a2, "2");// 3
hashMap.put(a3, "5");// 4複製程式碼1、建立了一個HashMap物件，初始化initialCapacity為4，增長因子為0.75。threshold初始化為4
2、進行了第一次put，因為table為空，進行了第一次resize()擴容操作，陣列進行初始化，預設為16. threshold變為3。同時通過hash演算法（陣列長度n-1 & hash）即為1。
3、第二次put操作，同時獲取陣列下標為2，此時陣列下標為2當前沒有陣列元素，則直接建立資料元素放入
4、第三次put操作，得到陣列下標為1已經有了一個陣列元素。同時我們知道儲存資料的Node物件中又一個next，則新的此時的資料元素放入上一個連結串列中next為空的Node中的next中。
形成了如下圖的資料結構
結論：通過hash演算法進行計算的出來的陣列下標，有一定概率會導致hash衝突，那在一個陣列元素中，存在hash值一樣的key，key卻不相等。為了解決這一個hash衝突問題，使用了連結串列結構進行處理。
HashMap擴容resize()
java是靜態方法，在陣列進行初始化時，必須給一個陣列長度。HashMap定義預設的陣列長度為16。條件滿足元素size>允許的最大元素數量threshold。則進行擴容。一般來說，在put操作中，HashMap至少進行了一次擴容（第一次為初始化）。
我們在原有的示例加入如下
int a4 = 6;
hashMap.put(a4, "6");複製程式碼形成了新的結構，如下圖
放入了2:2的next中，此時size=4,threshold>3，條件滿足size>threshold，進行擴容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) {
// 超過最大限制，不進行擴容
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
// 遍歷連結串列
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;
}
// 原索引＋oldCap
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;
}複製程式碼在put6:6之後，直接就執行了擴容，新陣列長度為8，新的結構如下
在新的結構中，將原始的陣列下標為1和2連結串列元素均勻分佈新陣列的其他陣列元素中。此間擴容的變化的過程如下
老陣列長度為4，通過演算法得出資料的下標1:1為1,5:5為1,2:2和6:6為2
1(1:1 == > 5:5)
2(2:2 == > 6:6)複製程式碼在進行擴容操作是，陣列元素連結串列中的第一個陣列下標不會產生變化，在遍歷連結串列其他元素中通過演算法"e.hash & oldCap"!=0則將連結串列元素放入新資料陣列下標為[原始資料下標+原始資料長度]
再次引用大神的圖，便於理解擴容的資料移動變化
在擴容操作中，因無需重新計算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) {
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;
}複製程式碼get方法比較簡單，基本流程為通過key的hashCode和定址演算法得到陣列下標，若陣列元素中的key和hash相等，則直接返回。若不想等，同時存在連結串列元素，則遍歷連結串列元素進行匹配。由於1.8引用了紅黑樹結構，在連結串列元素過多時，1.8的實現將比1.7在get和put操作上效率高上很多。
在本文中，未詳細說明，定址的演算法的優越性和紅黑樹的優點。這裡不進行討論。
下節，研究和證明HashMap為何是執行緒非安全的
【我是碼農，也不是碼農】軟體 – 注重思想與邏輯