hashMap是一個經常用的數據結構了，本文主要分析下jdk7與jdk8的源碼還有他們的區別
我們帶着問題去看源碼：
- 1.7與1.8的區別有哪些？
- 爲什麼數組的角標運算是&而不是%？
- 1.7爲什麼會出現“死鎖”的原因？
- 是否能存入null類型的key和vaule?
- 爲什麼擴容或者數組的length一定是2的冪數？
- 爲什麼要對key進行二次hash？
- 爲什麼會拋出ConcurrentModificationException
我們先解答一下這些問題，然後在源碼中去探究一下：
1、1.7與1.8的區別
1.7數據結構爲 ：數組+鏈表 儲存類 Entry類 插入時候是鏈表頭部插入（後面稱頭插法），擴容時會導致之前鏈表儲存的元素顛倒順序。例如插入時候爲： a b c d e..... 擴容會導致變爲 e d c b a;
1.8數據結構爲：數組+鏈表+紅黑樹 儲存類 Node類 並且多了一個實現Node累的子類用於儲存TreeNode類，當鏈表的長度大於閾值8的時候轉換成紅黑樹，而樹結構在減少達到6的時候，會轉換成鏈表。爲什麼要引入紅黑樹，利用了紅黑樹快速增刪改查的特點，解決了 hash碰撞後鏈表過長導致索引效率慢的問題。
二次hash方法不一樣，具體看代碼。
這裏我們先回答第6個問題
6、爲什麼要對key進行二次hash？
哈希值一般是int類型，2進制的32帶符號的範圍可以取到：-（2^31）~~2^31-1 而hashmap 的容量最小值 =初始默認值 =16，
最大值取到 = 2^30 所以取值範圍已經限定了。
如果不就行二次 hash，參與運算的只有低位的幾位數字，會更容易導致hash衝突，爲了hash值更加均勻。從而提高對應數組存儲下標位置的隨機性 & 均勻性，最終減少Hash衝突
我們寫代碼時候，我們有可能自己會複寫hash值，爲了更加嚴謹，也是爲了減少hash衝突，所以每個版本的源碼，都會進行二次hash，每個版本的算法有可能不同。
2、爲什麼數組的角標運算是&而不是%？ 5、 爲什麼擴容或者數組的length一定是2的冪數？
我們來一起回答這2個問題，看來我們要舉個例子。智商高的就不用看了
假設數組的length爲 16 我們根據哈希碼 與運算（&） （數組長度-1）這個公式來，爲了偷懶就寫了8位；
16的 二進制爲 0001 0000
15的 二進制爲 0000 1111
&
假設hash值爲 1111 0011
-----------------------------------------
0000 0011
我們是不是發現了一個規律 取值範圍和我們的低4位有關係，取值範圍爲0~15是不是正符合我們的心意，這也就是數組的length一定是2的冪數，系統在擴容的也是按照2倍的進行擴容。
- %效率低，沒有位運算&效率高
- 數組長度一定是2的冪數
- 使得哈希值的高位歸零、只保留低位值作爲數組下標，解決哈希值與數組大小範圍不匹配
- 爲了讓哈希值的高位也參加運算，所以會進行二次hash 爲了避免哈希衝突
3、1.7爲什麼會出現“死鎖”的原因？
首先這個問題就是個僞命題，我們都知道hashMap是線程不安全的，也就是無鎖的。所以是不可能出現死鎖的現象。在這個問題上我也打上了一個引號。 發生的背景是：在數組進行擴容的時候，在多線程的操作下，1.7是頭插法（1、1.7與1.8的區別已經提到），所以在擴容轉移到新數組的時候，會出現逆序的現象。多線程中會出現死循環的問題。而在1.8已經修復了這個問題，1.8都是尾插法，無論是put還是在擴容的時候。
4、是否能存入null類型的key和vaule?
是可以的，只能有一個key爲null，當key爲null時 hash值爲0，允許多個vaule爲null
7、爲什麼會拋出ConcurrentModificationException？
原因是如果在迭代過程中出現多併發操作（多線程增刪等等），就會拋出ConcurrentModificationException異常，實現的原理是內部有個modCount成員變量，每修改一次hashmap的內容，都將增加該變量值，在迭代器初始化時將該值賦值給迭代器的mc，判斷modCount是否與mc相等，若相等則表示沒有其它線程在操作，反而不相等 表明有其它在操作該集合，則拋出異常。我們來看下1.8的源碼；
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
.........
transient int modCount;
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//只要有操作的都會 ++modCount
++modCount;
return null;
}
public void clear() {
Node<K,V>[] tab;
modCount++;
}
............
下面我們來看那個拋出的異常吧：
final class KeySet extends AbstractSet<K> {
public final void forEach(Consumer<? super K> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
//----------------------賦值-------------------------
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.key);
}
//--------------------------判斷---------------------
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
final class Values extends AbstractCollection<V> {
public final int size() { return size; }
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
}
我們已經對上面的問題進行了一一的回答，現在讓我們來進入源碼來具體看實現：
1、類的的關係
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
具體總結下：類關係就不總結了，上面的繼承結構已經寫的很清楚了。可以通過Collections工具類synchronizedMap獲取一個線程安全的HashMap,不保證有序
2、數組元素 & 鏈表節點的 實現類
HashMap中的數組元素 & 鏈表節點 採用Node類 實現與JDK 1.7的對比（Entry類），僅僅只是名字不同1.8新增了
TreeNode類來實現紅黑樹的
/**
* Node = HashMap的內部類，實現了Map.Entry接口，本質是 = 一個映射(鍵值對)
* 實現了getKey()、getValue()、equals(Object o)和hashCode()等方法
**/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; // 哈希值，HashMap根據該值確定記錄的位置
final K key; // key
V value; // 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;
}
public final K getKey() { return key; } // 返回 與 此項 對應的鍵
public final V getValue() { return value; } // 返回 與 此項 對應的值
public final String toString() { return key + "=" + value; }
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
/**
* hashCode（）
*/
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
/**
* equals（）
* 作用：判斷2個Entry是否相等，必須key和value都相等，才返回true
*/
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;
}
}
TreeNode 類
/**
* 紅黑樹節點 實現類：繼承自LinkedHashMap.Entry<K,V>類
*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
// 屬性 = 父節點、左子樹、右子樹、刪除輔助節點 + 顏色
TreeNode<K,V> parent;
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev;
boolean red;
// 構造函數
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
// 返回當前節點的根節點
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
3、重要的成員屬性
HashMap中的主要參數 同JDK 1.7，即：容量、加載因子、擴容閾值- 但由於數據結構中引入了 紅黑樹，故加入了 與紅黑樹相關的參數。
/**
* 主要參數 同 JDK 1.7
* 即：容量、加載因子、擴容閾值（要求、範圍均相同）
*/
// 1. 容量（capacity）： 必須是2的冪 & <最大容量（2的30次方）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默認容量 = 16 = 1<<4 = 00001中的1向左移4位 = 10000 = 十進制的2^4=16
static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量 = 2的30次方（若傳入的容量過大，將被最大值替換）
// 2. 加載因子(Load factor)：HashMap在其容量自動增加前可達到多滿的一種尺度
final float loadFactor; // 實際加載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默認加載因子 = 0.75
// 3. 擴容閾值（threshold）：當哈希表的大小 ≥ 擴容閾值時，就會擴容哈希表（即擴充HashMap的容量）
// a. 擴容 = 對哈希表進行resize操作（即重建內部數據結構），從而哈希表將具有大約兩倍的桶數
// b. 擴容閾值 = 容量 x 加載因子
int threshold;
// 4. 其他
transient Node<K,V>[] table; // 存儲數據的Node類型 數組，長度 = 2的冪；數組的每個元素 = 1個單鏈表
transient int size;// HashMap的大小，即 HashMap中存儲的鍵值對的數量
/**
* 與紅黑樹相關的參數
*/
// 1. 桶的樹化閾值：即 鏈表轉成紅黑樹的閾值，在存儲數據時，當鏈表長度 > 該值時，則將鏈表轉換成紅黑樹
static final int TREEIFY_THRESHOLD = 8;
// 2. 桶的鏈表還原閾值：即 紅黑樹轉爲鏈表的閾值，當在擴容（resize（））時（此時HashMap的數據存儲位置會重新計算），在重新計算存儲位置後，當原有的紅黑樹內數量 < 6時，則將 紅黑樹轉換成鏈表
static final int UNTREEIFY_THRESHOLD = 6;
// 3. 最小樹形化容量閾值：即 當哈希表中的容量 > 該值時，才允許樹形化鏈表 （即 將鏈表 轉換成紅黑樹）
// 否則，若桶內元素太多時，則直接擴容，而不是樹形化
// 爲了避免進行擴容、樹形化選擇的衝突，這個值不能小於 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
總結一下：核心參數新增
- 桶的樹化閾值：鏈表轉化成樹形的閾值，在存儲數據時，當鏈表長度>該值時，將鏈表轉換成紅黑樹
- 桶的鏈表還原閾值：樹轉化成鏈表的的閾值，當在擴容resize()時，此時會重新計算數據儲存的位置，當計算完畢後。如果原有的樹結構的數量<6時，則將紅黑樹轉換成鏈表。
4、構造函數
如果我們明確知道容量的大小，最好是使用指定長度的構造參數，減少擴容
/**
* 源碼分析：主要是HashMap的構造函數 = 4個
* 僅貼出關於HashMap構造函數的源碼
*/
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable{
// 省略上節闡述的參數
/**
* 構造函數1：默認構造函數（無參）
* 加載因子 & 容量 = 默認 = 0.75、16
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
/**
* 構造函數2：指定“容量大小”的構造函數
* 加載因子 = 默認 = 0.75 、容量 = 指定大小
*/
public HashMap(int initialCapacity) {
// 實際上是調用指定“容量大小”和“加載因子”的構造函數
// 只是在傳入的加載因子參數 = 默認加載因子
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 構造函數3：指定“容量大小”和“加載因子”的構造函數
* 加載因子 & 容量 = 自己指定
*/
public HashMap(int initialCapacity, float loadFactor) {
// 指定初始容量必須非負，否則報錯
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// HashMap的最大容量只能是MAXIMUM_CAPACITY，哪怕傳入的 > 最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 填充比必須爲正
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 設置 加載因子
this.loadFactor = loadFactor;
// 設置 擴容閾值
// 注：此處不是真正的閾值，僅僅只是將傳入的容量大小轉化爲：>傳入容量大小的最小的2的冪，該閾值後面會重新計算
// 下面會詳細講解 ->> 分析1
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 構造函數4：包含“子Map”的構造函數
* 即 構造出來的HashMap包含傳入Map的映射關係
* 加載因子 & 容量 = 默認
*/
public HashMap(Map<? extends K, ? extends V> m) {
// 設置容量大小 & 加載因子 = 默認
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 將傳入的子Map中的全部元素逐個添加到HashMap中
putMapEntries(m, false);
}
}
}
- 此處僅用於接收初始容量大小（
capacity）、加載因子(Load factor)，但仍無真正初始化哈希表，即初始化存儲數組table - 此處先給出結論：真正初始化哈希表（初始化存儲數組
table）是在第1次添加鍵值對時，即第1次調用put（）時。
5、put方法
/**
* 源碼分析：主要分析HashMap的put函數
*/
public V put(K key, V value) {
// 1. 對傳入數組的鍵Key計算Hash值 ->>分析1
// 2. 再調用putVal（）添加數據進去 ->>分析2
return putVal(hash(key), key, value, false, true);
}
- 分析1：hash（key）
**
* 分析1：hash(key)
* 作用：計算傳入數據的哈希碼（哈希值、Hash值）
* 該函數在JDK 1.7 和 1.8 中的實現不同，但原理一樣 = 擾動函數 = 使得根據key生成的哈希碼（hash值）分佈更加均勻、更具備隨機性，避免出現hash值衝突（即指不同key但生成同1個hash值）
*/
// JDK 1.7實現：將 鍵key 轉換成 哈希碼（hash值）操作 = 使用hashCode() + 4次位運算 + 5次異或運算（9次擾動）
static final int hash(int h) {
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
// JDK 1.8實現：將 鍵key 轉換成 哈希碼（hash值）操作 = 使用hashCode() + 1次位運算 + 1次異或運算（2次擾動）
// 1. 取hashCode值： h = key.hashCode()
// 2. 高位參與低位的運算：h ^ (h >>> 16)
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
// a. 當key = null時，hash值 = 0，所以HashMap的key 可爲null
// 注：對比HashTable，HashTable對key直接hashCode（），若key爲null時，會拋出異常，所以HashTable的key不可爲null
// b. 當key ≠ null時，則通過先計算出 key的 hashCode()（記爲h），然後 對哈希碼進行 擾動處理： 按位 異或（^） 哈希碼自身右移16位後的二進制
}
/**
* 計算存儲位置的函數分析：indexFor(hash, table.length)
* 注：該函數僅存在於JDK 1.7 ，JDK 1.8中實際上無該函數（直接用1條語句判斷寫出），但原理相同
* 爲了方便講解，故提前到此講解
*/
static int indexFor(int h, int length) {
return h & (length-1);
// 將對哈希碼擾動處理後的結果 與運算(&) （數組長度-1），最終得到存儲在數組table的位置（即數組下標、索引）
}
- 分析2：putVal(hash(key), key, value, false, true);
/**
* 分析2：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. 若哈希表的數組tab爲空，則 通過resize() 創建
// 所以，初始化哈希表的時機 = 第1次調用put函數時，即調用resize() 初始化創建
// 關於resize（）的源碼分析將在下面講解擴容時詳細分析，此處先跳過
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 2. 計算插入存儲的數組索引i：根據鍵值key計算的hash值 得到
// 此處的數組下標計算方式 = i = (n - 1) & hash，同JDK 1.7中的indexFor（），上面已詳細描述
// 3. 插入時，需判斷是否存在Hash衝突：
// 若不存在（即當前table[i] == null），則直接在該數組位置新建節點，插入完畢
// 否則，代表存在Hash衝突，即當前存儲位置已存在節點，則依次往下判斷：a. 當前位置的key是否與需插入的key相同、b. 判斷需插入的數據結構是否爲紅黑樹 or 鏈表
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); // newNode(hash, key, value, null)的源碼 = new Node<>(hash, key, value, next)
else {
Node<K,V> e; K k;
// a. 判斷 table[i]的元素的key是否與 需插入的key一樣，若相同則 直接用新value 覆蓋 舊value
// 判斷原則：equals（）
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// b. 繼續判斷：需插入的數據結構是否爲紅黑樹 or 鏈表
// 若是紅黑樹，則直接在樹中插入 or 更新鍵值對
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); ->>分析3
// 若是鏈表,則在鏈表中插入 or 更新鍵值對
// i. 遍歷table[i]，判斷Key是否已存在：採用equals（） 對比當前遍歷節點的key 與 需插入數據的key：若已存在，則直接用新value 覆蓋 舊value
// ii. 遍歷完畢後仍無發現上述情況，則直接在鏈表尾部插入數據
// 注：新增節點後，需判斷鏈表長度是否>8（8 = 桶的樹化閾值）：若是，則把鏈表轉換爲紅黑樹
else {
for (int binCount = 0; ; ++binCount) {
// 對於ii：若數組的下1個位置，表示已到表尾也沒有找到key值相同節點，則新建節點 = 插入節點
// 注：此處是從鏈表尾插入，與JDK 1.7不同（從鏈表頭插入，即永遠都是添加到數組的位置，原來數組位置的數據則往後移）
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 插入節點後，若鏈表節點>數閾值，則將鏈表轉換爲紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash); // 樹化操作
break;
}
// 對於i
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 更新p指向下一個節點，繼續遍歷
p = e;
}
}
// 對i情況的後續操作：發現key已存在，直接用新value 覆蓋 舊value & 返回舊value
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // 替換舊值時會調用的方法（默認實現爲空）
return oldValue;
}
}
++modCount;
// 插入成功後，判斷實際存在的鍵值對數量size > 最大容量threshold
// 若 > ，則進行擴容 ->>分析4（但單獨講解，請直接跳出該代碼塊）
if (++size > threshold)
resize();
afterNodeInsertion(evict);// 插入成功時會調用的方法（默認實現爲空）
return null;
}
/**
* 分析3：putTreeVal(this, tab, hash, key, value)
* 作用：向紅黑樹插入 or 更新數據（鍵值對）
* 過程：遍歷紅黑樹判斷該節點的key是否與需插入的key 相同：
* a. 若相同，則新value覆蓋舊value
* b. 若不相同，則插入
*/
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
總結如下：
- 首先判斷數組table是否初始化，否則通過resize()進行初始化，設置容量、加載因子、擴容閾值
- 計算存放的位置，即table的索引，公式：hash&(數組長度-1)
- 在數組中插入or更新數據，首先判斷數組上是否有數據，如果沒有直接在該位置新建節點（這點和1.7相同），完成插入。
- 上面有數據，視爲hash衝突，進入下一步判斷，當前的位置的key 是否與需要插入key的相同，若相同則直接使用新的value覆蓋舊的value,完成插入。否則視爲插入失敗。
- 表明有hash衝突，優先判斷當前的節點是否是樹節點，如果是樹節點，在樹中插入或者更新數據。遍歷紅黑樹，判斷節點key是否與要插入的key相等，相等覆蓋跟新數據。不相等新建一個節點，插入。
- 如果是鏈表節點：遍歷table[i]中的鏈表節點，判斷key是否已經存在，如果存在則用新value覆蓋舊的value完成數據更新。如果不存在則在尾部插入（這點與1.7不相同，1.7採用的是頭插法） 插入完成後，判斷是否需要轉化成樹結構，如果鏈表>8則轉化， 當size>threshold則進行擴容，重新計算舊數組的數據儲存的位置。
6、擴容機制 rize()方法
源碼分析：
/**
* 分析4：resize（）
* 該函數有2種使用情況：1.初始化哈希表 2.當前數組容量過小，需擴容
*/
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // 擴容前的數組（當前數組）
int oldCap = (oldTab == null) ? 0 : oldTab.length; // 擴容前的數組的容量 = 長度
int oldThr = threshold;// 擴容前的數組的閾值
int newCap, newThr = 0;
// 針對情況2：若擴容前的數組容量超過最大值，則不再擴充
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; // 通過右移擴充2倍
}
// 針對情況1：初始化哈希表（採用指定 or 默認值）
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 計算新的resize上限
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;
if (oldTab != null) {
// 把每個bucket都移動到新的buckets中
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 { // 鏈表優化重hash的代碼塊
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);
// 原索引放到bucket裏
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket裏
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
7.獲取方法 public V get(Object key)
源碼分析
/**
* 函數原型
* 作用：根據鍵key，向HashMap獲取對應的值
*/
map.get(key)；
/**
* 源碼分析
*/
public V get(Object key) {
Node<K,V> e;
// 1. 計算需獲取數據的hash值
// 2. 通過getNode（）獲取所查詢的數據 ->>分析1
// 3. 獲取後，判斷數據是否爲空
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 分析1：getNode(hash(key), key))
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 1. 計算存放在數組table中的位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 4. 通過該函數，依次在數組、紅黑樹、鏈表中查找（通過equals（）判斷）
// a. 先在數組中找，若存在，則直接返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// b. 若數組中沒有，則到紅黑樹中尋找
if ((e = first.next) != null) {
// 在樹中get
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// c. 若紅黑樹中也沒有，則通過遍歷，到鏈表中尋找
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
總結：
通過key計算出需要獲取數據的hash值，與put()方法計算相同。計算數組table 中的位置，依次在數組中、紅黑樹、鏈表中查找，先判斷hash值是否相同，在比較key是否相同，找到則返回數據，如果沒有找到則返回null
本次源碼分析完畢，擴容機制後期在補充。如有轉載請，說明出處。
參考資料：https://www.jianshu.com/p/8324a34577a0 流程圖畫的非常好