HashMap詳解（jdk1.8）
本文的一部分內容是參照了 http://www.iteye.com/topic/539465， 這部分小弟沒有這位大佬講得好，但源碼的解釋大家可以看看我的，因爲大佬沒有詳細解釋，而且版本比較久遠。本文關於源碼的解析都是基於jdk1.8的。本文沒有涉及鏈表的樹化內容，水平暫時不夠。
一、HashMap的數據結構
要知道hashmap是什麼，首先要搞清楚它的數據結構，在java編程語言中，最基本的結構就是兩種，一個是數組，另外一個是模擬指針（引用），所有的數據結構都可以用這兩個基本結構來構造的，hashmap也不例外。Hashmap實際上是一個數組和鏈表的結合體（在數據結構中，一般稱之爲“鏈表散列“），請看下圖（橫排表示數組，後文源碼解析中，我們將它稱爲“桶”；縱排表示數組元素【實際上是一個鏈表】）
二、往哪裏put？
想知道put方法的詳細步驟，必須先知道在哪裏進行操作，我們知道，HashMap是一個是基於散列表的類，當然會跟hash值密不可分，下面我們詳細看看具體步驟
//桶，如1號桶，2號桶...
transient Node<K,V>[] table;
//桶中的元素類型，與鏈表的數據結構基本一致，如一號桶Node有node.next、next.next...
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;
}
.............
}
- 基本步驟：
put方法主要是對這2個元素進行操作，當put一個對象的時候：
-
先根據key的hash值得到這個元素在數組中的位置（即下標，也就是幾號桶）
-
如果這個桶中已經存放有其他元素了，那麼在同桶中的元素將以鏈表的形式存放，新加入的放在鏈頭，最先加入的放在鏈尾。
-
如果這個桶是空的，那麼這個元素就作爲桶中的第一個元素，也就是鏈表的鏈頭
從hashmap中get元素時，首先計算key的hashcode，找到數組中對應的桶，然後通過key的equals方法在桶中的鏈表找到需要的元素。從這裏我們可以想象得到，如果每個位置上的鏈表只有一個元素，那麼hashmap的get效率將是最高的
- 定位方法詳解與細節
我們可以看到在hashmap中要找到元素相應的桶，需要根據key的hash值來求得對應數組中的位置。如何計算這個位置就是hash算法。前面說過hashmap的數據結構是數組和鏈表的結合，所以我們當然希望這個hashmap裏面的元素位置儘量的分佈均勻些，儘量使得每個位置上的元素數量只有一個，那麼當我們用hash算法求得這個位置的時候，馬上就可以知道對應位置的元素就是我們要的，而不用再去遍歷鏈表。
所以我們首先想到的就是對hashcode的數組長度取模運算，這樣一來，元素的分佈相對來說是比較均勻的。但是，“模”運算的消耗還是比較大的，能不能找一種更快速，消耗更小的方式那？HashMap是這樣做的：
// i：數組下標， n：數組長度，hash：元素的hash值
i = (n - 1) & hash
首先算得key的hashcode值，然後跟數組的長度-1做一次“與”運算（&）。看上去很簡單，其實比較有玄機。比如數組的長度是2的4次方，那麼hashcode就會和2的4次方-1做“與”運算。很多人都有這個疑問，爲什麼hashmap的數組初始化大小都是2的次方大小時，hashmap的效率最高，我以2的4次方舉例，來解釋一下爲什麼數組大小爲2的冪時hashmap訪問的性能最高。
看下圖，左邊兩組是數組長度爲16（2的4次方），右邊兩組是數組長度爲15。兩組的hashcode均爲8和9，但是很明顯，當它們和1110“與”的時候，產生了相同的結果，也就是說它們會定位到數組中的同一個位置上去，這就產生了碰撞，8和9會被放到同一個鏈表上，那麼查詢的時候就需要遍歷這個鏈表，得到8或者9，這樣就降低了查詢的效率。同時，我們也可以發現，當數組長度爲15的時候，hashcode的值會與14（1110）進行“與”，那麼最後一位永遠是0，而0001，0011，0101，1001，1011，0111，1101這幾個位置永遠都不能存放元素了，空間浪費相當大，更糟的是這種情況中，數組可以使用的位置比數組長度小了很多，這意味着進一步增加了碰撞的機率，減慢了查詢的效率！
當數組長度爲2的n次冪的時候，不同的key算得得index相同的機率較小，那麼數據在數組上分佈就比較均勻，也就是說碰撞的機率小，相對的，查詢的時候就不用遍歷某個位置上的鏈表，這樣查詢效率也就較高了。
說到這裏，我們再回頭看一下hashmap中默認的數組大小是多少，查看源代碼可以得知是16，爲什麼是16，而不是15，也不是20呢，看到上面的解釋之後我們就清楚了吧，顯然是因爲16是2的整數次冪的原因，在小數據量的情況下16比15和20更能減少key之間的碰撞，而加快查詢的效率。
指的注意的是，就算你指定初始容量不是2的冪次方，它也會想辦法將你的值變成離你給的值最近的2次方值，比如你給定初始容量爲29，它會在構造時變成32
//構造函數調用
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;
}
三、put方法源碼分析：
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;
//1.判斷數組是否爲空
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; //爲空，則重新制定容量
//2.根據參數的hash值判斷對應桶是否爲空
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); //若爲空，則桶的第一個元素就是參數
// 3.其他情況，即數組不爲空，且找到了對應的桶，且桶中的元素不爲空
else {
Node<K,V> e; K k;
//4.判斷桶的第一個元素，即鏈頭的hash值與參數的hash值是否一致，然後再通過equals方法與==比對2個元素，都一致才爲視爲同一個鍵
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p; //如果一致，則將鏈頭賦給e（第二步將鏈頭賦給了p）
//5. 如果這個桶已經樹化了，即鏈表已經樹化，則調用樹節點的put方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//6. 其他情況，即參數與鏈頭不一致，則依次比對鏈表中其他元素
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;
}
//判斷下一個元素是否與參數一致（在上面 e=p.next）
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果桶中已經存在了鍵一致的元素，則覆蓋舊value，返回舊value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount；
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
四、resize方法源碼解析
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;
}
// 將數組大小擴大一倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 將閾值擴大一倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // 對應使用 new HashMap(int initialCapacity) 初始化後，第一次 put 的時候
newCap = oldThr;
else {// 對應使用 new HashMap() 初始化後，第一次 put 的時候
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;
// 用新的數組大小初始化新的數組
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab; // 如果是初始化數組，到這裏就結束了，返回 newTab 即可
if (oldTab != null) {
// 開始遍歷原數組，進行數據遷移。
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 {
// 這塊是處理鏈表的情況，
// 需要將此鏈表拆成兩個鏈表，放到新的數組中，並且保留原來的先後順序
// loHead、loTail 對應一條鏈表，hiHead、hiTail 對應另一條鏈表，代碼還是比較簡單的
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;
// 第二條鏈表的新的位置是 j + oldCap，這個很好理解
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
五、hash方法：
之前我們將定位的時候，說到是用元素的hash值和length-1取hash值，這裏的hash值是通過hash()方法計算的，
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
這裏的hash方法簡單來說就是高16位異或低16位，這樣的好處就是混合了原hashcode的高低位信息，以此來增大隨機性，也就增大了hashmap的元素存儲隨機性，這也就是HashMap解決hash碰撞的方法——拉鍊法