前言
原來看過1.7的hashMap底層，1.8更新後也稍微看了一下，沒有進行仔細的總結，今天總結一下1.8底層的原理。本文只討論1.8的底層原理。以下全文爲1.8版本的
HashMap 數據結構
對於HashMap的數據結構，是老生常談了，面試的時候經常會被問道。底層數據結構爲數組+鏈表+紅黑樹，存儲的是Node節點，紅黑樹是TreeNode。
進行put操作
在進行put操作的時候，會調用putVal方法進行存儲，在調用方法的時候，key會進行哈希計算。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
// 獲取隨機數，防止過多的進行哈希碰撞。
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
然後看putVal 方法做了哪些操作
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;
// i = (n - 1) & hash 進行取模運行，減少哈希衝突並且很平均的分佈在數組上
// 如果數組下座標上是null
if ((p = tab[i = (n - 1) & hash]) == null)
// 創建newNode 節點，進行存儲， 除非是紅黑樹 否則hashMap都是node節點存儲
tab[i] = newNode(hash, key, value, null);
else {
// 如果不是null
Node<K,V> e; K k;
// 如果此位置只有一個值 進行比較 hash key 如果相等
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);
// 判斷長度是不是大於等於 8-1
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果大於 轉換成紅黑樹
// 在進行轉換紅黑樹的時候，會進行判斷
// 如果HashMap中tab數組長度小於MIN_TREEIFY_CAPAITY
// 也就是小於64，不會轉換成紅黑樹，會進行擴容 調用resize()方法
// 這樣是爲了減少哈希衝突，這個特別注意
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;
}
}
// 對HashMap 的操作進行增加
++modCount;
// 判斷 增加後的數組長度是否大於臨界值 臨界值爲當前數據長的0.75
if (++size > threshold)
// 進行擴容
resize();
afterNodeInsertion(evict);
return null;
}
HashMap數組中存儲的節點是node，如果轉換成紅黑樹，節點就是TreeNode，可以自己看一看這兩個節點。然後來到主要的方法resize()。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;
}
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;
// 獲取下座標上的節點數據拷貝 判斷是否爲null
if ((e = oldTab[j]) != null) {
// 當前下座標節點 賦值爲null
oldTab[j] = null;
// 如果此節點就一個值，進行新數組長度的取模運算，放到新的數組節點上
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 判斷此節點是不是紅黑樹
else if (e instanceof TreeNode)
// 進行紅黑樹節點拆分，拆分成兩顆樹
// 分別判斷兩兩顆樹長度是否小於等於6 然後進行轉換成鏈表
// 然後分別放置 前一個放到當前節點 另一個放到j+oldCap節點
((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); // 如果e節點下一個不爲null 繼續循環
// 判斷不爲null
if (loTail != null) {
// 說明 最開始 loTail和loHead是同一個節點 開始節點
// 然後循環到最後 loHead還是開始節點
// 在循環中 loTail 不斷把新節點放置到前一個節點的下一個
// 然後把本身賦值爲新節點
// 這樣循環完 loTail就是最後一個節點 loHead 就是頭節點
// 把最後節點的下一個節點置null
loTail.next = null;
// 把當前鏈表防止到j位置上
newTab[j] = loHead;
}
if (hiTail != null) {
// 同上原理
hiTail.next = null;
// 把當前鏈表放置到新數組的 j+oldCap 的位置上
newTab[j + oldCap] = hiHead;
}
}
}
}
}
// 返回樹
return newTab;
}
以上就是put 操作的過程。由此可知
1. 如果不進行put操作，HashMap底層不會進行創建數組。put後進行初始化數組，默認初始化數組長度是16，擴容值爲當前數組長度的0.75。
（如果指定了長度，那麼擴容後，數組長度也會是2的n次方，這樣是爲了減少哈希碰撞。）
2. 鏈表長度如果大於等於7,（不是8），會進行轉換紅黑樹操作。在紅黑樹轉換方法裏，還會進行判斷數組長度是否大於64，如果不大於，不轉換紅黑樹，進行擴容操作。否則進行轉換。（爲了減少哈希衝突）
3. 每次擴容，會進行當前數組長度一倍的擴容，擴容值也進行一倍的增加。
get操作就不進行講解，就是通過key進行哈希，計算在數組的位置，然後如果是鏈表，在鏈表裏遍歷查找。如果是紅黑樹，在紅黑樹裏遍歷查找。
HashMap 爲啥線程不安全
HashMap線程原因是會丟失數據，不會進行死循環。（也有可能是我測試的數據量太小）
具體原因是在擴容的時候。每次擴容，都會把當前節點拷貝出來，然後置null。如果A線程把節點數據獲取，然後置null；B線程就會獲取null數據，處理下一個位置的數據，不管是哪個線程先完成擴容，都會丟失一部分數據。
而且不管是紅黑樹還是鏈表，都會拆分成兩個，兩個線程同時拆分，同時賦值，也會造成後一個線程會把前一個線程的數據給覆蓋掉。
以上就是對HashMap的總結，如果有問題可以一起討論。