簡(jiǎn)單來(lái)說(shuō)，HashMap由數(shù)組+鏈表組成的，數(shù)組是HashMap的主體，鏈表則是主要為了解決哈希沖突而存在的.
在分析源碼之前讓我們來(lái)看下源碼中一些重要的變量。
//table是一個(gè)Entry[]數(shù)組類型，而Entry實(shí)際上就是一個(gè)單向鏈表。哈希表的"key-value鍵值對(duì)"都是存儲(chǔ)在Entry數(shù)組中的。
transient Node<K,V>[] table;
//size是HashMap的大小，它是HashMap保存的鍵值對(duì)的數(shù)量。
transient int size;
//threshold是HashMap的閾值，用于判斷是否需要調(diào)整HashMap的容量。threshold的值="容量*加載因子"，當(dāng)HashMap中存儲(chǔ)數(shù)據(jù)的數(shù)量達(dá)到threshold時(shí)，就需要將HashMap的容量加倍。
int threshold;
//loadFactor就是加載因子。
final float loadFactor;
//modCount是用來(lái)實(shí)現(xiàn)fail-fast機(jī)制的。
transient int modCount;
//一個(gè)桶的樹(shù)化閾值:如果一個(gè)桶中的元素個(gè)數(shù)超過(guò)此閾值，就會(huì)用紅黑樹(shù)來(lái)替換鏈表
static final int TREEIFY_THRESHOLD = 8;
//一個(gè)樹(shù)的鏈表還原閾值:當(dāng)擴(kuò)容時(shí)，桶中元素個(gè)數(shù)小于這個(gè)值就會(huì)把樹(shù)形的桶元素還原（切分）為鏈表結(jié)構(gòu)
static final int UNTREEIFY_THRESHOLD = 6;
//哈希表的最小樹(shù)形化容量（樹(shù)化的前提）
static final int MIN_TREEIFY_CAPACITY = 64;
下面我們從一個(gè)簡(jiǎn)單的例子來(lái)觀察HashMap的結(jié)構(gòu)
public class Demo {
public static void main(String[] args) {
Map<String,Object> map = new HashMap<>();
map.put("訂單", 1);
map.put("問(wèn)問(wèn)", 2);
map.put("穩(wěn)穩(wěn)", 4);
map.put("日日", 5);
map.put("天天", 6);
map.put("夜夜", 7);
map.put("一一", 8);
map.put("噢噢", 9);
map.put("胖胖", 10);
map.put("啊啊", 11);
map.put("試試", 12);
map.put("調(diào)的", 13);
map.put("翻翻", 14);
map.put("好好", 16);
map.put("聚聚", 17);
map.put("看看", 18);
map.put("流量", 19);
map.put("信息", 21);
map.put("寶寶", 23);
map.put("明明", 25);
}
}
從第一個(gè)put開(kāi)始斷點(diǎn)，可以看到初始的HashMap的結(jié)構(gòu)為：
斷點(diǎn)向下走動(dòng)
當(dāng)HashMap添加完第一個(gè)數(shù)據(jù)后size變?yōu)榱?（容器內(nèi)已經(jīng)存了一條數(shù)據(jù)）threshold已經(jīng)變?yōu)榱?2（意味著當(dāng)HashMap中超過(guò)12個(gè)數(shù)據(jù)的時(shí)候，HashMap就會(huì)擴(kuò)容。），第一條數(shù)據(jù)存放在了數(shù)組的2號(hào)位上。
繼續(xù)向下走動(dòng)，直至HashMap中添加至13條數(shù)據(jù)。
此刻，HashMap中已經(jīng)存放了13個(gè)數(shù)據(jù)，size變?yōu)榱?3并且table的容量也由原來(lái)的16擴(kuò)大了一倍，閾值同樣的變?yōu)榱?4（32 * 0.75）
并且我們可以明顯的發(fā)現(xiàn)，明明我們已經(jīng)存放了13個(gè)數(shù)據(jù)，但是table里面卻僅僅只占了九個(gè)位置，因?yàn)榇丝逃嘞碌臄?shù)據(jù)已經(jīng)化為了鏈表的節(jié)點(diǎn)（Node）了。
講道這里讓我們?cè)賮?lái)看下Node<k , v>結(jié)構(gòu)
//用于大多數(shù)鍵值對(duì)的普通節(jié)點(diǎn)
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;//指向下一個(gè)節(jié)點(diǎn)的引用
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; }
//返回key和value的哈希值的異或運(yùn)算結(jié)果
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;
}
}
HashMap里的數(shù)據(jù)結(jié)構(gòu)是數(shù)組+鏈表的形式來(lái)存儲(chǔ)節(jié)點(diǎn)的，每個(gè)節(jié)點(diǎn)以鍵值對(duì)（Node<K,V>）的形式存儲(chǔ)，之前我么已經(jīng)說(shuō)過(guò)table數(shù)組，就是HashMap中存放值的地方，它的數(shù)據(jù)結(jié)構(gòu)是這樣的：Node<K,V>[] table；
下面我們將斷點(diǎn)走完
依照著這散列表的結(jié)構(gòu)，我們用一張圖表給畫(huà)出來(lái)：
（作者畫(huà)圖渣渣，不要太過(guò)在意~~）
對(duì)比兩幅圖應(yīng)該就能比較清楚的了解了，可以看出里面數(shù)組并不是順序往里存的，中間有很多空的桶（源碼中稱為bin），至于為啥這樣存，就讓我們來(lái)一起看下put的源代碼：
/**
* 將map中指定key和value進(jìn)行關(guān)聯(lián)，如果map中已經(jīng)存在該key的映射，則舊的值將會(huì)被替換。
* 返回該key映射的舊值，如果該key的映射不存在的話則返回null。
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* 實(shí)現(xiàn) Map.put 和相關(guān)方法
*
* @param hash key的哈希值
* @param key key
* @param value key將要映射的value
* @param onlyIfAbsent 如果是true的話，將不會(huì)改變已存在的值
* @param evict 這個(gè)參數(shù)如果為true，那么每插入一個(gè)新值，就會(huì)把鏈表的第一個(gè)元素頂出去，保持鏈表元素個(gè)數(shù)不變
*/
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)
//如果當(dāng)前table未初始化，則先重新調(diào)整大小至初始容量
n = (tab = resize()).length;
//（n-1）& hash 這個(gè)地方即根據(jù)hash求序號(hào)
if ((p = tab[i = (n - 1) & hash]) == null)
//不存在，則新建節(jié)點(diǎn)
tab[i] = newNode(hash, key, value, null);
else {
//存在
Node<K,V> e; K k;
//先找到對(duì)應(yīng)的node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
//如果是樹(shù)節(jié)點(diǎn)，則調(diào)用相應(yīng)的putVal方法
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果是鏈表則遍歷查找
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//如果沒(méi)有找到則在該鏈表新建一個(gè)節(jié)點(diǎn)掛在最后
p.next = newNode(hash, key, value, null);
//如果鏈表的長(zhǎng)度大于了桶的樹(shù)化閾值(默認(rèn)為8)，就會(huì)樹(shù)化
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;
}
}
//如果已存在該key的映射，則將值進(jìn)行替換
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//修改次數(shù)加1
++modCount;
// 如果容量超過(guò)threshold則擴(kuò)容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
總結(jié)HashMap添加元素時(shí)：
1.對(duì)key的hashCode()做一次散列，然后根據(jù)這個(gè)散列值計(jì)算index（i = (n - 1) & hash）；
2.如果沒(méi)有發(fā)生哈希沖突，則直接放到桶里；
3.如果碰撞了，以鏈表的形式掛在桶后；
4.如果因?yàn)榕鲎矊?dǎo)致鏈表過(guò)長(zhǎng)(大于等于TREEIFY_THRESHOLD)，就把鏈表轉(zhuǎn)換成紅黑樹(shù)；
5.如果節(jié)點(diǎn)已經(jīng)存在就替換
6.如果桶滿了(超過(guò)負(fù)載因子*當(dāng)前容量)，就要resize（重新調(diào)整大小并重新散列）。
為什么化樹(shù)的閾值是8？
HashCode隨機(jī)分布，當(dāng)負(fù)載因子設(shè)置成0.75時(shí)，那么在桶中元素個(gè)數(shù)的概率大致符合0.5的泊松分布，桶中元素個(gè)數(shù)達(dá)到8的概率小于千萬(wàn)分之一，因?yàn)檗D(zhuǎn)化為紅黑樹(shù)還是比較耗時(shí)耗力的操作，自然不希望經(jīng)常進(jìn)行，但如果設(shè)置得過(guò)大，將失去設(shè)置該值的意義。
/**
* 用指定初始容量和裝載因子構(gòu)造一個(gè)空的hashmap，
*/
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;
//重新計(jì)算閾值
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 用指定初始容量和默認(rèn)的裝載因子（0.75）構(gòu)造一個(gè)空的hashmap
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 用指定默認(rèn)容量（16）和默認(rèn)的裝載因子（0.75）構(gòu)造一個(gè)空的hashmap
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* 用另一個(gè)map來(lái)構(gòu)造一個(gè)新的hashmap，并保留相同的映射。新的HashMap使用默認(rèn)加載因子（0.75）和適合裝下指定map中所有映射關(guān)系的
* 初始容量。
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
看完HashMap是怎樣放入數(shù)據(jù)的，下面再讓我們來(lái)看一下它是怎樣取數(shù)據(jù)的。
/**
* 返回指定鍵映射的值，當(dāng)該key不存在的時(shí)候返回null
*/
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 根據(jù)Key查詢
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//當(dāng)table不為空，并且根據(jù)根據(jù)key生成的序號(hào)查詢到了該桶
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
//如果是第一個(gè)節(jié)點(diǎn)
return first;
if ((e = first.next) != null) {
//如果有子節(jié)點(diǎn)
if (first instanceof TreeNode)
//如果是樹(shù)節(jié)點(diǎn)，則用TreeNode的getTreeNode方法來(lái)查找相應(yīng)的key
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果是鏈表則循環(huán)遍歷該鏈表，如果匹配上則返回該節(jié)點(diǎn)
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
1.先匹配bucket里的第一個(gè)節(jié)點(diǎn)，直接命中則返回；
2.如果有沖突，則再去查詢鏈表或者樹(shù)
