在java編程語言中，最基本的結構就是兩種，一個是數組，另一個是模擬指針（引用），所有的數據結構都可以用這兩個基本結構來構造的。HashMap實際上是一個數組和鏈表的結合體（在數據結構中，一般稱之爲“鏈表散列”）。
什麼是數組？
Java提供了一個用於存儲相同類型元素的，固定大小的連續集合數據結構：數組。
什麼是鏈表？
鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。鏈表由一系列結點（鏈表中每一個元素稱爲結點）組成，結點可以在運行時動態生成。每個結點包括兩個部分：一個是存儲數據元素的數據域，另一個是存儲下一個結點地址的指針域。
鏈表與數組的主要區別
（1）數組的元素個數是固定的,而組成鏈表的結點個數可按需要增減；
（2）數組元素的存諸單元在數組定義時分配，鏈表結點的存儲單元在程序執行時動態向系統申請；
（3）數組中的元素順序關係由元素在數組中的位置(即下標)確定，鏈表中的結點順序關係由結點所包含的指針來體現；
（4）對於不是固定長度的列表,用可能最大長度的數組來描述，會浪費許多內存空間。
（5）對於元素的插人、刪除操作非常頻繁的列表處理場合，用數組表示列表也是不適宜的。若用鏈表實現，會使程序結構清晰，處理的方法也較爲簡便。
例如：在一個列表中間要插人一個新元素，如用數組表示列表，爲完成插入工作，插入處之後的全部元素必須向後移動一個位置空出的位置用於存儲新元素。對於在一個列表中刪除一個元素情況，爲保持數組中元素相對位置連續遞增，刪除處之後的元素都得向前移一個位置。如用鏈表實現列表.鏈表結點的插人或刪除操作不再需要移動結點，只需改變相關的結點中的後繼結點指針的值即可，與結點的實際存儲位置無關。
HashMap的數據結構
JDK環境：1.8
HsahMap實現類 繼承了 AbstractMap抽象類，並實現了Map,Cloneable,Serializable 接口 表示可以被克隆，序列化
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { // 內容... }
存儲的內容： key-value 鍵值對
數據結構：數組+鏈表(單向)+ 1.8後新增紅黑樹（當一個數組裏，鏈表長度>=(閾值-默認8)-1 的時候 會將鏈表轉化成紅黑樹（平衡））
重要參數：
- 初始容量大小（默認值）：
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;
- 鏈表轉紅黑樹閥值（鏈表中長度>=8-1 的時候會轉爲紅黑樹）
static final int TREEIFY_THRESHOLD = 8;
- 最小樹形化數組容量閥值
static final int MIN_TREEIFY_CAPACITY = 64;
源碼解析：
1、HashMap構造方法
/* 無參數 默認長度16，負載因子0.75 */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } /* 一個參數 還是調用2個帶參構造（傳入的容量,加載因子取默認值）*/ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } /* 兩個參數 */ public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) // 長度必須>=0 throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY)// 檢查傳入的容量 是否大於最大容量 1<<30 initialCapacity = MAXIMUM_CAPACITY;// 當傳入的容量 大於最大容量 1<<30的話 ，則將傳入的容量調整爲最大容量 if (loadFactor <= 0 || Float.isNaN(loadFactor)) // 加載因子必須>0 throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); // 負載容量 } /* 參數爲Map */ public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
2、帶着問題看源碼
通過解析上面的構造方法源碼，我們已經知道了“最大容量”的使用場景，接下來讓我一起去探究一下，其他幾個參數的使用場景，這裏提幾個小問題，最後我看能不呢找到答案：
- HashMap默認長度爲16（2^4）有什麼意義？
- HashMap加載因子（loadfactor）爲什麼默認是0.75？
- key的hashCode與equals方法爲什麼要重寫？
3、解析put方法
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
3.1、hash(key)
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
3.2、putVal
// 第三個參數 onlyIfAbsent 如果是 true，那麼只有在不存在該 key 時纔會進行 put 操作 // 第四個參數 evict 我們這裏不關心 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; // 第一次 put 值的時候，會觸發下面的 resize()，類似 java7 的第一次 put 也要初始化數組長度 // 第一次 resize 和後續的擴容有些不一樣，因爲這次是數組從 null 初始化到默認的 16 或自定義的初始容量 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 找到具體的數組下標，如果此位置沒有值，那麼直接初始化一下 Node 並放置在這個位置就可以了 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else {// 數組該位置有數據 Node<K,V> e; K k; // 首先，判斷該位置的第一個數據和我們要插入的數據，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) { // 插入到鏈表的最後面(Java7 是插入到鏈表的最前面) if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); // TREEIFY_THRESHOLD 爲 8，所以，如果新插入的值是鏈表中的第 9 個 // 會觸發下面的 treeifyBin，也就是將鏈表轉換爲紅黑樹 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } // 如果在該鏈表中找到了"相等"的 key(== 或 equals) if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) // 此時 break，那麼 e 爲鏈表中[與要插入的新值的 key "相等"]的 node break; p = e; } } // e!=null 說明存在舊值的key與要插入的key"相等" // 對於我們分析的put操作，下面這個 if 其實就是進行 "值覆蓋"，然後返回舊值 if (e != null) { V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; // 如果 HashMap 由於新插入這個值導致 size 已經超過了閾值，需要進行擴容 if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }
3.3、Node節點
static class Node<K,V> implements Map.Entry<K,V> { final int hash;// key hash值 final K key; V value; Node<K,V> next;// 指向下一個節點的指針 }
3.4、數組擴容：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) { //如果老容量大於最大的容量的話，則設置 最大容量爲Integer最大數值（之後不再擴容） threshold = Integer.MAX_VALUE; return oldTab; } // 將數組大小擴大一倍 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) // 新數組容量小於1 << 30，且老數組容量大於等於 1 << 4 // 將閾值擴大一倍 newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // 對應使用 new HashMap(int initialCapacity) 初始化後，第一次 put 的時候 newCap = oldThr; else {// 對應使用 new HashMap() 初始化後，第一次 put 的時候 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; // 用新的數組大小初始化新的數組 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; // 如果是初始化數組，到這裏就結束了，返回 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 { // 這塊是處理鏈表的情況， // 需要將此鏈表拆成兩個鏈表，放到新的數組中，並且保留原來的先後順序 // loHead、loTail 對應一條鏈表，hiHead、hiTail 對應另一條鏈表，代碼還是比較簡單的 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; // 第二條鏈表的新的位置是 j + oldCap，這個很好理解 newTab[j + oldCap] = hiHead; } } } } } return newTab; }
3.5、鏈表與紅黑樹互轉：treeifyBin()
final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; // 判斷capacity是否小於最小樹形化容量閾值：64 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize();// 對數組容量進行擴容 else if ((e = tab[index = (n - 1) & hash]) != null) { TreeNode<K,V> hd = null, tl = null; do { TreeNode<K,V> p = replacementTreeNode(e, null); if (tl == null) hd = p; else { p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null); if ((tab[index] = hd) != null) hd.treeify(tab); } }
現在我們做下總結，通過put的源碼解析，我們已經知道了Map重要參數的用處，那爲什麼數組的初始大小是16呢？
在HashMap中要找到某個元素，需要通過key的hash值來求得對應數組中的位置。如何提高hashMap的訪問性能，減少遍歷鏈表？
可以看到，key在數組的下標值爲：key的hashcode值，跟數組的長度-1做一次“與”運算（&）。爲什麼hashMap的數組初始化大小都是2的次方大小時，hashMap的訪問效率最高。
下面我們以8和9分別作爲key，16和15作爲數組初始大小，進行計算：
接着我們再介紹一個概念：加載因子
加載因子 = 填入表中的元素個數 / 散列表的長度
加載因子越大，填滿的元素越多，空間利用率越高，但發生衝突的機會變大了；加載因子越小，填滿的元素越少，衝突發生的機會減小，但空間浪費了更多了，而且還會提高擴容rehash操作的次數。衝突的機會越大，說明需要查找的數據還需要通過另一個途徑查找，這樣查找的成本就越高。因此，必須在“衝突的機會”與“空間利用率”之間，尋找一種平衡與折衷。
那麼爲什麼選擇了0.75作爲HashMap的加載因子呢？筆者不才，通過看源碼解釋和大佬的文章，才知道這個跟一個統計學裏很重要的原理——泊松分佈有關。
泊松分佈是統計學和概率學常見的離散概率分佈，適用於描述單位時間內隨機事件發生的次數的概率分佈。有興趣的讀者可以看看維基百科或者阮一峯老師的這篇文章：泊松分佈和指數分佈：10分鐘教程
等號的左邊，P 表示概率，N表示某種函數關係，t 表示時間，n 表示數量。等號的右邊，λ 表示事件的頻率。關於具體的分析，請移步：HashMap的加載因子爲什麼是0.75？
4、解析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; }
5、解析remove()
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)))) node = p; else if ((e = p.next) != null) { if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } // 上面代碼與get()基本一樣 // 根據查詢到的值 刪除 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) // 該node節點是首節點 tab[index] = node.next; //刪除 在數組內替換 else p.next = node.next; //node不是首節點 p是node的父節點，只需要把p的下一個節點指向到node的下一個節點即可把node從鏈表中刪除了 ++modCount; --size; afterNodeRemoval(node); return node; } } return null; }
6、總結
- 1.7採用數組+單鏈表，1.8在單鏈表超過一定長度後改成紅黑樹存儲
- 1.7擴容時需要重新計算哈希值和索引位置（resize()裏面調用transfer()），1.8並不重新計算哈希值，巧妙地採用和擴容後容量進行&操作來計算新的索引位置。（圖解jdk1.8擴容機制）
- 1.7插入元素到單鏈表中採用頭插入法，1.8採用的是尾插入法（在併發擴容的狀態下，不會造成 鏈表死循環）。