![](http://img.blog.itpub.net/blog/2020/04/08/d16130b5d3872a57.png?x-oss-process=style/bb)

如果沒有特別說明，以下原始碼分析基於 JDK 1.8。

# 一、HashMap

為了便於理解，以下原始碼分析以 JDK 1.7 為主。

**1. 儲存結構**

內部包含了一個 Entry 型別的陣列 table。
```
transient Entry[] table;
```
Entry 儲存著鍵值對。它包含了四個欄位，從 next 欄位我們可以看出 Entry 是一個連結串列。 即陣列中的每個位置被當成一個桶，一個桶存放一個連結串列。HashMap 使用拉鍊法來解決衝突， 同一個連結串列中存放雜湊值相同的 Entry。

![](https://upload-images.jianshu.io/upload_images/20352904-5aece3ff28fb0d01.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
```
static class Entry<k> implements Map.Entry<k> {
	//包含了四個欄位
	final K key;
	V value;
	//next指向下一個節點，說明是連結串列結構
	Entry<k> next;
	int hash;
	Entry(int h, K k, V v, Entry<k> n) {
		value = v;
		next = n;
		key = k;
		hash = h;
	}
	public final K getKey() {
		return key;
	}
	public final V getValue() {
		return value;
	}
	public final V setValue(V newValue) {
		V oldValue = value;
		value = newValue;
		return oldValue;
	}
	public final Boolean equals(Object o) {
		if (!(o instanceof Map.Entry))
		            return false;
		Map.Entry e = (Map.Entry)o;
		Object k1 = getKey();
		Object k2 = e.getKey();
		// k1==k2 比較的是 hashcode 值，
		// k1.equals(k2)比較的是k1和k2的內容 equals 未重寫，則等價於 k1 == k2
		if (k1 == k2 || (k1 != null && k1.equals(k2))) {
			Object v1 = getValue();
			Object v2 = e.getValue();
			if (v1 == v2 || (v1 != null && v1.equals(v2)))
			                return true;
		}
		return false;
	}
	public final int hashCode() {
		return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
	}
	public final String toString() {
		return getKey() + "=" + getValue();
	}
}
```
**2. 拉鍊法的工作原理**
```
HashMap<string string=""> map = new HashMap<>();
map.put("K1", "V1");
map.put("K2", "V2");
map.put("K3", "V3");
```
- 新建一個 HashMap，預設大小為 16；
- 插入 <k1> 鍵值對，先計算 K1 的 hashCode 為 115，使用除留餘數法得到所在的桶下標 115%16=3。
- 插入 <k2> 鍵值對，先計算 K2 的 hashCode 為 118，使用除留餘數法得到所在的桶下標 118%16=6。
- 插入 <k3> 鍵值對，先計算 K3 的 hashCode 為 118，使用除留餘數法得到所在的桶下標 118%16=6，插在 <k2> 前面。

應該注意到連結串列的插入是以頭插法方式進行的，例如上面的 <k3> 不是插在 <k2> 後面，而是插入在連結串列頭部。

查詢需要分成兩步進行：

- 計算鍵值對所在的桶；
- 在連結串列上順序查詢，時間複雜度顯然和連結串列的長度成正比。

**3. put 操作**
```
public V put(K key, V value) {
	if (table == EMPTY_TABLE) {
		inflateTable(threshold);
	}
	// 鍵為 null 單獨處理
	if (key == null)
	        return putForNullKey(value);
	int hash = hash(key);
	// 確定桶下標
	int i = indexFor(hash, table.length);
	// 先找出是否已經存在鍵為 key 的鍵值對，如果存在的話就更新這個鍵值對的值為 value
	// 時間複雜度顯然和連結串列的長度成正比。
	for (Entry<k> e = table[i]; e != null; e = e.next) {
		Object k;
		if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
			V oldValue = e.value;
			e.value = value;
			e.recordAccess(this);
			return oldValue;
		}
	}
	modCount++;
	// 插入新鍵值對
	addEntry(hash, key, value, i);
	return null;
}
```
HashMap 允許插入鍵為 null 的鍵值對。但是因為無法呼叫 null 的 hashCode() 方法，也就無法確定該鍵值對的桶下標，只能透過強制指定一個桶下標來存放。HashMap 使用第 0 個桶存放鍵為 null 的鍵值對。
```
private V putForNullKey(V value) {
	//HashMap 使用第 0 個桶 table[0] 存放鍵為 null 的鍵值對。
	for (Entry<k> e = table[0]; e != null; e = e.next) {
		if (e.key == null) {
			V oldValue = e.value;
			e.value = value;
			// 更新值
			e.recordAccess(this);
			return oldValue;
			// 返回舊值
		}
	}
	modCount++;
	//void addEntry(int hash, K key, V value, int bucketIndex)
	addEntry(0, null, value, 0);
	return null;
}
```
使用連結串列的頭插法，也就是新的鍵值對插在連結串列的頭部，而不是連結串列的尾部。
```
//TODO:使用連結串列的頭插法，也就是新的鍵值對插在連結串列的頭部，而不是連結串列的尾部。
void addEntry(int hash, K key, V value, int bucketIndex) {
	if ((size >= threshold) && (null != table[bucketIndex])) {
		resize(2 * table.length);
		hash = (null != key) ? hash(key) : 0;
		bucketIndex = indexFor(hash, table.length);
	}
	createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
	Entry<k> e = table[bucketIndex];
	// 頭插法，連結串列頭部指向新的鍵值對
	table[bucketIndex] = new Entry<>(hash, key, value, e);
	size++;
}
```

```
Entry(int h, K k, V v, Entry<k> n) {
	value = v;
	next = n;
	key = k;
	hash = h;
}
```
**4. 確定桶下標**

很多操作都需要先確定一個鍵值對所在的桶下標。
```
int hash = hash(key);
int i = indexFor(hash, table.length);
```
①. 計算 hash 值
```
final int hash(Object k) {
	int h = hashSeed;
	if (0 != h && k instanceof String) {
		return sun.misc.Hashing.stringHash32((String) k);
	}
	h ^= k.hashCode();
	// This function ensures that hashCodes that differ only by
	// constant multiples at each bit position have a bounded
	// number of collisions (approximately 8 at default load factor).
	h ^= (h >>> 20) ^ (h >>> 12);
	return h ^ (h >>> 7) ^ (h >>> 4);
}
```

```
public final int hashCode() {
	return Objects.hashCode(key) ^ Objects.hashCode(value);
}
```
②. 取模

令 x = 1<<4，即 x 為 2 的 4 次方，它具有以下性質：
```
x   : 00010000
x-1 : 00001111
```
令一個數 y 與 x-1 做與運算，可以去除 y 位級表示的第 4 位以上數：
```
y       : 10110010
x-1     : 00001111
y&(x-1) : 00000010
```
這個性質和 y 對 x 取模效果是一樣的：
```
y   : 10110010
x   : 00010000
y%x : 00000010
```
我們知道，位運算的代價比求模運算小的多，因此在進行這種計算時用位運算的話能帶來更高的效能。

確定桶下標的最後一步是將 key 的 hash 值對桶個數取模： hash%capacity，如果能保證 capacity 為 2 的 n 次方，那麼就可以將這個操作轉換為位運算。
```
static int indexFor(int h, int length) {
    return h & (length-1);
}
```
就等價於
```
static int indexFor(int h, int length) {
    return h % length;
}
```
但是效率會更高。

**5. 擴容-基本原理**

設 HashMap 的 table 長度為 M，需要儲存的鍵值對數量為 N，如果雜湊函式滿足均勻性的要求，那麼每條連結串列的長度大約為 N/M，因此平均查詢次數的複雜度為 O(N/M)。

為了讓查詢的成本降低，應該儘可能使得 N/M 儘可能小，因此需要保證 M 儘可能大，也就是說 table 要儘可能大。 HashMap 採用動態擴容來根據當前的 N 值來調整 M 值，使得空間效率和時間效率都能得到保證。

和擴容相關的引數主要有：capacity、size、threshold 和 load_factor。

![](https://upload-images.jianshu.io/upload_images/20352904-b9d299ddecf5aca0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

```
static final int DEFAULT_INITIAL_CAPACITY = 16;
//保證 capacity 為 2 的 n 次方，那麼就可以將indexFor方法中操作轉換為位運算
static final int MAXIMUM_CAPACITY = 1 << 30;
//保證 capacity 為 2 的 n 次方，那麼就可以將 indexFor 方法中操作轉換為位運算
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry[] table;
transient int size;
int threshold;
final float loadFactor;
transient int modCount;
```
從下面的新增元素程式碼中可以看出，當需要擴容時，令 capacity 為原來的兩倍。
```
void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<k> e = table[bucketIndex];
	table[bucketIndex] = new Entry<>(hash, key, value, e);
	if (size++ >= threshold)
	        resize(2 * table.length);
	//令 capacity 為原來的兩倍
}
```
擴容使用 resize() 實現，需要注意的是，擴容操作同樣需要把 oldTable 的所有鍵值對重新插入 newTable 中，因此這一步是很費時的。
```
void resize(int newCapacity) {
	Entry[] oldTable = table;
	int oldCapacity = oldTable.length;
	if (oldCapacity == MAXIMUM_CAPACITY) {
		threshold = Integer.MAX_VALUE;
		return;
	}
	Entry[] newTable = new Entry[newCapacity];
	transfer(newTable);
	table = newTable;
	threshold = (int)(newCapacity * loadFactor);
}
void transfer(Entry[] newTable) {
	Entry[] src = table;
	int newCapacity = newTable.length;
	for (int j = 0; j < src.length; j++) {
		Entry<k> e = src[j];
		if (e != null) {
			src[j] = null;
			do {
				Entry<k> next = e.next;
				int i = indexFor(e.hash, newCapacity);
				e.next = newTable[i];
				newTable[i] = e;
				e = next;
			}
			while (e != null);
		}
	}
}
```
**6. 擴容-重新計算桶下標**

在進行擴容時，需要把鍵值對重新放到對應的桶上。HashMap 使用了一個特殊的機制，可以提升重新計算桶下標的效率。

假設原陣列長度 capacity 為 16，擴容之後 new capacity 為 32：
```
capacity     : 00010000
new capacity : 00100000
```
對於一個 Key，

- 它的雜湊值如果在第 5 位上為 0，那麼取模得到的結果和之前一樣；
- 如果為 1，那麼得到的結果為原來的結果 +16。

**7. 計算陣列容量**

HashMap 建構函式允許使用者傳入的容量不是 2 的 n 次方，因為它可以自動地將傳入的容量轉換為 2 的 n 次方。

先考慮如何求一個數的掩碼，對於 10010000，它的掩碼為 11111111，可以使用以下方法得到：
```
mask |= mask >> 1    11011000
mask |= mask >> 2    11111110
mask |= mask >> 4    11111111
```
mask+1 是大於原始數字的最小的 2 的 n 次方。
```
num     10010000
mask+1  100000000
```
以下是 HashMap 中計算陣列容量的程式碼：
```
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;
    //得到n的掩碼
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
```
**8. 連結串列轉紅黑樹**

從 JDK 1.8 開始，一個桶儲存的連結串列長度大於 8 時會將連結串列轉換為紅黑樹。

**9. 與 HashTable 的比較**

- HashMap 是非執行緒安全的，HashTable 使用 synchronized 來進行同步，是執行緒安全的。
- HashMap 要比 HashTable 效率高一點。Hashtable 基本被淘汰，不要在程式碼中使用它。
- HashMap 可以插入鍵為 null 的 Entry；HashTable 中插入的鍵只要有一個為 null，直接丟擲 NullPointerException。
- HashMap 的迭代器是 fail-fast 迭代器。
- HashMap 不能保證隨著時間的推移 Map 中的元素次序是不變的。
- HashMap 在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為8）時，將連結串列轉化為紅黑樹，以減少搜尋時間；Hashtable 沒有這樣的機制。
- HashMap 預設的初始化大小為16。之後每次擴充，容量變為原來的2倍；Hashtable 容量預設的初始大小為11，之後每次擴充，容量變為原來的2n+1。 在初始化時如果給定了容量初始值，HashMap 會將其擴充為2的冪次方大小；Hashtable 會直接使用初始值。

**10. 與 HashSet 的比較**

HashSet 底層就是基於HashMap實現的。 (HashSet 的原始碼非常非常少，因為除了 clone() 方法、writeObject()方法、readObject()方法是 HashSet 自己不得不實現之外， 其他方法都是直接呼叫 HashMap 中的方法。)

![](https://upload-images.jianshu.io/upload_images/20352904-735070c87e6098d6.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

# 二、LinkedHashMap

**1.儲存結構**

繼承自 HashMap，因此具有和 HashMap 一樣的快速查詢特性。
```
public class LinkedHashMap<k> extends HashMap<k> implements Map<k>
```
內部維護了一個雙向連結串列，用來維護插入順序或者 LRU 順序。
```
/**
 * The head (eldest) of the doubly linked list.
 */
transient LinkedHashMap.Entry<k> head;
/**
 * The tail (youngest) of the doubly linked list.
 */
transient LinkedHashMap.Entry<k> tail;
```
accessOrder 決定了順序，預設為 false，此時維護的是插入順序。
```
final boolean accessOrder;
```
LinkedHashMap 最重要的是以下用於維護順序的函式，它們會在 put、get 等方法中呼叫。
```
void afterNodeAccess(Node<k> p) { }
void afterNodeInsertion(boolean evict) { }
```
**2.afterNodeAccess()**

當一個節點被訪問時，如果 accessOrder 為 true，則會將該節點移到連結串列尾部。也就是說指定為 LRU 順序之後，在每次訪問一個節點時，會將這個節點移到連結串列尾部，保證連結串列尾部是最近訪問的節點，那麼連結串列首部就是最近最久未使用的節點。
```
void afterNodeAccess(Node<k> e) {
	// move node to last
	LinkedHashMap.Entry<k> last;
	if (accessOrder && (last = tail) != e) {
		LinkedHashMap.Entry<k> p =
		            (LinkedHashMap.Entry<k>)e, b = p.before, a = p.after;
		p.after = null;
		if (b == null)
		            head = a; else
		            b.after = a;
		if (a != null)
		            a.before = b; else
		            last = b;
		if (last == null)
		            head = p; else {
			p.before = last;
			last.after = p;
		}
		tail = p;
		++modCount;
	}
}
```
**3.afterNodeInsertion()**

在 put 等操作之後執行，當 removeEldestEntry() 方法返回 true 時會移除最晚的節點，也就是連結串列首部節點 first。

evict 只有在構建 Map 的時候才為 false，在這裡為 true。
```
void afterNodeInsertion(Boolean evict) {
	// possibly remove eldest
	LinkedHashMap.Entry<k> first;
	if (evict && (first = head) != null && removeEldestEntry(first)) {
		K key = first.key;
		removeNode(hash(key), key, null, false, true);
	}
}
```
removeEldestEntry() 預設為 false，如果需要讓它為 true，需要繼承 LinkedHashMap 並且覆蓋這個方法的實現，這在實現 LRU 的快取中特別有用，透過移除最近最久未使用的節點，從而保證快取空間足夠，並且快取的資料都是熱點資料。
```
protected boolean removeEldestEntry(Map.Entry<k> eldest) {
    return false;
}
```
**4.LRU 快取**

以下是使用 LinkedHashMap 實現的一個 LRU 快取：

- 設定最大快取空間 MAX_ENTRIES 為 3；
- 使用 LinkedHashMap 的建構函式將 accessOrder 設定為 true，開啟 LRU 順序；
- 覆蓋 removeEldestEntry() 方法實現，在節點多於 MAX_ENTRIES 就會將最近最久未使用的資料移除。

```
public class LRUCache<k> extends LinkedHashMap<k>{
	private static final int MAX_ENTRIES = 3;
	LRUCache(){
		super(MAX_ENTRIES,0.75f,true);
	}
	/**
     * removeEldestEntry() 預設為 false，
     * 如果需要讓它為 true，需要繼承 LinkedHashMap 並且覆蓋這個方法的實現，
     * 這在實現 LRU 的快取中特別有用，透過移除最近最久未使用的節點，
     * 從而保證快取空間足夠，並且快取的資料都是熱點資料。
     */
	@Override
	    protected Boolean removeEldestEntry(Map.Entry eldest) {
		return size() > MAX_ENTRIES;
	}
	public static void main(String[] args) {
		LRUCache<integer> cache=new LRUCache<>();
		cache.put(1, "a");
		cache.put(2, "b");
		cache.put(3, "c");
		cache.get(1);
		//LRU  鍵值1被訪問過了，則最近最久未訪問的就是2
		cache.put(4, "d");
		System.out.println(cache.keySet());
	}
}
```

```
[3, 1, 4]
```

# 三、WeakHashMap

**1.儲存結構**

WeakHashMap 的 Entry 繼承自 WeakReference，被 WeakReference 關聯的物件在下一次垃圾回收時會被回收。

WeakHashMap 主要用來實現快取，透過使用 WeakHashMap 來引用快取物件，由 JVM 對這部分快取進行回收。
```
private static class Entry<k> extends WeakReference<object> implements Map.Entry<k>
```
**2.ConcurrentCache**

Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 來實現快取功能。

ConcurrentCache 採取的是分代快取：

- 經常使用的物件放入 eden 中，eden 使用 ConcurrentHashMap 實現，不用擔心會被回收；
- 不常用的物件放入 longterm，longterm 使用 WeakHashMap 實現，這些老物件會被垃圾收集器回收。
- 當呼叫 get() 方法時，會先從 eden 區獲取，如果沒有找到的話再到 longterm 獲取，當從 longterm 獲取到就把物件放入 eden 中，從而保證經常被訪問的節點不容易被回收。
- 當呼叫 put() 方法時，如果 eden 的大小超過了 size，那麼就將 eden 中的所有物件都放入 longterm 中，利用虛擬機器回收掉一部分不經常使用的物件。

```
public final class ConcurrentCache<k v=""> {
	private final int size;
	private final Map<k v=""> eden;
	private final Map<k v=""> longterm;
	public ConcurrentCache(int size) {
		this.size = size;
		this.eden = new ConcurrentHashMap<>(size);
		this.longterm = new WeakHashMap<>(size);
	}
	public V get(K k) {
		V v = this.eden.get(k);
		if (v == null) {
			v = this.longterm.get(k);
			if (v != null)
			                this.eden.put(k, v);
		}
		return v;
	}
	public void put(K k, V v) {
		if (this.eden.size() >= size) {
			this.longterm.putAll(this.eden);
			this.eden.clear();
		}
		this.eden.put(k, v);
	}
}
```</k></k></k></k></object></k></integer></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k></k2></k3></k2></k3></k2></k1></string></k></k></k></k>

詳解Java 容器（第④篇）——容器原始碼分析 - Map

相關文章