HashMap筆記(JDK 1.7 & JDK 1.8)
內容參考自:(感謝作者,僅學習整合,如侵必刪)
文章目錄
- HashMap筆記(JDK 1.7 & JDK 1.8)
- 一、簡介
- 二、數據結構(1.7 和1.8 有主要差異)
- 三、具體使用
- 四、基礎知識:HashMap中的重要參數(7&8基本相同)
- 五、源碼分析
- 1、步驟1:聲明一個HashMap的對象
- 2、步驟2:向HashMap添加數據(成對 放入 鍵 - 值對)(7&8主要差異)
- 分析1:hash(key)!!7&8差異
- 問題1:爲什麼不直接採用經過hashCode()處理的哈希碼 作爲 存儲數組table的下標位置?
- 問題2:爲什麼採用 哈希碼 與運算(&) (數組長度-1) 計算數組下標?
- 問題3:爲什麼在計算數組下標前,需對哈希碼進行二次處理:擾動處理?
- 分析2:putVal(hash(key), key, value, false, true);
- 主要講解點1:計算完存儲位置後,具體該如何存放數據到哈希表中
- 主要講解點2:擴容機制(即 resize()函數)
- ==常考點:1.7 鏈表 **死循環** 問題==
- ==1.8 擴容時,數據存儲位置重新計算的方式==
- 總結
- 3、步驟3:從HashMap中獲取數據
- 4、步驟4:對HashMap的其他操作
一、簡介
1、類定義
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
2、主要介紹
二、數據結構(1.7 和1.8 有主要差異)
1、具體描述
1.7 HashMap 和 1.8 HashMap 有 主要不同
1.7 HashMap 採用的數據結構 = 數組(主)+單鏈表(副),也稱拉鍊法,具體描述如下:
結構 | 描述 | 備註 |
---|---|---|
數組 (主) |
- 核心底層 = 1個數組( table[] ) (又稱:哈希數組) - 數組下標 = 進過處理的鍵key的hash值 (通過hashCode()計算等一系列處理) - 數組元素 = 1個鍵值對 = 1個鏈表(頭節點) - 數組大小 = HashMap的容量(capacity) |
|
單鏈表 (副) |
- 每個鏈表 = 哈希表的桶(bucket) - 鏈表的節點值 = 1個鍵值對 - 鏈表的長度 = 桶的大小 |
- 鏈表主要用於解決哈希衝突:若不同的key計算出的hash值相同(即都需存放到數組的同一位置),由於之前該hash值的數組位置已經存放元素,則將原先位置的元素移到單鏈表中,衝突hash值對應的元素放入數組中。 (即 發生衝突時,新元素插入到鏈表頭中:新元素總是添加到數組中,舊元素移到鏈表中) - 該採用鏈表解決hash衝突的方法 = 鏈地址法 |
注:HashMap的鍵值對數量 = 數組的鍵值對 + 所有單鏈表的鍵值對 |
2、示意圖
1.8 引入了紅黑樹
關於 紅黑樹 瞭解:http://blog.csdn.net/v_july_v/article/details/6105630
附:既然紅黑樹那麼好,爲啥HashMap不全部採用紅黑樹?
- 因爲紅黑樹需要進行左旋,右旋操作, 而單鏈表不需要。紅黑樹查詢快但新增成本高,鏈表反之。
整體都是考慮時間和空間的權衡
附:爲什麼Map桶中個數超過8才轉爲紅黑樹?
- 源碼註釋得知,理想情況下的hashCode算法一個bin桶中的分佈頻率符合泊松分佈,達到8的概率已經非常小了,所以選擇了8。
當hashCode離散性很好的時候,樹型bin用到的概率非常小,因爲數據均勻分佈在每個bin中,幾乎不會有bin中鏈表長度會達到閾值。但是在隨機hashCode下,離散性可能會變差,然而JDK又不能阻止用戶實現這種不好的hash算法,因此就可能導致不均勻的數據分佈。不過理想情況下隨機hashCode算法下所有bin中節點的分佈頻率會遵循泊松分佈,我們可以看到,一個bin中鏈表長度達到8個元素的概率爲0.00000006,幾乎是不可能事件。
Because TreeNodes are about twice the size of regular nodes, we
use them only when bins contain enough nodes to warrant use
(see TREEIFY_THRESHOLD). And when they become too small (due to
removal or resizing) they are converted back to plain bins. In
usages with well-distributed user hashCodes, tree bins are
rarely used. Ideally, under random hashCodes, the frequency of
nodes in bins follows a Poisson distribution
(http://en.wikipedia.org/wiki/Poisson_distribution) with a
parameter of about 0.5 on average for the default resizing
threshold of 0.75, although with a large variance because of
resizing granularity. Ignoring variance, the expected
occurrences of list size k are (exp(-0.5)*pow(0.5, k)/factorial(k)).
The first values are:
0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006
more: less than 1 in ten million
// 1. 桶的樹化閾值:即 鏈表轉成紅黑樹的閾值,在存儲數據時,當鏈表長度 > 該值時,則將鏈表轉換成紅黑樹
static final int TREEIFY_THRESHOLD = 8;
// 2. 桶的鏈表還原閾值:即 紅黑樹轉爲鏈表的閾值,當在擴容(resize())時(此時HashMap的數據存儲位置會重新計算),在重新計算存儲位置後,當原有的紅黑樹內數量 < 6時,則將 紅黑樹轉換成鏈表
static final int UNTREEIFY_THRESHOLD = 6;
- 選擇6和8,中間有個差值7可以有效防止鏈表和樹頻繁轉換。
附:爲什麼使用紅黑樹而不是AVL樹?
- 紅黑樹整體統計性能優於AVL樹:
因爲紅黑樹本身不是完全平衡的二叉樹(只是“黑”平衡),所以插入刪除性能略高於AVL,但犧牲了查找性能。
而AVL是完全平衡的二叉樹,自平衡的計算犧牲了插入刪除性能,但是因爲最多隻有一層的高度差,所以查找效率高些。
對於查找密集型任務,使用AVL樹;對於插入密集型任務,使用紅黑樹。
3、存儲流程
1.7
1.8
4、數組元素 & 鏈表結點 的實現類
-
1.7
HashMap
中的數組元素 & 鏈表節點 採用Entry
類 實現 -
1.8
HashMap
中的數組元素 & 鏈表節點 採用Node
類 實現, 紅黑樹節點 採用TreeNode
類 實現
與
JDK 1.7
的對比(Entry
類),僅僅只是換了名字
三、具體使用
1、主要使用API(1.7和1.8基本相同)
V get(Object key); // 獲得指定鍵的值
V put(K key, V value); // 添加鍵值對
void putAll(Map<? extends K, ? extends V> m); // 將指定Map中的鍵值對 複製到 此Map中
V remove(Object key); // 刪除該鍵值對
boolean containsKey(Object key); // 判斷是否存在該鍵的鍵值對;是 則返回true
boolean containsValue(Object value); // 判斷是否存在該值的鍵值對;是 則返回true
Set<K> keySet(); // 單獨抽取key序列,將所有key生成一個Set
Collection<V> values(); // 單獨value序列,將所有value生成一個Collection
void clear(); // 清除哈希表中的所有鍵值對
int size(); // 返回哈希表中所有 鍵值對的數量 = 數組中的鍵值對 + 鏈表中的鍵值對
boolean isEmpty(); // 判斷HashMap是否爲空;size == 0時 表示爲 空
2、使用流程(7和8基本相同)
- 在具體使用時,主要流程是:
- 聲明1個
HashMap
的對象 - 向
HashMap
添加數據(成對 放入 鍵 - 值對) - 獲取
HashMap
的某個數據 - 獲取
HashMap
的全部數據:遍歷HashMap
四、基礎知識:HashMap中的重要參數(7&8基本相同)
HashMap
的主要參數:容量(capacity)、加載因子(loadFactor)、擴容閾值(threshold)
1.8 由於數據結構中引入了 紅黑樹,故加入了 與紅黑樹相關的參數。具體介紹如下:
/**
* JDK 1.8
* 主要參數 同 JDK 1.7
* 即:容量、加載因子、擴容閾值(要求、範圍均相同)
*/
// 1. 容量(capacity)HashMap中的數組長度
// a. 容量範圍:必須是2的冪 & < 最大容量(2的30次方)
// b. 初始容量 = 哈希表創建時的容量
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. 加載因子(loadFactor):HashMap在其容量擴容前可到達多滿的一種尺度
// a. 加載因子越大,填滿的元素越多 = 空間利用率高,但衝突的機會變大,查找效率變低(因爲鏈表變長了)
// b. 加載因子越小,填滿的元素越少 = 空間利用率小,衝突的機會變小,查找效率變高(鏈表變短)
final float loadFactor; // 實際加載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默認加載因子 = 0.75
// 3. 擴容閾值(threshold):當哈希表的大小 ≥ 擴容閾值是,就會擴容哈希表(即capacity)
// a. 擴容 = 對哈希表進行resize操作(即重建內部數據結構),從而哈希表將具有大約兩倍的桶數
// b. 擴容閾值 = 容量 × 加載因子
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;
容量 capacity 必須是2的冪
如果傳入的capacity不是2的冪, 這個運算的結果是比我們傳入的參數要大,而且是離我們傳入的參數最近的2的冪的數。
爲什麼大小必須是2的冪?
- 原因有兩點:1.加快哈希運算 2.減少哈希衝突
-
加快哈希運算:hash &(length - 1),因爲 位運算與 & 比 邏輯運算取模 % 快一點點點
-
保證數據分散,減少哈希衝突: 使用2的冪爲長度,則
length-1
後爲奇數,該奇數轉爲2進制後最後一位肯定是1
。 這樣奇偶由hash
值決定。否則,length-1
後爲偶數的話,最後一位是0
,&hash
都是偶數。
加載因子(DEFAULT_LOAD_FACTOR = 0.75f)
很小概率問道爲什麼是 0.75?若問答下
- 源碼註釋:時間和空間的平衡
<p>As a general rule, the default load factor (.75) offers a good* tradeoff between time and space costs.
- 一個bucket空和非空的概率爲0.5,通過牛頓二項式等數學計算,得到這個loadfactor的值爲log(2),約等於0.693。取0.75應該是方便計算。
參考 What is the significance of load factor in HashMap?
五、源碼分析
- 本次的源碼分析主要是根據 使用步驟 進行相關函數的詳細分析
- 主要分析內容如下:
1、步驟1:聲明一個HashMap的對象
/**
* 函數使用原型
*/
Map<String,Integer> map = new HashMap<String,Integer>();
/**
* 源碼分析:主要是HashMap的構造函數 = 4個
* 僅貼出關於HashMap構造函數的源碼
*/
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable{
// 省略上節闡述的參數
/**
* 構造函數1:默認構造函數(無參)
* 加載因子 & 容量 = 默認 = 0.75、16
*/
public HashMap() {
// 實際上是調用構造函數3:指定“容量大小”和“加載因子”的構造函數
// 傳入的指定容量 & 加載因子 = 默認
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
/**
* 構造函數2:指定“容量大小”的構造函數
* 加載因子 = 默認 = 0.75 、容量 = 指定大小
*/
public HashMap(int initialCapacity) {
// 實際上是調用指定“容量大小”和“加載因子”的構造函數
// 只是在傳入的加載因子參數 = 默認加載因子
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 構造函數3:指定“容量大小”和“加載因子”的構造函數
* 加載因子 & 容量 = 自己指定
*/
public HashMap(int initialCapacity, float loadFactor) {
// HashMap的最大容量只能是MAXIMUM_CAPACITY,哪怕傳入的 > 最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 設置 加載因子
this.loadFactor = loadFactor;
// 設置 擴容閾值 = 初始容量
// 注:此處不是真正的閾值,是爲了擴展table,該閾值後面會重新計算,下面會詳細講解
threshold = initialCapacity;
init(); // 一個空方法用於未來的子對象擴展
}
/**
* 構造函數4:包含“子Map”的構造函數
* 即 構造出來的HashMap包含傳入Map的映射關係
* 加載因子 & 容量 = 默認
*/
public HashMap(Map<? extends K, ? extends V> m) {
// 設置容量大小 & 加載因子 = 默認
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
// 該方法用於初始化 數組 & 閾值,下面會詳細說明
inflateTable(threshold);
// 將傳入的子Map中的全部元素逐個添加到HashMap中
putAllForCreate(m);
}
}
1.8 不同
/**
* 分析1:tableSizeFor(initialCapacity)
* 作用:將傳入的容量大小轉化爲:>傳入容量大小的最小的2的冪
* 與JDK 1.7對比:類似於JDK 1.7 中 inflateTable()裏的 roundUpToPowerOf2(toSize)
*/
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;
}
- 注:(同
JDK 1.7
類似)- 此處僅用於接收初始容量大小(
capacity
)、加載因子(Load factor
),但仍無真正初始化哈希表,即初始化存儲數組table
- 此處先給出結論:真正初始化哈希表(初始化存儲數組
table
)是在第1次添加鍵值對時,即第1次調用put()
時。下面會詳細說明
- 此處僅用於接收初始容量大小(
2、步驟2:向HashMap添加數據(成對 放入 鍵 - 值對)(7&8主要差異)
版本 | 初始化方式 | hash值的計算方式 | 存放數據的規則 | 插入數據的方式 | 擴容後存儲位置的計算方式 |
---|---|---|---|---|---|
JDK 1.7 | 單獨函數:infalteTable() | 1.hashCode() 2.擾動處理 = 9次擾動 = 4次位運算 + 5次異或運算 |
數組、鏈表 - 無衝突時,存放在數組- 有衝突時,存放在鏈表 |
頭插法 (先將原位置的數據移到後一位,再插入數據到該位置) |
全部按照原來的方法計算 (即 hashCode() ->> 擾動處理 ->> (h & length - 1) ) |
JDK 1.8 | 直接集成在擴容函數:resize() | 1.hashCode() 2.擾動處理 = 2次擾動 = 1次位運算 + 1次異或運算 |
數組、鏈表、紅黑樹 - 無衝突時,存放數組- 有衝突 & 鏈表長度 < 8時,存放鏈表 - 有衝突 & 鏈表長度 > 8時,存放紅黑樹 |
尾插法 (直接插入到鏈表尾部 / 紅黑樹) |
按照擴容後的規律計算 (即 擴容後的位置 = 原位置 or 原位置 + 舊容量 ) |
- 1.7 添加數據的流程如下
/**
* 源碼分析:主要分析: HashMap的put函數
*/
public V put(K key, V value)
// 1. 若 哈希表未初始化(即 table爲空)
// 則使用 構造函數時設置的閾值(即初始容量) 初始化 數組table
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// 2. 判斷key是否爲空值null
// 2.1 若key == null,則將該鍵-值 存放到數組table 中的第1個位置,即table [0]
// (本質:key = Null時,hash值 = 0,故存放到table[0]中)
// 該位置永遠只有1個value,新傳進來的value會覆蓋舊的value
if (key == null)
return putForNullKey(value);
// 2.2 若 key ≠ null,則計算存放數組 table 中的位置(下標、索引)
// a. 根據鍵值key計算hash值
int hash = hash(key);
// b. 根據hash值 最終獲得 key對應存放的數組Table中位置
int i = indexFor(hash, table.length);
// 3. 判斷該key對應的值是否已存在(通過遍歷 以該數組元素爲頭結點的鏈表 逐個判斷)
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 3.1 若該key已存在(即 key-value已存在 ),則用 新value 替換 舊value
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue; //並返回舊的value
}
}
modCount++;
// 3.2 若 該key不存在,則將“key-value”添加到table中
addEntry(hash, key, value, i);
return null;
}
- 1.8 添加數據的流程如下
/**
* 源碼分析:主要分析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)!!7&8差異
/**
* 分析1:hash(key)
* 作用:計算傳入數據的哈希碼(哈希值、Hash值)
* 該函數在JDK 1.7 和 1.8 中的實現不同,但原理一樣 = 擾動函數 = 使得根據key生成的哈希碼(hash值)分佈更加均勻、更具備隨機性,避免出現hash值衝突(即指不同key但生成同1個hash值)
* JDK 1.7 做了9次擾動處理 = 4次位運算 + 5次異或運算
* JDK 1.8 簡化了擾動函數 = 只做了2次擾動 = 1次位運算 + 1次異或運算
*/
// 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中實際上無該函數(在putVal()中判斷寫出),但原理相同
* 爲了方便講解,故提前到此講解
*/
static int indexFor(int h, int length) {
return h & (length-1);
// 將對哈希碼擾動處理後的結果 與運算(&) (數組長度-1),最終得到存儲在數組table的位置(即數組下標、索引)
}
- 總結 計算存放在數組 table 中的位置(即數組下標、索引)的過程
- 此處與
JDK 1.7
的區別在於:hash
值的求解過程中 哈希碼的二次處理方式(擾動處理)- 步驟1、2 =
hash
值的求解過程
步驟 | 代碼實現 | 具體實現過程 |
---|---|---|
1.計算哈希碼 | h = key.hashCode() | 根據鍵key,通過hashCode()計算 hashCode()簡介
|
2.二次處理哈希碼
(最終求得 鍵對應的hash值) |
h ^ (h >>> 16) | - 該處理也稱 擾動處理 -即 哈希碼 異或(^) 哈希碼自身右移16位後的二進制 -本質:二次處理低位 = 哈希碼的高16位不變、低16位 = 低16位 異或 高16位 (即 高位參與低位的運算) |
3.最終計算存儲的數組位置
(根據hash值 & 數組長度) |
h & (length - 1) | 二次處理的哈希碼 與運算(&) (數組長度-1) |
- 計算示意圖
在瞭解 如何計算存放數組table
中的位置 後,所謂 知其然 而 需知其所以然,下面我將講解爲什麼要這樣計算,即主要解答以下3個問題:
- 爲什麼不直接採用經過
hashCode()
處理的哈希碼 作爲 存儲數組table
的下標位置? - 爲什麼採用 哈希碼 與運算(&) (數組長度-1) 計算數組下標?
- 爲什麼在計算數組下標前,需對哈希碼進行二次處理:擾動處理?
在回答這3個問題前,請大家記住一個核心思想:
所有處理的根本目的,都是爲了提高 存儲
key-value
的數組下標位置的 隨機性 & 分佈均勻性,儘量避免哈希衝突。即 對於不同的key
,存儲的數組下標位置儘量不一樣。
問題1:爲什麼不直接採用經過hashCode()處理的哈希碼 作爲 存儲數組table的下標位置?
- 結論:容易出現 哈希碼 與數組大小不匹配的情況,即 計算出來的哈希碼 不在數組大小範圍內,從而導致無法匹配存儲位置。
- 原因如下圖
- 爲了解決 ”哈希碼與數組大小不匹配“ 的問題,HashMap給的解決方案:哈希碼 與運算(&) (數組長度-1)
- 引出問題2
問題2:爲什麼採用 哈希碼 與運算(&) (數組長度-1) 計算數組下標?
-
結論:根據HashMap的容量大小(數組長度),按需取哈希碼一定數量的低位作爲存儲的數組下標,從而解決 “ 哈希碼與數組大小範圍不匹配 ” 的問題
-
具體描述如下圖
問題3:爲什麼在計算數組下標前,需對哈希碼進行二次處理:擾動處理?
-
結論:加大哈希碼低位的隨機性,使得分佈更均勻,從而提高對數組存儲下標位置的 隨機性&均勻性,最終減少哈希衝突。
-
具體如下圖
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-gc8NHlES-1584256511041)(C:\Users\Kevin\AppData\Roaming\Typora\typora-user-images\1584083041918.png)]
至此,關於怎麼計算 key-value
值存儲在HashMap
數組位置 & 爲什麼要這麼計算,講解完畢。
分析2:putVal(hash(key), key, value, false, true);
此處有2個主要講解點:
- 計算完存儲位置後,具體該如何 存放數據 到哈希表中
- 具體如何擴容,即擴容機制
主要講解點1:計算完存儲位置後,具體該如何存放數據到哈希表中
由於數據結構中加入了紅黑樹,所以在存放數據到哈希表中時,需多次數據結構的判斷:數組、紅黑樹、鏈表
與JDK 1.7的區別,1.7只需要判斷數組和鏈表
/**
* 分析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;
}
}
}
- 總結
主要講解點2:擴容機制(即 resize()函數)
- 擴容流程如下圖
- 源碼分析
/**
* 分析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;
}
- 擴容流程(含 與
JDK 1.7
的對比)
常考點:1.7 鏈表 死循環 問題
- 原因結論:1.7 的轉移數據方式是頭插法(頭插法方便,並且由於局部性原理,考慮到最近添加的最可能被訪問),在數據擴容後容易出現鏈表逆序的情況,在多線程併發下,容易出現 環形鏈表, 從而在獲取數據、遍歷鏈表時形成死循環(
Infinite Loop
),即 死鎖的狀態 。
詳細參看此文:疫苗:JAVA HASHMAP的死循環
先看源碼
問題所在 transfer
:
單線程正常 rehash 如下:
多線程併發下的 rehash,可能出現死循環!
**1)假設我們有兩個線程。**我用紅色和淺藍色標註了一下。
我們再回頭看一下我們的 transfer代碼中的這個細節:
而我們的線程二執行完成了。於是我們有下面的這個樣子。
注意,因爲Thread1的 e 指向了key(3),而next指向了key(7),其在線程二rehash後,指向了線程二重組後的鏈表。我們可以看到鏈表的順序被反轉後。
2)線程一被調度回來執行
- 先是執行 newTalbe[i] = e;
- 然後是e = next,導致了e指向了key(7),
- 而下一次循環的next = e.next導致了next指向了key(3)
3)一切安好
線程一接着工作。把key(7)摘下來,放到newTable[i]的第一個,然後把e和next往下移。
4)環形鏈接出現
e.next = newTable[i] 導致 key(3).next 指向了 key(7)
注意:此時的key(7).next 已經指向了key(3), 環形鏈表就這樣出現了。
於是,當我們的線程一調用到,HashTable.get(11)時,悲劇就出現了——Infinite Loop。 CPU100%, 查看堆棧,你會發現程序都Hang在了HashMap.get()這個方法上
-
注:由於
JDK 1.8
轉移數據操作 = 按舊鏈表的正序遍歷鏈表、在新鏈表的尾部依次插入,所以不會出現鏈表 逆序、倒置的情況,故不容易出現環形鏈表的情況。但
JDK 1.8
還是線程不安全,因爲 無加同步鎖保護
1.8 擴容時,數據存儲位置重新計算的方式
- 計算結論 & 原因解析
- 結論示意圖
總結
- 添加數據的流程
- 7&8 區別
添加數據時 | ||||
---|---|---|---|---|
版本 | 初始化方式 | hash值的計算方式 | 存放數據的位置判斷 | 插入數據方式 |
JDK 1.7 | 單獨函數:inflateTable() | 1.hashCode() 2.擾動處理 = 9次擾動 = 4次位運算 + 5次異或運算 |
數組、鏈表 | 頭插法 (先將原位置的數據移到後一位,再插入數據到該位置) |
JDK 1.8 | 直接集成在函數:resize() | 1.hashCode() 2.擾動處理 = 2次擾動 = 1次位運算 + 1次異或運算 |
數組、鏈表、紅黑樹 | 尾插法 (直接插入到鏈表尾部/紅黑樹) |
擴容機制 | |||
---|---|---|---|
版本 | 擴容後存儲位置的計算方式 | 轉移數據方式 | 需插入數據的插入時機&位置重計算時機 |
JDK 1.7 | 全部按照原來的方法進行計算
(即 hashCode() ->> 擾動處理 ->> (h & length-1)) |
頭插法
(先將原位置的數據移到後一位,再插入數據到該位置) |
擴容後計算、單獨計算(即 轉移數據時無統一計算) |
JDK 1.8 | 按照擴容後的規律計算
(即 擴容後的位置 = 原位置 or 原位置 + 舊容量) |
尾插法
(直接插入到鏈表尾部/紅黑樹) |
擴容前計算、轉移數據時統一計算 |
至此,關於 HashMap
的添加數據源碼分析 分析完畢。
3、步驟3:從HashMap中獲取數據
- 假如理解了上述
put()
函數的原理,那麼get()
函數非常好理解,因爲二者的過程原理幾乎相同 get()
函數的流程如下:
/**
* 函數原型
* 作用:根據鍵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;
}
至此,關於 “向 HashMap
獲取數據 “講解完畢。
4、步驟4:對HashMap的其他操作
HashMap
除了核心的put()
、get()
函數,還有以下主要使用的函數方法
void clear(); // 清除哈希表中的所有鍵值對
int size(); // 返回哈希表中所有 鍵值對的數量 = 數組中的鍵值對 + 鏈表中的鍵值對
boolean isEmpty(); // 判斷HashMap是否爲空;size == 0時 表示爲 空
void putAll(Map<? extends K, ? extends V> m); // 將指定Map中的鍵值對 複製到 此Map中
V remove(Object key); // 刪除該鍵值對
boolean containsKey(Object key); // 判斷是否存在該鍵的鍵值對;是 則返回true
boolean containsValue(Object value); // 判斷是否存在該值的鍵值對;是 則返回true
這些方法比較簡單就不詳細敘述。