一、HashMap的結構
Map集合即Key-Value的集合，前面加個Hash，即散列，無序的。所以HashMap是一個用於存儲Key-Value鍵值對的無序集合，每一個鍵值對也叫做Entry。
在JDK1.8之前，HashMap采用數組+鏈表實現，即使用鏈表處理沖突，同一hash值的節點都存儲在一個鏈表里。但是當位於一個桶中的元素較多，即hash值相等的元素較多時，通過key值查找要遍歷鏈表，時間復雜度為O(N)，效率較低。因此JDK1.8中，HashMap采用數組+鏈表+紅黑樹實現，當鏈表長度超過閾值（8）時，將鏈表轉換為紅黑樹，時間復雜度為O(logN)，這樣大大減少了查找時間。
圖1 JDK1.8之前的HashMap 圖2 JDK1.8的HashMap
1、鏈表
Node是HashMap的一個內部類，實現了Map.Entry接口，本質是就是一個映射(鍵值對)。來看圖和具體代碼：
//Node是單向鏈表，它實現了Map.Entry接口 static class Node<k,v> implements Map.Entry<k,v> { final int hash;//哈希值 final K key;//key值 V value;//value值 Node<k,v> next;//鏈表中下一個節點
}
2、紅黑樹
//紅黑樹 static final class TreeNode<k,v> extends LinkedHashMap.Entry<k,v> { TreeNode<k,v> parent; //父節點 TreeNode<k,v> left; //左子樹 TreeNode<k,v> right;//右子樹 TreeNode<k,v> prev; //上一個同級節點 boolean red; //顏色屬性 }
3、位桶
transient Node<k,v>[] table;//存儲（位桶）的數組
HashMap類中有一個非常重要的字段，就是 Node[] table，即哈希桶數組，明顯它是一個Node的數組。
HashMap的基本數據結構是數組加鏈表的。HashMap數組的每一個元素不止是一個Entry對象，也是一個鏈表的頭節點。每一個Entry對象通過Next指針指向它的下一個Entry節點。當新來的Entry映射到沖突的數組位置時，只需要插入到對應的鏈表尾部即可。當鏈表長度大於8時，鏈表轉為紅黑樹，以此提高查找效率。
HashMap數組每一個元素的初始值都是Null。
二、初始化
// 默認構造函數。 HashMap() // 指定“容量大小”的構造函數 HashMap(int capacity) // 指定“容量大小”和“加載因子”的構造函數 HashMap(int capacity, float loadFactor) // 包含“子Map”的構造函數 HashMap(Map<? extends K, ? extends V> map)
/** * Constructs an empty {@code HashMap} with the specified initial * capacity and load factor. * * @param initialCapacity 初始化容量 * @param loadFactor 負載因子 * @throws IllegalArgumentException 初始化容量或者負載因子為負數的時候，拋出參數異常 */ 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;
//將容量賦值為：大於初始化容量參數，且為2的冪的最小整數 this.threshold = tableSizeFor(initialCapacity); }
三、Get和Put時發生了什么
對於HashMap，我們最常使用的是兩個方法：Get 和 Put。
首先，我們需了解一下在這個過程中，如何確定散列位置。
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
首先獲取key值的hashCode()值，然后將hashCode值右移16位，然后將右移后的值與原來的hashCode做異或運算（使得高位也可以參與hash，更大程度上減少了碰撞率），返回結果。（其中
h>>>16，在JDK1.8中，優化了高位運算的算法，使用了零擴展，無論正數還是負數，都在高位插入0）。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { ... if ((p = tab[i = (n - 1) & hash]) == null)//獲取位置 tab[i] = newNode(hash, key, value, null); ... }
在putVal源碼中，我們通過(n-1)&hash獲取該對象在hashmap中的位置。其中hash就是上面hash()函數獲得的值，其中n表示的是hash桶數組的長度，並且該長度為2的n次方，這樣(n-1)&hash就等價於hash%n。因為&運算的效率高於%運算。
hashMap的默認初始長度為16，並且每次自動擴展或是手動初始化時，長度必須是2的冪。為什么長度必須是2的冪，下面我們以值為“book”的Key來演示整個過程：
1.計算book的hash（）值，結果為十進制的3029737，二進制的101110001110101110 1001。
2.假定HashMap長度是默認的16，計算Length-1的結果為十進制的15，二進制的1111。
3.把以上兩個結果做與運算，101110001110101110 1001 & 1111 = 1001，十進制是9，所以 index=9。
長度16或者其他2的冪，Length-1的值是所有二進制位全為1，Hash算法最終得到的index結果，完全取決於hash()值的最后幾位。只要hash()本身分布均勻，Hash算法的結果就是均勻的。
假設長度取15，Length-1為14，1110，與結果的最后一位永遠為0，也就是說數組中奇數下標的位置永遠不會被put進任何值。
1、Put方法的原理
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; // 步驟①：table未初始化或者長度為0，進行擴容 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 步驟②：計算index，並對null做處理 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，用e來記錄 e = p; // 步驟④：桶中第一個元素hash值不相等，即key不相等；且為紅黑樹結點 else if (p instanceof TreeNode) // 放入樹中 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // 步驟⑤：桶中第一個元素hash值不相等，且為鏈表結點 else { for (int binCount = 0; ; ++binCount) { // 到達鏈表的尾部 if ((e = p.next) == null) { // 在尾部插入新結點 p.next = newNode(hash, key, value, null); // 結點數量達到閾值，轉化為紅黑樹 if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash); // 跳出循環 break; } // 判斷鏈表中結點的key值與插入的元素的key值是否相等 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) // 相等，跳出循環 break; // p后移，用於遍歷桶中的鏈表 p = e; } } // 表示在桶中找到key值、hash值與插入元素相等的結點 if (e != null) { // 記錄e的value V oldValue = e.value; // onlyIfAbsent為false或者舊值為null if (!onlyIfAbsent || oldValue == null) //用新值替換舊值 e.value = value; // 訪問后回調 afterNodeAccess(e); // 返回舊值 return oldValue; } } // 結構性修改 ++modCount; // 步驟⑥：實際大小大於閾值則擴容 if (++size > threshold) resize(); // 插入后回調 afterNodeInsertion(evict); return null; }
流程：
1. 根據key計算得到key.hash = (h = k.hashCode()) ^ (h >>> 16)；
2. 根據key.hash計算得到桶數組的索引index = key.hash & (table.length - 1)，這樣就找到該key的存放位置了：
① 如果該位置沒有數據，用該數據新生成一個節點保存新數據，返回null；
② 如果該位置有數據是一個紅黑樹，那么執行相應的插入 / 更新操作；
③ 如果該位置有數據是一個鏈表，分兩種情況一是該鏈表沒有這個節點，另一個是該鏈表上有這個節點，注意這里判斷的依據是key.hash是否一樣：
如果該鏈表沒有這個節點，那么采用尾插法新增節點保存新數據，返回null；如果該鏈表已經有這個節點了，那么找到該節點並更新新數據，返回老數據。
3. 如果是鏈表，加入新節點以后長度>=8，轉為紅黑樹。
如果hashMap的實際節點數>容量*負載因子，擴容。
擴容方法：
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table;//oldTab指向hash桶數組 int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) {//如果oldCap不為空的話，就是hash桶數組不為空 if (oldCap >= MAXIMUM_CAPACITY) {//如果大於最大容量了，就賦值為整數最大的閥值 threshold = Integer.MAX_VALUE; return oldTab;//返回 }//如果當前hash桶數組的長度在擴容后仍然小於最大容量 並且oldCap大於默認值16 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold 雙倍擴容閥值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];//新建hash桶數組 table = newTab;//將新數組的值復制給舊的hash桶數組 if (oldTab != null) {//進行擴容操作，復制Node對象值到新的hash桶數組 for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) {//如果舊的hash桶數組在j結點處不為空，復制給e oldTab[j] = null;//將舊的hash桶數組在j結點處設置為空，方便gc if (e.next == null)//如果e后面沒有Node結點 newTab[e.hash & (newCap - 1)] = e;//直接對e的hash值對新的數組長度求模獲得存儲位置 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;//將Node結點的next賦值給next if ((e.hash & oldCap) == 0) {//如果結點e的hash值與原hash桶數組的長度作與運算為0 if (loTail == null)//如果loTail為null loHead = e;//將e結點賦值給loHead else loTail.next = e;//否則將e賦值給loTail.next loTail = e;//然后將e復制給loTail } else {//如果結點e的hash值與原hash桶數組的長度作與運算不為0 if (hiTail == null)//如果hiTail為null hiHead = e;//將e賦值給hiHead else hiTail.next = e;//如果hiTail不為空，將e復制給hiTail.next hiTail = e;//將e復制個hiTail } } while ((e = next) != null);//直到e為空 if (loTail != null) {//如果loTail不為空 loTail.next = null;//將loTail.next設置為空 newTab[j] = loHead;//將loHead賦值給新的hash桶數組[j]處 } if (hiTail != null) {//如果hiTail不為空 hiTail.next = null;//將hiTail.next賦值為空 newTab[j + oldCap] = hiHead;//將hiHead賦值給新的hash桶數組[j+舊hash桶數組長度] } } } } } return newTab; }
①在jdk1.8中，resize方法是在hashmap中的鍵值對大於閥值時或者初始化時，就調用resize方法進行擴容；
②每次擴展的時候，都是擴展2倍；
③擴展后Node對象的位置要么在原位置，要么移動到原偏移量兩倍的位置。
2、Get方法的原理
HashMap 的查找操作比較簡單，查找步驟與原理篇介紹一致，即先定位鍵值對所在的桶的位置，然后再對鏈表或紅黑樹進行查找。通過這兩步即可完成查找，該操作相關代碼如下：
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; // 1. 定位鍵值對所在桶的位置 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { // 2. 如果 first 是 TreeNode 類型，則調用黑紅樹查找方法 if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); // 2. 對鏈表進行查找 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }
參考與整理：https://www.cnblogs.com/xiaoxi/p/7233201.html
Q1：加載因子有什么作用？
QIQI：加載因子是哈希表在其容量自動增加之前可以達到多滿的一種尺度。負載因子越大表示散列表的裝填程度越高，反之愈小。如果負載因子越大，對空間的利用更充
分，然而后果是查找效率的降低；如果負載因子太小，那么散列表的數據將過於稀疏，對空間造成嚴重浪費。系統默認負載因子為0.75。加載因子為0，臨界值永遠為0，只
有在初始化時進行擴容操作，后續不會再擴容；加載因子為1，只有在hashmap實際容量達到數組長度時才會擴容，雖然空間利用率高，但是降低查找效率。