原文：https://www.cnblogs.com/younghao/p/8333795.html
為什么要設計散列這種數據結構呢？在現實世界中，實體之間可能存在着映射關系（key-value），比如一個訂單可能對應多個商品，對應一個配送站點。散列正是對這種映射關系的邏輯結構的表達，但同時，作為一種數據結構，在計算機中該如何實現存儲呢？
本節將重點從散列的邏輯結構和存儲結構出發，對上述涉及的散列原理及應用場景作出說明：
- 散列函數與散列表
- Java中的散列實例
- 保證最壞情況時間復雜度
一、散列函數與散列表
1.1 散列函數
散列函數（Hash Function）是一種從任何一種數據中創建小的數字“指紋”的方法。一般來講，散列函數的輸入包含較多的信息（比如SHA-2最高接受(264-1)/8長度的字節字符串），經過散列算法后，映射為一個更小空間的散列值（通常為格式固定的字母和數字組成的字符串），其過程如下圖所示。
散列函數在加密、校驗等安全領域有廣泛的應用，比如，SHA（Secure Hash Algorithm）家族在TLS和SSL、PGP、SSH、S/MIME和IPsec等安全協議中的廣泛應用，MD5（Message-Digest Algorithm 5）在文件下載中校驗的應用，此外，散列表是散列函數的一個主要應用。
1.2 散列表
散列表的核心優勢是能夠按照關鍵字快速存取數據記錄，其插入、查找和刪除的平均時間復雜度為O(1)。在實現上，將關鍵字通過散列函數映射為一個數組的地址，而將數據記錄存儲在該數組單元中。對同一散列函數，要求兩個散列值如果是不相同的，那么這兩個散列值的原始輸入也是不相同的；但兩個散列值如果是相同的，卻並不能確定兩個輸入值是相同的，如果不同的輸入得到的相同的散列值，這種情況就是“散列沖突”。一種常用的散列表結構如下圖所示。
從圖中可以看出，散列表的核心結構為：數組+鏈表。直接存儲散列數據的結構稱為節點，節點包含散列值、關鍵字、數據域和指針域（指向下一個節點）。如圖中的節點13，其關鍵字經過散列函數得出在數組中的下標為0，數據域為13，指針域指向下一個節點6。節點在數組中存儲的地址稱為槽位，比如散列沖突時，37、62、52和92經過散列函數計算得出的槽位均為14。
那么，為了減少散列沖突，使數據元素在數組中均勻分布，在散列表的實現中，選擇合適的散列函數至關重要，常見的散列函數包括直接尋址法、數字分析法、平方取中法、折疊法、隨機數法及除留余數法等，其中，直接尋址法通過取key值或者key值的某個線性函數值作為散列地址，即hash(k)=k或者hash(k)=a*k+b；除留余數法通過取關鍵字被某個不大於散列表表長m的數p除后所得的余數為散列地址。即 hash(k)= k mod p, p < m。在JDK中常用除留余數法作為散列函數。
1.3 解決散列沖突
一個好的散列函數要求盡量減少散列沖突且計算簡單，但沖突總是無法避免的，遇到沖突有哪些解決辦法呢？
- 鏈地址法。上圖中解決散列沖突的方法就是鏈地址法，即將散列到同一槽位的元素通過鏈表進行保存。JDK中就是使用這種方法來解決散列沖突的。
- 開放定址法。假定散列函數為H，經過散列函數運算H(key)后得到散列值為Hi，過程如下：
Hi =(H(key) + di) % m，其中i = 1，2，…，n.
常用的開放定址法包括線性探測法和平方探測法。其區別在於di：
線程探測法：di = 1，2，3，…，m-1.
平方探測法：di =12，-12，22，-22，…，k2，-k2 ( k<=m/2 ). - 再散列。顧名思義，在散列沖突發生后，采用新的散列函數對key進行重新散列。假定散列函數分別為RH1，RH2……，散列過程如下：
Hi=RH1（key）， 其中 i=1，2，…，k
當散列值Hi=RH1（key）發生沖突時，再計算Hi=RH2（key）……，直到不沖突為止。
二、Java中的散列實例
Java中的散列實例包括HashSet、HashMap、LinkedHashSet、LinkedHashMap以及HashTable等，其中，HashSet和LinkedHashSet是基於HashMap和LinkedHashMap封裝實現的，HashTable相比於HashMap僅增加了對同步操作的支持，並且在Java 5以后建議使用ConcurrentHashMap代替HashTable（第三章會講到ConcurrentHashMap），因此本節將重點對HashMap和LinkedHashMap的實現原理進行說明。
2.1 HashMap實現原理
2.1.1 HashMap的散列函數
《Effective Java》中指出：覆蓋equals時必須覆蓋hashCode，hashCode在基於散列的集合中有重要的作用，因為HashMap的hash方法需要根據Key對象的hashCode來計算散列值的。
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }上文提到，Java中采用除留余數法作為散列函數，假定n為數組的長度，則槽位的計算方法為hash % n。但計算hash值屬於高頻操作，而取余運算較為耗時，因此在Java中采用另外一種實現：(n - 1) & hash。使得hash % n 等於 (n - 1) & hash的前提是n = 2 m（m 為任意正整數），HashMap中數組長度要求必須為2的m次冪，擴容時也是按照2的倍數進行擴展，初始長度為1 << 4 == 2 4 == 16，最大值為 1 << 30 == 2 30 == 1073741824。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 初始值 static final int MAXIMUM_CAPACITY = 1 << 30; // 最大值下面以Key='A'為例說明HashMap中散列的計算過程：
首先，'A'作為字符串，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; }String計算hashcode的算法是遍歷String串中的每個字符，應用公式 h = 31 * h + val[i] （val[i]表示第i個字符的ASCII碼值）進行計算。計算hashcode是一個比較耗時的操作，因此，String采用了閃存散列代碼的方法，hashcode計算完成后會保存在hash域中，由於String是final類型的，所以再次調用時判斷如果hash值不為0則直接返回保存的hash值。
HashMap的hash方法將hashcode與hashcode>>>16進行異或，即將hashcode的高16位與低16位進行異或，然后與(n-1)進行位與操作得到該Key值在數組中的下標。在HashMap中，數組長度n始終為2的次方，比如初始長度16，n-1=15(0000 1111)，那么在計算數組下標時，實際上只有低四位是有用的，這可能會使得散列沖突加劇，所以HashMap的設計者在綜合權衡速度、作用和質量的基礎上，選擇了將hashcode的高16位與低16位進行異或得到一個綜合的信息。
2.1.2 鏈表和紅黑樹在解決散列沖突時的應用
在JDK1.8之前，Java僅采用鏈表解決散列沖突，因此，在最壞情況下，假定所有節點關鍵字的hash值都相等，則所有節點插入同一槽位，導致HashMap退化為該槽位的鏈表，查找節點的時間復雜度為O(n)。JDK1.8在解決散列沖突時引入了紅黑樹，在某槽位的鏈表長度超過限額之后，則將鏈表轉換為紅黑樹。通過上一節的描述，我們知道紅黑樹能夠保證最壞情況的操作時間復雜度為O(Log(n))，因此，使得HashMap在散列沖突時的性能有較大程度的提升。（下文中無特殊說明時，HashMap均表示JDK1.8中的實現）
下面以HashMap插入和刪除元素為例，說明鏈表和紅黑樹在解決散列沖突時的應用。HashMap中采用Node和TreeNode來分別表示鏈表和紅黑樹中存儲的節點，其定義如下：
// 鏈表節點 static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; } // 紅黑樹節點 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; } // 將鏈表節點轉換為紅黑樹節點 TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) { return new TreeNode<>(p.hash, p.key, p.value, next); }在HashMap中插入節點的流程，主要包括以下幾步：
- 根據數組是否為空（長度為0）確定是否初始化數組；
- 根據hash值計算Node在數組中的下標，根據下標判斷是否散列沖突，如果不沖突，則新建節點插入數組；
- 如果沖突並且不是同一節點，通過鏈表存儲新的節點；
- 如果沖突導致鏈表過長，就把鏈表轉換為紅黑樹；
- 判斷節點是否已經存在，如果存在就替換該節點對應的舊值，自增HashMap的修改數modCount；
- 判斷是否需要擴容（超過加載因子loadFactor * 數組容量），如果需要就調用resize方法擴容。
用流程圖表示如下：
可以看出，鏈表和紅黑樹的轉換發生在插入節點導致鏈表過長時，下面是HashMap中putVal方法的部分實現。
Node<K,V> e; K k;
// 待插入節點已存在 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); // 判斷是否需要將鏈表轉化為紅黑樹 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } // 待插入節點已存在 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } }上述代碼中，p初始為tab[i = (n - 1) & hash]，即待插入節點對應槽位處鏈表的首節點，e表示已存在的待插入節點。首先判斷待插入節點是否已存在，其次判斷是否已經需要插入紅黑樹節點，最后遍歷該鏈表，找到合適的插入位置，完成后判斷鏈表長度，如果超過TREEIFY_THRESHOLD（8），則調用treeifyBin方法。在treeifyBin方法中，會判斷HashMap數組長度，如果小於MIN_TREEIFY_CAPACITY（64），則先進行擴容。否則將Node鏈轉換為TreeNode鏈，最后調用TreeNode的treeify方法生產紅黑樹。
TreeNode繼承自LinkedHashMap.Entry，而LinkedHashMap.Entry又繼承自HashMap.Node，所以TreeNode具有Node的所有屬性。TreeNode是HashMap的靜態內部類，其內部定義一系列方法用於保證紅黑樹的性質，包括轉換樹（treeify）、左旋（rotateLeft）、右旋（rotateRight），刪除后平衡（balanceDeletion）、插入后平衡（balanceInsertion）等。
同樣，在HashMap中刪除元素也涉及到鏈表和紅黑樹的轉換，HashMap的remove方法主要分為兩步：1）找到待刪除的節點；2）刪除節點。
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); } } // 刪除節點 if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { // 如果待刪除節點為紅黑樹節點，則調用TreeNode的刪除節點方法 if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); // 刪除該槽位的首節點 else if (node == p) tab[index] = node.next; // 刪除鏈表中的節點 else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } }值得關注的是刪除紅黑樹節點的removeTreeNode方法中，當紅黑樹規模較小時，則會調用untreeify方法將紅黑樹退化為鏈表，該過程與插入時鏈表轉換為紅黑樹的過程剛好相反。
2.1.3 擴容
HashMap中有三個關鍵參數控制着擴容的時機，分別是threshold、loadFactor和size，其中，threshold = loadFactor * size。threshold表示當前HashMap所能容納的節點的最大數量，超過threshold就會觸發擴容；loadFactor為加載因子，初始值為0.75f；size表示HashMap存儲節點的數組的容量，初始值為16。
擴容的實現主要分為兩步：1）根據新的容量初始化節點數組；2）將原數組中的元素重新散列至新數組。新容量總是在現有容量的兩倍，因此HashMap的容量總等於2的冪（比如初始容量16擴容后為32）。同時，新的擴容上限也增加為現有上限的兩倍。
根據新的容量初始化節點數組
// 初始引用oldTab、oldCap和oldThr Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; // 初始newCap、newThr int newCap, newThr = 0; // 原容量大於0情況的擴容 if (oldCap > 0) { // 超過HashMap的容量上限就不再繼續擴容 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } // 新容量為原容量的2倍，新的上線為原上線的2倍 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; } else if (oldThr > 0) newCap = oldThr; else { // 設置初始容量為16、初始限度為12 newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } // 計算resize的上限 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;將原數組中的元素重新散列至新數組
HashMap計算插入節點槽位的方法為：(n - 1) & hash，由於HashMap的容量總是以2的倍數遞增，所以，擴容后的容量相比於原容量在二進制表達上，只是最高位前面增加了一位，並且為1。舉個例子，容量為16，n - 1為15（0000 1111），擴容后的容量為32，n - 1為31（0001 1111），0001 1111 相比於 0000 1111 只是多了最高位的 1。因此在於hash值做位與運算時，如果hash值該位為1，則新槽位 = 原槽位 + 原容量，否則槽位不變。
// 遍歷原數組中的所有槽位 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 { 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; newTab[j + oldCap] = hiHead; } } } }2.2 LinkedHashMap實現原理
在上節已經講過，LinkedHashMap支持按照插入順序對節點排序。實際上，LinkedHashMap還支持按照訪問順序排序。排序方式是由accessOrder字段決定的，如果accessOrder為true，則按照訪問順序排序，否則按照插入順序排序。LinkedHashMap按照訪問順序排序的特征為很多算法實現提供了支持，比如Android中的LruCache（緩存策略為最近最少使用最先刪除）就是基於LinkedHashMap的訪問順序實現的，其構造方法如下：
public LruCache(int maxSize) { if (maxSize <= 0) { throw new IllegalArgumentException("maxSize <= 0"); } this.maxSize = maxSize; // accessOrder字段為true，表示按照訪問順序排序，實現最近最少訪問最先刪除 this.map = new LinkedHashMap<K, V>(0, 0.75f, true); }因此，在探討LinkedHashMap的實現原理時，將重點關注LinkedHashMap是如何實現插入順序和訪問順序的？支持LinkedHashMap保持順序的基礎在於其節點Entry類自包含了before和after域，分別指向當前節點的前節點和后節點，這類似於LinkedList實現雙向鏈表的方法。
static class Entry<K,V> extends HashMap.Node<K,V> { Entry<K,V> before, after; Entry(int hash, K key, V value, Node<K,V> next) { super(hash, key, value, next); } }Entry繼承自HashMap.Node，因此具有HashMap節點類的所有特性。比如，LinkedHashMap插入節點是通過調用HashMap的put方法實現的。而put方法又調用了newNode和afterNodeInsertion等方法，而這些方法正好是HashMap預留給LinkedHashMap用來保持順序的方法，主要包括節點的初始化等、插入節點后的調整等。
// 新建節點 Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) { return new Node<>(hash, key, value, next); } // 用鏈表節點替代紅黑樹節點 Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) { return new Node<>(p.hash, p.key, p.value, next); } // 創建紅黑樹節點 TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) { return new TreeNode<>(hash, key, value, next); } // 用紅黑樹節點替代鏈表節點 TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) { return new TreeNode<>(p.hash, p.key, p.value, next); } // 重新初始化 void reinitialize() { // …… } // 節點操作后的調整 void afterNodeAccess(Node<K,V> p) { } void afterNodeInsertion(boolean evict) { } void afterNodeRemoval(Node<K,V> p) { }LinkedHashMap初始化節點是通過重寫HashMap的newNode方法實現的，首先創建LinkedHashMap.Entry節點對象，其次將該節點對象鏈接到LinkedHashMap當前尾節點的后面（after域），成為新的尾節點。通過節點之間的鏈接來保證插入節點的有序性。
// LinkedHashMap的新建節點實現 Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) { LinkedHashMap.Entry<K,V> p = new LinkedHashMap.Entry<K,V>(hash, key, value, e); // 將當前節點鏈接到尾節點的后面 linkNodeLast(p); return p; } // 鏈接到尾節點的后面 private void linkNodeLast(LinkedHashMap.Entry<K,V> p) { LinkedHashMap.Entry<K,V> last = tail; tail = p; if (last == null) head = p; else { p.before = last; last.after = p; } }需要注意的是，LinkedHashMap並未改變節點存儲的順序，換句話說，在HashMap存儲節點的數組Node
// LinkedHashMap的LinkedHashIterator實現 final LinkedHashMap.Entry<K,V> nextNode() { LinkedHashMap.Entry<K,V> e = next; if (modCount != expectedModCount) throw new ConcurrentModificationException(); if (e == null) throw new NoSuchElementException(); current = e; // next指向當前節點的after節點 next = e.after; return e; } // HashMap的HashIterator實現 final Node<K,V> nextNode() { Node<K,V>[] t; Node<K,V> e = next; if (modCount != expectedModCount) throw new ConcurrentModificationException(); if (e == null) throw new NoSuchElementException(); // next指向當前槽位的下一個節點或者下一個槽位的首節點 if ((next = (current = e).next) == null && (t = table) != null) { do {} while (index < t.length && (next = t[index++]) == null); } return e; }可以看出，LinkedHashMap的順序是在迭代器層面實現的。那LinkedHashMap的訪問順序又是如何實現的呢？也是通過迭代器嗎？LinkedHashMap在插入、查找以及替換元素之后都會調用afterNodeAccess方法進行重排序，下面來看下afterNodeAccess的實現。
// 將指定節點移至尾部 void afterNodeAccess(Node<K,V> e) { LinkedHashMap.Entry<K,V> last; if (accessOrder && (last = tail) != e) { LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after; // 尾節點的after節點為null p.after = null; // 指定節點為首節點，則將其after節點置為首節點 if (b == null) head = a; // 否則將before節點的after節點置為指定節點的after節點 else b.after = a; // 如果指定節點的after節點不為空，則將其before節點置為指定節點的before節點 if (a != null) a.before = b; // 否則將其before節點置為last節點 else last = b; // 如果last節點為null，則指定節點為頭結點 if (last == null) head = p; // 否則將指定節點綁定到尾節點 else { p.before = last; last.after = p; } tail = p; ++modCount; } }afterNodeAccess方法實現的核心功能是將指定節點移動到LinkedHashMap當前節點鏈的尾部，整個過程如下示意圖所示。
由此可知，在訪問元素后，總會將該元素移動到LinkedHashMap當前節點鏈的尾部，而tail尾節點也就是最年輕（youngest）的節點，head是最老（eldest）的節點，從而實現了訪問順序的排序。回到本節開始提到的Android中LruCache基於LinkedHashMap的實現最近最少訪問最先刪除算法的問題。LruCache指定了緩存的最大值maxSize，緩存元素超過maxSize后會觸發刪除eldest節點，Android中的LinkedHashMap實現新增了eldest方法，返回的正好就是節點鏈的頭節點header（eldest），即最近最少訪問的節點。
public Entry<K, V> eldest() { LinkedEntry<K, V> eldest = header.nxt; return eldest != header ? eldest : null; }至此，我們分析了HashMap和LinkedHashMap的實現原理，相比於之前版本的實現，JDK 1.8中最壞情況下查找的時間復雜度已經由O(n)變為O(lgn)，大大提高了性能。但在某些需要嚴格確保性能的場合，比如路由表實現，需要保證最壞情況下的時間復雜度仍為O(1)，那么就需要重新設計散列算法，而不能使用標准Java庫中的鏈地址法來解決散列沖突了。