看源碼之前首先要知道HashMap底層存儲結構
默認參數，構造方法
//默認的table大小，左移4位等於16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//table最大長度
static final int MAXIMUM_CAPACITY = 1 << 30;
//默認的負載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//樹化閾值，鏈表長度到達8
static final int TREEIFY_THRESHOLD = 8;
//樹降級爲鏈表的閾值6，樹的子節點到達6時，降級爲鏈表
static final int UNTREEIFY_THRESHOLD = 6;
//樹化的另一個參數，當哈希表中的所有元素超過64時，纔會允許樹化
static final int MIN_TREEIFY_CAPACITY = 64;
//定義哈希表
transient Node<K,V>[] table;
//
transient Set<Map.Entry<K,V>> entrySet;
//當前哈希表的元素個數
transient int size;
//當前哈希表結構修改次數
transient int modCount;
//擴容閾值，當哈希表中的元素超過閾值時，觸發擴容
int threshold;
//負載因子 用於計算擴容閾值，threshold=loadFactor*table大小
final float loadFactor;
//tableSizeFor的作用：計算大於等於當前cap的一個數字，並且這個數一定時二的次方數
static final int tableSizeFor(int cap) {//cap=10的話
int n = cap - 1;//n-1=9，
n |= n >>> 1;//9轉換二進制0b1001, 0b1001|0b0100=>0b1101
n |= n >>> 2;//0b1101|0b0001=>0b1111
n |= n >>> 4;//0b1111|0b0000=>0b1111
n |= n >>> 8;//0b1111|0b0000=>0b1111
n |= n >>> 16;//0b1111|0b0000=>0b1111
//0b1111=>15 因爲15>0 又因爲15<MAXIMUM_CAPACITY 返回return 15+1 返回16
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
//構造方法1 兩個參數（表格大小，負載因子）
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;
//把initialCapacity轉換爲一個大於等於initialCapacity二的次方數
this.threshold = tableSizeFor(initialCapacity);
}
//構造方法2，套娃，構造方法1
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//構造方法3，無參構造方法
public HashMap() {
//所有的其他參數都是默認參數
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//構造方法4
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
map-put過程形象圖
put方法
/**
作用：讓key的hash的高16位也參與路由運算（[lengh-1&h]=index），擾動函數
假設 h=0b 0010 0101 1010 1100 0011 1111 0010 1110
0b 0010 0101 1010 1100 0011 1111 0010 1110
^(異或，相同等於0，不同爲一)
0b 0000 0000 0000 0000 0010 0101 1010 1100（h>>>16）
=> 0010 0101 1010 1100 0001 1010 1000 0010
爲什麼要高16位參與運算呢？
在table長度還不是很高的情況下，讓高16位也參與路由運算（[lengh-1&h]=index），使散列表更加鬆散，降低hash碰撞
*/
static final int hash(Object key) {
int h;
//key=null返回0
//key1=null返回key.hashCode()) ^ (h >>> 16)
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//onlyIfAbsent=>如果散列表中已經存在某一個key,就不插入了，一般的話都是傳入false，就是key有的話替換，沒有的話傳入一個新的
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
//tab：引用當前hashMap的散列表
Node<K,V>[] tab;
//p:表示當前散列表的元素
Node<K,V> p;
//n:表示散列表數組的長度 ,i:表示路由尋址的結果
int n, i;
//延遲初始化邏輯，第一次調用putVal時會初始化hashMap對象中最耗費內存的散列表，
//（tab = table) == null說明table=null,還沒有進行初始化
if ((tab = table) == null || (n = tab.length) == 0)
//resize（）創建散列表
//爲什麼要在put的時候創建散列表呢，
//這是一個懶加載機制，比如說我們新建一個hashMap時，只是放着，不存數據，
//，只有我們往裏面加入數據的時候，纔會新建散列表初始化，這樣就節省了內存空間
n = (tab = resize()).length;
// 最簡單的一種情況：尋址找到的桶位，剛好是null,這個時候，直接將當前的k-v=>node 扔進去就可以離
//n在上面語句判斷賦值的，(n - 1) & hash路由算法，判斷散列表i位置元素==null
if ((p = tab[i = (n - 1) & hash]) == null)
//直接把key,value新建節點
tab[i] = newNode(hash, key, value, null);
else {
//e:node臨時元素
//k:表示臨時的一個key
Node<K,V> e; K k;
//p在上面語句判斷賦值，
//（p.hash == hash 表示桶位中的該元素，與你當前插入的元素的key完全一致，表示後續需要進行替換操作
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
//p賦值給e,現在e爲一個與當前要插入的key-value一致的key的元素
e = p;
//如果是紅黑樹的話
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//鏈表情況，而且鏈表的頭元素，與我們要插入的key不一致
for (int binCount = 0; ; ++binCount) {
//(e = p.next) == null條件成立說明，鏈表迭代到末尾最後一個元素了，也沒有找到與要插入的key一致的node
if ((e = p.next) == null) {
//那麼就將node插入到當前鏈表的末尾
p.next = newNode(hash, key, value, null);
//觸發樹化操作：如果鏈表的長度達到樹化標準了
//（TREEIFY_THRESHOLD=8，鏈表長度達到8，不算數組的長度就是8-1=7）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//樹化函數
treeifyBin(tab, hash);
break;
}
//條件成立的話，說明找到了相同key的node元素，需要進行特換操作
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
break;
//下一次循環
p = e;
}
}
//條件成立，說明找到一個與你插入元素key完全一直的元素，需要進行替換操作
if (e != null) { // existing mapping for key
V oldValue = e.value;
//onlyIfAbsent =false !onlyIfAbsent=true
if (!onlyIfAbsent || oldValue == null)
//把值覆寫
e.value = value;
afterNodeAccess(e);
//返回覆蓋後的值
return oldValue;
}
}
//表示散列表結構修改的次數。替換不算
++modCount;
//插入新元素。size自增，如果自增後的值大於擴容閾值，則觸發擴容
if (++size > threshold)
//擴容操作
resize();
afterNodeInsertion(evict);
return null;
}
擴容-鏈表處理
resize()擴容方法
//爲什麼需要擴容
//爲了解決哈希衝突導致的鏈化影響查詢效率的問題，擴容會緩解該問題
final Node<K,V>[] resize() {
//oldTab 引用擴容前的hash表
Node<K,V>[] oldTab = table;
//oldCap ：表示擴容前table數組的長度，oldTab ==null,是第一次沒有放數據時是null
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldThr :表示擴容之前的擴容閾值，觸發本次擴容的閾值
int oldThr = threshold;
//newCap:擴容之後的table數組的大小
//newThr:擴容之後，下次再次觸發擴容的閾值
int newCap, newThr = 0;
//條件如果成立：說明hashMap中的散列表已經初始化過了，這是一次正常擴容
if (oldCap > 0) {
//擴容之前的table數組大小，已經達到最大閾值（1<<30），則不擴容，且設置條件爲int最大值(0x7fffffff)
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//newCap = oldCap << 1:表示oldCap 左移一位賦值給newCap,左移一位就表示乘了一個2次方
//newCap < 數組最大值限制（1<<30），且擴容之前的閾值>=16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
//這種情況下，則下次擴容的閾值，等於當前閾值的翻倍
newThr = oldThr << 1; // double threshold
}
//oldCap==0，說明hashMap 中的散列表是null(還沒有初始化)
//1. new HashMap(int initialCapacity, float loadFactor)
//2. new HashMap(int initialCapacity)
//3. new HashMap(map)並且map有數據
else if (oldThr > 0) // initial capacity was placed in threshold
//把oldThr賦值給新的數組大小（oldThr是通過tableSizeFor計算出來的 所以 一定是一個二的次方數）
newCap = oldThr;
//oldCap==0 ，oldThr==0這個是table數組大小爲0，擴容閾值也爲0
//new HashMap()；//無參構造時會出現這種情況
else { // zero initial threshold signifies using defaults
//默認數組大小16賦值newCap
newCap = DEFAULT_INITIAL_CAPACITY;
//擴容閾值等於，負載因子*默認數組大小16=12賦值給newThr
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//什麼時候newThr會等於0？
//1.當你自定義的 擴容閾值<16時
//2. oldThr > 0並且oldCap==0時
if (newThr == 0) {
//這種情況，就需要自己計算下次擴容閾值了 計算方法很簡單 新的數組大小*負載因子
float ft = (float)newCap * loadFactor;
//newCap <(1<<30) ft<(1<<30) 如果條件成立則ft轉換爲int,不成立擇把int的最大值賦值給newThr
//（其實一般都是成立的）
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//newThr賦值給擴容閾值
threshold = newThr;
//創建出一個更長更大的數組newTab
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//賦值
table = newTab;
//oldTab != null 說明hashMap本次擴容之前，table不爲null
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
//當前node節點
Node<K,V> e;
//(e = oldTab[j]) != null，說明當前桶位有數據，但是數據具體是數據，還是鏈表，還是紅黑樹，並不知道
if ((e = oldTab[j]) != null) {
//方便JVM GC時回收內存
oldTab[j] = null;
//第一種情況：說明這個桶就一個元素，還沒有生成鏈表，
//這是直接計算出當前元素應存放在新數組中的位置，然後扔進去就可以了
if (e.next == null)
//把這個e值賦值給尋址算法後的哈希表中
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表示當鏈表的下一個元素
Node<K,V> next;
do {
//賦值
next = e.next;
//1.hash->.... ...1 1111
//2.hash->.... ...0 1111
//&
// oldCap=16 =>ob 1 0000
//1.=============>1
//2.=============>0
//(e.hash & oldCap) == 0說明hash的高位等於0，則表示當前這個元素要放到低位鏈中
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置空
loTail.next = null;
newTab[j] = loHead;
}
//
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}