概覽
HashMap在Map.Entry靜態內部類實現中存儲key-value對。HashMap使用哈希算法，在put和get方法中，它使用hashCode()和equals()方法。當我們通過傳遞key-value對調用put方法的時候，HashMap使用Key hashCode()和哈希算法來找出存儲key-value對的索引。Entry存儲在LinkedList中，所以如果存在entry，它使用equals()方法來檢查傳遞的key是否已經存在，如果存在，它會覆蓋value，如果不存在，它會創建一個新的entry然後保存。當我們通過傳遞key調用get方法時，它再次使用hashCode()來找到數組中的索引，然後使用equals()方法找出正確的Entry，然後返回它的值。
其它關於HashMap比較重要的問題是容量、負荷係數和閥值調整。HashMap默認的初始容量是32，負荷係數是0.75。閥值是爲負荷係數乘以容量，無論何時我們嘗試添加一個entry，如果map的大小比閥值大的時候，HashMap會對map的內容進行重新哈希，且使用更大的容量。容量總是2的冪，所以如果你知道你需要存儲大量的key-value對，比如緩存從數據庫裏面拉取的數據，使用正確的容量和負荷係數對HashMap進行初始化是個不錯的做法。
1.JDK1.8 引入紅黑樹
在 JDK1.6，JDK1.7 中，HashMap 採用位桶 + 鏈表實現，即使用鏈表處理衝突，同一 hash 值的鏈表都存儲在一個鏈表裏。但是當位於一個桶中的元素較多，即 hash 值相等的元素較多時，通過 key 值依次查找的效率較低。而 JDK1.8 中，HashMap 採用位桶 + 鏈表 + 紅黑樹實現，當鏈表長度超過閾值（8）時，將鏈表轉換爲紅黑樹，這樣大大減少了查找時間。
2.HashMap 的實現原理：
首先有一個每個元素都是鏈表（可能表述不準確）的數組，當添加一個元素（key-value）時，就首先計算元素 key 的 hash 值，以此確定插入數組中的位置，但是可能存在同一 hash 值的元素已經被放在數組同一位置了，這時就添加到同一 hash 值的元素的後面，他們在數組的同一位置，但是形成了鏈表，同一各鏈表上的 Hash 值是相同的，所以說數組存放的是鏈表。而當鏈表長度太長時，鏈表就轉換爲紅黑樹，這樣大大提高了查找的效率。
當鏈表數組的容量超過初始容量的 0.75 時，再散列將鏈表數組擴大 2 倍，把原鏈表數組的搬移到新的數組中
3.數據結構
- 位桶數組
transient Node<k,v>[] table;//存儲（位桶）的數組</k,v>
- 數組元素 Node<K,V> 實現了 Entry 接口
//Node是單向鏈表，它實現了Map.Entry接口
static class Node<k,v> implements Map.Entry<k,v>
- 紅黑樹
//紅黑樹
static final class TreeNode<k,v> extends LinkedHashMap.Entry<k,v>
4.數據域
加載因子（默認 0.75）：爲什麼需要使用加載因子，爲什麼需要擴容呢？因爲如果填充比很大，說明利用的空間很多，如果一直不進行擴容的話，鏈表就會越來越長，這樣查找的效率很低，因爲鏈表的長度很大（當然最新版本使用了紅黑樹後會改進很多），擴容之後，將原來鏈表數組的每一個鏈表分成奇偶兩個子鏈表分別掛在新鏈表數組的散列位置，這樣就減少了每個鏈表的長度，增加查找效率
HashMap 本來是以空間換時間，所以填充比沒必要太大。但是填充比太小又會導致空間浪費。如果關注內存，填充比可以稍大，如果主要關注查找性能，填充比可以稍小。
public class HashMap<k,v> extends AbstractMap<k,v>
implements Map<k,v>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
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;//填充比
//當add一個元素到某個位桶，其鏈表長度達到8時將鏈表轉換爲紅黑樹
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
transient Node<k,v>[] table;//存儲元素的數組
transient Set<map.entry<k,v>> entrySet;
transient int size;//存放元素的個數
transient int modCount;//被修改的次數fast-fail機制
int threshold;//臨界值 當實際大小(容量*填充比)超過臨界值時，會進行擴容
final float loadFactor;//填充比（......後面略）
5.HashMap如何取值get
get (key) 方法時獲取 key 的 hash 值，計算 hash&(n-1) 得到在鏈表數組中的位置 first=tab [hash&(n-1)], 先判斷 first 的 key 是否與參數 key 相等，不等就遍歷後面的鏈表找到相同的 key 值返回對應的 Value 值即可
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab;//Entry對象數組
Node<K,V> first,e; //在tab數組中經過散列的第一個位置
int n;
K k;
/*找到插入的第一個Node，方法是hash值和n-1相與，tab[(n - 1) & hash]*/
//也就是說在一條鏈上的hash值相同的
if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {
/*檢查第一個Node是不是要找的Node*/
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))//判斷條件是hash值要相同，key值要相同
return first;
/*檢查first後面的node*/
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
/*遍歷後面的鏈表，找到key值和hash值都相同的Node*/
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
6.HashMap如何存值put
1，判斷鍵值對數組 tab [] 是否爲空或爲 null，否則以默認大小 resize ()；
2，根據鍵值 key 計算 hash 值得到插入的數組索引 i，如果 tab [i]==null，直接新建節點添加，否則轉入 3
3，判斷當前數組中處理 hash 衝突的方式爲鏈表還是紅黑樹 (check 第一個節點類型即可), 分別處理
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;
/*如果table的在（n-1）&hash的值是空，就新建一個節點插入在該位置*/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
/*表示有衝突,開始處理衝突*/
else {
Node<K,V> e;
K k;
/*檢查第一個Node，p是不是要找的值*/
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個，看是否需要改變衝突節點的存儲結構，
//treeifyBin首先判斷當前hashMap的長度，如果不足64，只進行
//resize，擴容table，如果達到64，那麼將衝突的存儲結構爲紅黑樹
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;
}
}
/*就是鏈表上有相同的key值*/
if (e != null) { // existing mapping for key，就是key的Value存在
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//返回存在的Value值
}
}
++modCount;
/*如果當前大小大於門限，門限原本是初始容量*0.75*/
if (++size > threshold)
resize();//擴容兩倍
afterNodeInsertion(evict);
return null;
}
注：如果衝突的節點數已經達到8個，看是否需要改變衝突節點的存儲結構，treeifyBin首先判斷當前hashMap的長度，如果不足64，只進行
resize，擴容table，如果達到64，那麼將衝突的存儲結構爲紅黑樹
7.HashMap的擴容機制resize
構造 hash 表時，如果不指明初始大小，默認大小爲 16（即 Node 數組大小 16），如果 Node [] 數組中的元素達到（填充比 * Node.length）重新調整 HashMap 大小 變爲原來 2 倍大小，擴容很耗時
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
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;
}
/*把新表的長度設置爲舊錶長度的兩倍，newCap=2*oldCap*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
/*把新表的門限設置爲舊錶門限的兩倍，newThr=oldThr*2*/
newThr = oldThr << 1; // double threshold
}
/*如果舊錶的長度的是0，就是說第一次初始化表*/
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;//把新表賦值給table
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)//說明這個node沒有鏈表直接放在新表的e.hash & (newCap - 1)位置
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
/*如果e後邊有鏈表,到這裏表示e後面帶着個單鏈表，需要遍歷單鏈表，將每個結點重*/
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;//記錄下一個結點
//新表是舊錶的兩倍容量，實例上就把單鏈表拆分爲兩隊，
//e.hash&oldCap爲偶數一隊，e.hash&oldCap爲奇數一對
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) {//lo隊不爲null，放在新表原位置
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {//hi隊不爲null，放在新表j+oldCap位置
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
8.HashMap引入紅黑樹
希碰撞會對 hashMap 的性能帶來災難性的影響。如果多個 hashCode () 的值落到同一個桶內的時候，這些值是存儲到一個鏈表中的。最壞的情況下，所有的 key 都映射到同一個桶中，這樣 hashmap 就退化成了一個鏈表 —— 查找時間從 O (1) 到 O (n)。
紅黑樹是這樣解決的：
如果某個桶中的記錄過大的話（當前是 TREEIFY_THRESHOLD = 8），HashMap 會動態的使用一個專門的 treemap 實現來替換掉它。這樣做的結果會更好，是 O (logn)，而不是糟糕的 O (n)。
在 java jdk8 中對 HashMap 的源碼進行了優化，在 jdk7 中，HashMap 處理 “碰撞” 的時候，都是採用鏈表來存儲，當碰撞的結點很多時，查詢時間是 O（n）。
在 jdk8 中，HashMap 處理 “碰撞” 增加了紅黑樹這種數據結構，當碰撞結點較少時，採用鏈表存儲，當較大時（>8 個），採用紅黑樹（特點是查詢時間是 O（logn））存儲（有一個閥值控制，大於閥值 (8 個)，將鏈表存儲轉換成紅黑樹存儲）