容器之路 HashMap、HashSet解析（一）
1.1 HashMap概述
相信大家在大學的時候都學習過散列表。
使用散列表的查詢演算法主要分為兩步，第一步是利用雜湊函式將被查詢的鍵轉化為一個索引，理想情況下，所有不同的key都會被雜湊為不同的索引值，但是由於雜湊函式無法達到完美的雜湊，所以，我們通常還需要處理碰撞的情況。
處理碰撞的方法主要有兩種，一種是拉鍊法，另一種是線性探測法。
在HashMap中，使用的是拉鍊法，也就是一個桶，由陣列構成，陣列的索引代表了雜湊值，每個陣列後接了一個連結串列。當出現衝突碰撞的情況時，我們將判斷這個key是否已經存在，如果存在，那麼，替換value值，如果不存在，那麼，將這個Entry連結到連結串列上。
//HashMap中的桶 transient Node<K,V>[] table;
那麼，當我們查詢時，先找到對應的索引值，然後，遍歷連結串列，找到所需的內容。
這裡，我們需要注意，如果大量資料的雜湊值相同，就會導致連結串列很長，查詢效率也就變低了。因此，在JDK1.8中，當連結串列的長度超出閾值，我們會將連結串列進行樹化，形成紅黑樹，讓查詢效率提高。
還有就是，關於Map的resize。Map中有一個引數叫做負載因子loadFactor，當桶中的資料量達到桶的長度乘上負載因子時，就會進行擴容。擴容過程中，會把桶的大小變為原來的2倍，並且，將原來Map中的內容進行重新雜湊，這部分內容也是HashMap中的一個難點，而且，這個演算法十分巧妙。
下面是HashMap中節點的資料結構，是單鏈表結點
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }
1.2 插入資料
通常情況下，如果我們使用我們自己建立的類來作為HashMap中的key，那麼，我們需要提供一個比較好的hashCode ，如果這個方法有問題，將會影響雜湊函式的效率。所以，通常情況下，推薦使用不可變類來作為key，例如String。
根據註釋可以初步瞭解插入資料的流程
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)
//新建後第一次插入資料會呼叫resize方法
n = (tab = resize()).length;
//如果找到的索引位置沒有插入資料，那麼直接新建節點，插入即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
/**
* 如果該索引出已經有資料，可能是兩種情況
* 一種是，當前插入節點的key值已經存在，那麼需要替換value值
* 另外一種是，出現衝突，需要將結點增加到連結串列中
*/
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) {
//遍歷過程中沒有找到相同的key，確定新增
p.next = newNode(hash, key, value, null);
//新增結點後，如果連結串列長度超過閾值即>=7，連結串列轉化為紅黑樹
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;
}
}
//如果是已經存在的結點，替換value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//HashMap中此方法為空，LinkedHashMap實現了這個方法
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//達到閾值，擴容
if (++size > threshold)
resize();
//HashMap中此方法為空，LinkedHashMap實現了這個方法
afterNodeInsertion(evict);
return null;
}1.2.1 確定索引位置
當我們已經有了key的hash值，確定索引位置，也就是雜湊值的方法如下。
這裡n是桶的長度
(n - 1) & hash這種方式實際上是除留取餘法，這種方法方便計算，使用運算子&比mod效率更高一點。
如果n=2^m，那麼這樣的方式我們就取得了hash值的低m位。
1.2.2 建構函式與tableSizeFor
這裡首先介紹一下HashMap的建構函式，主要有以下兩個。
public HashMap() {
//沒有給出初始值，那麼負載因子預設為0.75
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//初始值超出最大值，那麼就去最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//這裡通過tableSizeFor方法獲取到離給定值最近的2的冪
this.threshold = tableSizeFor(initialCapacity);
}我們需要注意，在HashMap中，桶的大小，也就table的大小必須是2的冪，這樣後面計算索引的時候更加方便，因此，我們需要一個演算法來獲取這個值。
/**
* Returns a power of two size for the given target capacity.
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}首先，我們考慮如何取一個大於給定數字的並且離給定數字最近的2的冪。
關於這裡為什麼減1，後面又加一，實際上，如果給定數字已經是2的冪，這裡給出的演算法獲得的將是其倍數，而不是本身。
下面來看一下JDK中的實現。
在這裡，我們發現，初始化時，並沒有給桶的大小賦初值，這個操作延遲到了放入資料的resize函式中，接下來，我們來看一下resize函式。
1.2.3 resize擴容
擴容主要分為兩步，第一步是確定擴容後的桶的大小和再次擴容的閾值threshold，第二步是將原來HashMap中的資料移動到新的Map中。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//由於初始化時沒有給table賦初值，所以這裡指的時map已經有資料的情況
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
}
//初始化時，賦了初值，在此處將這個值賦newCap
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else {
//之前呼叫了沒有引數的建構函式，這裡使用預設值，閾值是DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY
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;
//順著桶遍歷
if ((e = oldTab[j]) != null) {
//釋放原有的空間，以便GC
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 { // 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);
//將兩個連結串列連線到正確的位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}這段程式碼中，最為巧妙的地方就是如何找到已有結點在新map中的位置。
前面已經說過，一個entry的索引位置實際是hash值的低m位，那麼擴容後，這個取值就會變為低m+1位。這樣，如果hash值的第m+1位是0，那麼這個資料還在原來的位置；如果這位為1，那麼這個資料就會在原來位置加上oldCap的位置處。
理解了這部分內容，我們就可以瞭解上面的演算法為什麼將原來的一條連結串列分為兩條了。
那麼我們的重點就是獲得這個m+1為的值，方法如下
e.hash & oldCap
至此，我們對擴容已經有了一個深入的瞭解。關於HashMap的樹化，已經樹化後擴容的移動問題，我們將在下一篇中介紹。