【集合詳解】HashMap原始碼解析
一、HashMap概述
二、HashMap的資料結構
三、HashMap原始碼分析
1.繼承
2、關鍵屬性
3、結構
4、建構函式
5、擴容
四：總結
一、概述
HashMap基於雜湊表的 Map 介面的實現。此實現提供所有可選的對映操作，並允許使用 null 值和 null 鍵。（除了不同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）此類不保證對映的順序，特別是它不保證該順序恆久不變。
值得注意的是HashMap不是執行緒安全的，如果想要執行緒安全的HashMap，可以通過Collections類的靜態方法synchronizedMap獲得執行緒安全的HashMap。
二、資料結構
在java程式語言中，最基本的結構就是兩種，一個是陣列，另外一個是模擬指標（引用），所有的資料結構都可以用這兩個基本結構來構造的，hashmap也不例外。Hashmap實際上是一個數組和連結串列的結合體（在資料結構中，一般稱之為“連結串列雜湊“），如圖（豎排表示陣列，橫排表示陣列元素【實際上是一個連結串列】）。
圖中，紫色部分即代表雜湊表，也稱為雜湊陣列，陣列的每個元素都是一個單鏈表的頭節點，連結串列是用來解決衝突的，如果不同的key對映到了陣列的同一位置處，就將其放入單鏈表中的第一個位置。
在JDK8中 又有了新的優化。桶中的元素不再唯一按照連結串列組合，也可以使用紅黑樹進行儲存
三、原始碼分析
繼承
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable關鍵屬性
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
// 序列號
private static final long HashMap結構
JDK 7
/** Entry是單向連結串列。
* 它是 “HashMap鏈式儲存法”對應的連結串列。
*它實現了Map.Entry 介面，即實現getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函式
**/
transient Entry[] table;
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
// 指向下一個節點
Entry<K,V> next;
final int hash;
// 建構函式。
// 輸入引數包括"雜湊值(h)", "鍵(k)", "值(v)", "下一節點(n)"
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
} ＪＤＫ８
/** Entry是單向連結串列。
* 它是 “HashMap鏈式儲存法”對應的連結串列。
*它實現了Map.Entry 介面，即實現getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函式
**/
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;
}
．．．
//紅黑樹節點
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* Returns root of tree containing this node.
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
建構函式
HashMap(int initialCapacity)
public HashMap(int initialCapacity) {
// 呼叫HashMap(int, float)型建構函式
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}public HashMap()
public HashMap() {
// 初始化填充因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
}public HashMap(Map
public HashMap(Map<? extends K, ? extends V> m) {
// 初始化填充因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 將m中的所有元素新增至HashMap中
putMapEntries(m, false);
}注意：在hashMap中陣列的大小都是預設指定為2的４次冪，以後容量也是２的ｎ次冪。具體原因，下面putVal方法介紹。
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為空就建立
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//確定插入table的位置，演算法是(n - 1) & hash
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//在table的i位置發生碰撞，有兩種情況，1、key值是一樣的，替換value值，
//2、key值不一樣的有兩種處理方式：2.1、儲存在i位置的連結串列；2.2、儲存在紅黑樹中
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//2.2
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//2.1
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//超過了連結串列的設定長度8就擴容
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;
}
}
//如果e不為空就替換舊的oldValue值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//threshold=newThr:(int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
//預設0.75*16，大於threshold值就擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}Hash演算法：
得到hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}解釋：
h>>16:
得到通過h=key.hashCode()方法計算key的hashcode的值，通過計算出的hashcode的值向右移動16位，使原有的hashcode的值的高16位變低16位，高16位則統一都變為0。
異或運算：(h = key.hashCode()) ^ (h >>> 16)
原 來 的 hashCode : 1111 1111 1111 1111 0100 1100 0000 1010
移位後的hashCode: 0000 0000 0000 0000 1111 1111 1111 1111
進行異或運算 結果：1111 1111 1111 1111 1011 0011 1111 0101
這樣做的好處是，可以將hashcode高位和低位的值進行混合做異或運算，而且混合後，低位的資訊中加入了高位的資訊，這樣高位的資訊被變相的保留了下來。摻雜的元素多了，那麼生成的hash值的隨機性會增大。
獲取位置：
接著我們看該重新產生的hashcode應該對應的位置。
原始碼中模運算是在這個indexFor( )函式裡完成的。
bucketIndex = indexFor(hash, table.length);indexFor的程式碼也很簡單，就是把雜湊值和陣列長度做一個”與”操作
static int indexFor(int h, int length) {
return h & (length-1);
}順便說一下，這也正好解釋了為什麼HashMap的陣列長度要取2的整次冪。因為這樣（陣列長度-1）正好相當於一個“低位掩碼”。“與”操作的結果就是雜湊值的高位全部歸零，只保留低位值，用來做陣列下好相當於一個“低位掩碼”。“與”操作的結果就是雜湊值的高位全部歸零，只保留低位值，用來做陣列下標訪問。以初始長度16為例，16-1=15。2進製表示是00000000 00000000 00001111。和某雜湊值“與”操作如下，結果就是截取了最低的四位值。
10100101 11000100 00100101
& 00000000 00000000 00001111
----------------------------------
00000000 00000000 00000101 //高位全部歸零，只保留末四位整個流程如下:
這樣我們已經得到了該元素的在陣列中的位置。 在put時，由於根據的是hashcode來put元素的,假如當前陣列位置已經存在元素，則會通過連結串列形式在該位置追加元素。（jdk7）
在JDK8中，有所改進的是，當加入連結串列元素的數量達到某固定值時，則改為紅黑樹結構儲存。
//put(K key,V value)函式
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，則resize()
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//找到key值對應的槽並且是第一個，直接加入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e;
K k;
//第一個node的hash值即為要加入元素的hash
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))){
e = p;
}else if (p instanceof TreeNode)//第一個節點是TreeNode，即tree-bin
/*Tree version of putVal.
*final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,int h, K k, V v)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//不是TreeNode,即為連結串列,遍歷連結串列
for (int binCount = 0; ; ++binCount) {
/*到達連結串列的尾端也沒有找到key值相同的節點，
*則生成一個新的Node,並且判斷連結串列的節點個數是不是到達轉換成紅黑樹的上界
*達到，則轉換成紅黑樹
*/
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;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回舊的value值
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
擴容：
final Node<K,V>[] resize() {
// 當前table儲存
Node<K,V>[] oldTab = table;
// 儲存table大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 儲存當前閾值
int oldThr = threshold;
int newCap, newThr = 0;
// 之前table大小大於0
if (oldCap > 0) {
// 之前table大於最大容量
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
}
// 之前閾值大於0
else if (oldThr > 0)
newCap = oldThr;
// oldCap = 0並且oldThr = 0，使用預設值（如使用HashMap()建構函式，之後再插入一個元素會呼叫resize函式，會進入這一步）
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 新閾值為0
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"})
// 初始化table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 之前的table已經初始化過
if (oldTab != null) {
// 複製元素，重新進行hash
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 { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 將同一桶中的元素根據(e.hash & oldCap)是否為0進行分割，分成兩個不同的連結串列，完成rehash
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;
} 說明：進行擴容，會伴隨著一次重新hash分配，並且會遍歷hash表中所有的元素，是非常耗時的。在編寫程式中，要儘量避免resize。 在resize前和resize後的元素佈局如下
說明：上圖只是針對了陣列下標為2的桶中的各個元素在擴容後的分配佈局，其他各個桶中的元素佈局可以以此類推。 從putVal原始碼中我們可以知道，當插入一個元素的時候size就加1，若size大於threshold的時候，就會進行擴容。假設我們的capacity大小為32，loadFator為0.75,則threshold為24 = 32 * 0.75，此時，插入了25個元素，並且插入的這25個元素都在同一個桶中，桶中的資料結構為紅黑樹，則還有31個桶是空的，也會進行擴容處理，其實，此時，還有31個桶是空的，好像似乎不需要進行擴容處理，但是是需要擴容處理的，因為此時我們的capacity大小可能不適當。我們前面知道，擴容處理會遍歷所有的元素，時間複雜度很高；前面我們還知道，經過一次擴容處理後，元素會更加均勻的分佈在各個桶中，會提升訪問效率。所以，說盡量避免進行擴容處理，也就意味著，遍歷元素所帶來的壞處大於元素在桶中均勻分佈所帶來的好處。
總結：
本文介紹了hashMap的資料結構，重點分析了一些原始碼建構函式和擴容函式。以及對hash演算法進行了簡單剖析。如果不足，請多指正。