哈希表之HashMap(二)
在寫這篇文章以前，看了不少關於HashMap解析的文章。對於大多數人來講，可了跟着別人的文章走一遍。你們都能瞭解HashMap的內部結構，使用方法以及注意事項。我仍是以爲知道用是一回事。知道原理是另外一回事。只有瞭解了其數據結構設計初衷。才能更好的使用它。此係列文章主要分爲兩個部分，具體目錄以下：java
- 哈希表初識(一)
- 哈希表之HashMap(二)
提示：該篇文章做爲完全理解哈希表的第二個部分。主要講了HashMap在Java中基於JDK1.8(不一樣版本HashMap可能實現不一樣)的具體實現。若是你對哈希表還不算太熟，建議先閱讀上一篇文章，我相信等你看完以後，在回來看這篇文章，會有一種飛翔的感受。git
前言
在Java中java.util包下，定義了Map接口來實現鍵值對的映射關係。經常使用的類爲HashMap,LinkedHashMap,TreeMap。其主要的類關係以下圖所示：github
在平時項目的開發中，咱們主要使用的是HashMap及其子類，那咱們接下來就瞭解一下HashMap的主要特徵。數組
- 採用數組+鏈表的形式對數據進行存儲。
- 根據hashCode值存儲數據，訪問速度較快。
- 有且只有一個key爲null的數組。
- 遍歷是無序的。
- 線程非安全。
內部結構
既然上文提到了數組+鏈表的形式，你們是否想起咱們上篇文章提到的鏈地址法呢？若是你忘記了鏈地址法的具體實現，不要緊，讓咱們一塊兒看看在Java中HashMap具體的內部結構,具體的結構以下圖所示：(注意:在JDK1.8中若是鏈表的長度大於8時會將該鏈表轉換爲紅黑樹)安全
從圖中看出，HashMap底層存儲的是Node節點，本質是一個映射（鍵值對）。上圖中，每一個黑色圓點就是一個Node對象，數組table對應Node<K,V>[] table。bash
查看Node對應源碼:數據結構
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, HashMapEntry<K,V> next) {...}
public final K getKey() {...}
public final V getValue() {...}
public final String toString() {...}
public final int hashCode(){...}
public final V setValue(V newValue) {...}
public final boolean equals(Object o) {...}
}
複製代碼
從代碼中咱們能夠看出，Node是HashMap的一個內部類，實現了Map.Entry接口。該類中保存了當前存儲數據的hash值，關鍵字、和當前存儲數據、及下一個Node節點的引用。既然咱們已經知道了HashMap到底存儲的是什麼東西，那麼咱們繼續看看HashMap的初始化。函數
HashMap初始化
在咱們初始化HashMap實例對象的時候，咱們默認調用是其參數爲空的構造函數，查看具體實現：post
public HashMap() {
//DEFAULT_LOAD_FACTOR = 0.75
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
複製代碼
從上，不知道你們看到熟悉的東西沒loadFactor,還記得上篇文章咱們提到的裝載因子(咱們不可能等到數組快滿時，才進行擴容操做，由於會影響效率），咱們發現默認狀況下，HashMap初始容量爲16，且裝載因子爲0.75，也就是當容量爲12(當前數組容量*裝載因子)時，進行下一次添加數據的時候，會對HashMap內部的數組進行擴容。ui
HashMap放入鍵值對
查看put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
複製代碼
在HashMap調用put方法，放入鍵值對時，會先調用hash方法計算當前key對象的哈希值，對應hash方法以下：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
複製代碼
hash方法內部會獲取當前key的hashCode,經過當前hashCode與當前hashCode右移後的數字，進行異或運算獲得哈希值。
查看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;
//第二步，若是當前數據未放入，則添加
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) {
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;
}
//若是是鏈表中的key已存在，則進行覆蓋操做
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) {
V oldValue = e.value;
//第六步，是否覆蓋已存在的key對應的value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//若是添加完後，當前數組容量大於臨界值，對數組進行擴容。
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
複製代碼
從上述代碼中咱們能夠看出，HashMap添加元素主要分爲六個步驟。通過這六個步驟完成了相應的鍵值對的映射。下面咱們將具體的來分析這六個步驟。
(一) 建立table數組
若是當前數組爲空，會調用相應resize()方法。建立相應table數組。這裏省略了擴容數組代碼，由於其比較複雜，下面咱們會單獨進行分析。
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) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//若是當前數組到達臨界值
//數組容量爲原來的2倍
//新的臨界值爲原來的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0)
newCap = oldThr;
else {
//默認沒有數據的狀況下，初始化數組，與臨界值
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;
....省略擴容代碼
//返回新的數組
return newTab;
}
複製代碼
上面的代碼很好理解。判斷當前數組是否爲空，若是爲空，則初始化當前數組，且當前數組容量爲DEFAULT_INITIAL_CAPACITY=16,且臨界值爲12（16*0.75），最後該方法會將建立的數組進行返回。
(二) 若是當前數據未放入，則添加
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
複製代碼
上述代碼，知根據當前key值計算出來的hash值。獲取對應數組中的下標，若是當前數組單元沒有放入數據，則添加數據到相應的數組單元中。
(三) 若是當前key已存在，則進行覆蓋操做
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
複製代碼
上面代碼也是很好理解，若是當前數組單元有數據，且相同hash值且key值相同，那麼就進行替換操做。
(四) 判斷當前是不是紅黑樹
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
複製代碼
若是當前數組單元對應的是紅黑樹，那麼調用相應紅黑樹添加方法。這裏咱們不討論紅黑樹，這裏咱們只要知道。在使用紅黑樹的時候，查找效率是要優於傳統的鏈表就行了。
(五)、(六)添加元素到鏈表中
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1)
//若是當前鏈表長度大於8，轉換爲紅黑樹
treeifyBin(tab, hash);
break;
}
//獲取hash值相同與key值相同，直接返回當前節點。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { //替換相同key值的value
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
複製代碼
這裏我把第五步與第六部合併來說解。從代碼代碼你們就能夠理解。獲取數組單元鏈表的長度，若是當前鏈表長度大於8，轉換爲紅黑樹，若是存在相同hash值或者key值相同的節點。直接替換對應的value。反之,添加鍵值對到相應鏈表中。
HashMap的擴容機制
上面咱們省略了擴容代碼的具體，下面咱們來仔細探討一下HashMap的擴容機制。 主要擴容代碼以下：
//oldTab是原來的talble 數組
if (oldTab != null) {
//遍歷原來數組單元中對應的鏈表，oldCap是原來數組的容量
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;
do {
next = e.next;
//原位置的節點
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//原位置+oldCap的節點
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;
}
}
}
}
}
複製代碼
直接去理解這段代碼很難，根據上篇文章的經驗，咱們知道在數組進行擴容的時候，須要根據hash值去與新的數組長度進行取餘運算（hash&length -1),可是從上述代碼中，咱們沒有發現進行取餘的操做。這是怎麼回事呢？沒事你們一塊兒來看下圖。
上圖中，咱們假設某個節點hash值爲1111 1111 1111 1111 11111 0000 1011 1111，而且在添加該值時，數組進行了擴容操做（爲原來的數組長度的2倍）。咱們發現節點在從新計算角標的時候，由於數組的長度變爲以前的兩倍，因此在新數組中的bit位中，始終要比原來的高一位（圖中紅色以表示區分），那麼咱們就能夠根據下圖得知。
從上圖能夠得知，只要咱們經過e.hash & oldCap==0，咱們就能夠得知，該節點的新位置是在原位置，仍是在原來的位置基礎上+oldCap。不得不說這段代碼很是優雅與巧妙，提升的效率不是吹的（由於沒有從新取餘去計算角標）。
參考
站在巨人的肩膀上。能夠看得更遠。 [Java 8系列之從新認識HashMap]--美團技術團隊
最後
最後，附上我寫的一個基於Kotlin 仿開眼的項目SimpleEyes(ps: 其實在我以前，已經有不少小朋友開始仿這款應用了，可是我以爲要作就作好。因此個人項目和其餘的人應該不一樣，不只僅是簡單的一個應用。可是，可是。可是。重要的話說三遍。還在開發階段，不要打我)，歡迎你們follow和start.
- 1. 哈希表HashMap
- 2. HashMap/HashSet,hashCode,哈希表
- 3. java 哈希表與HashMap
- 4. 哈希表、Java中HashMap
- 5. 哈希（哈希表與哈希函數）
- 6. bullet HashMap 內存緊密的哈希表
- 7. HashTable（哈希表）和HashMap簡單分析
- 8. 哈希表，HashMap，Hashtable，ConcurrentHashMap，WeakHashMap，ThreadLocal，集合
- 9. 哈希與哈希表
- 10. 哈希函數 哈希表
- 更多相關文章...
- • C# 哈希表（Hashtable） - C#教程
- • Redis哈希數據結構和常用命令 - Redis教程
- • RxJava操作符（二）Transforming Observables
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。