【集合詳解】HashMap原始碼解析
一、HashMap概述
二、HashMap的資料結構
三、HashMap原始碼分析
1.繼承
2、關鍵屬性
3、結構
4、建構函式
5、擴容
四:總結
一、概述
HashMap基於雜湊表的 Map 介面的實現。此實現提供所有可選的對映操作,並允許使用 null 值和 null 鍵。(除了不同步和允許使用 null 之外,HashMap 類與 Hashtable 大致相同。)此類不保證對映的順序,特別是它不保證該順序恆久不變。
值得注意的是HashMap不是執行緒安全的,如果想要執行緒安全的HashMap,可以通過Collections類的靜態方法synchronizedMap獲得執行緒安全的HashMap。
二、資料結構
在java程式語言中,最基本的結構就是兩種,一個是陣列,另外一個是模擬指標(引用),所有的資料結構都可以用這兩個基本結構來構造的,hashmap也不例外。Hashmap實際上是一個數組和連結串列的結合體(在資料結構中,一般稱之為“連結串列雜湊“),如圖(豎排表示陣列,橫排表示陣列元素【實際上是一個連結串列】)。
圖中,紫色部分即代表雜湊表,也稱為雜湊陣列,陣列的每個元素都是一個單鏈表的頭節點,連結串列是用來解決衝突的,如果不同的key對映到了陣列的同一位置處,就將其放入單鏈表中的第一個位置。
在JDK8中 又有了新的優化。桶中的元素不再唯一按照連結串列組合,也可以使用紅黑樹進行儲存
三、原始碼分析
繼承
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
關鍵屬性
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
// 序列號
private static final long serialVersionUID = 362498820763181265L;
// 預設的初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 預設的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 當桶(bucket)上的結點數大於這個值時會轉成紅黑樹
static final int TREEIFY_THRESHOLD = 8;
// 當桶(bucket)上的結點數小於這個值時樹轉連結串列
static final int UNTREEIFY_THRESHOLD = 6;
// 桶中結構轉化為紅黑樹對應的table的最小大小
static final int MIN_TREEIFY_CAPACITY = 64;
// 儲存元素的陣列,總是2的冪次倍
transient Node<k,v>[] table;
// 存放具體元素的集
transient Set<map.entry<k,v>> entrySet;
// 存放元素的個數,注意這個不等於陣列的長度。
transient int size;
// 每次擴容和更改map結構的計數器
transient int modCount;
// 臨界值 當實際大小(容量*填充因子)超過臨界值時,會進行擴容
int threshold;
// 填充因子
final float loadFactor;
}
HashMap結構
JDK 7
/** Entry是單向連結串列。
* 它是 “HashMap鏈式儲存法”對應的連結串列。
*它實現了Map.Entry 介面,即實現getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函式
**/
transient Entry[] table;
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
// 指向下一個節點
Entry<K,V> next;
final int hash;
// 建構函式。
// 輸入引數包括"雜湊值(h)", "鍵(k)", "值(v)", "下一節點(n)"
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
}
JDK8
/** Entry是單向連結串列。
* 它是 “HashMap鏈式儲存法”對應的連結串列。
*它實現了Map.Entry 介面,即實現getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函式
**/
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;
}
...
//紅黑樹節點
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* Returns root of tree containing this node.
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
建構函式
HashMap(int initialCapacity)
public HashMap(int initialCapacity) {
// 呼叫HashMap(int, float)型建構函式
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap()
public HashMap() {
// 初始化填充因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
public HashMap(Map
public HashMap(Map<? extends K, ? extends V> m) {
// 初始化填充因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 將m中的所有元素新增至HashMap中
putMapEntries(m, false);
}
注意:在hashMap中陣列的大小都是預設指定為2的4次冪,以後容量也是2的n次冪。具體原因,下面putVal方法介紹。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//table為空就建立
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//確定插入table的位置,演算法是(n - 1) & hash
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//在table的i位置發生碰撞,有兩種情況,1、key值是一樣的,替換value值,
//2、key值不一樣的有兩種處理方式:2.1、儲存在i位置的連結串列;2.2、儲存在紅黑樹中
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//2.2
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//2.1
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//超過了連結串列的設定長度8就擴容
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;
}
}
//如果e不為空就替換舊的oldValue值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//threshold=newThr:(int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
//預設0.75*16,大於threshold值就擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
Hash演算法:
得到hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
解釋:
h>>16:
得到通過h=key.hashCode()方法計算key的hashcode的值,通過計算出的hashcode的值向右移動16位,使原有的hashcode的值的高16位變低16位,高16位則統一都變為0。
異或運算:(h = key.hashCode()) ^ (h >>> 16)
原 來 的 hashCode : 1111 1111 1111 1111 0100 1100 0000 1010
移位後的hashCode: 0000 0000 0000 0000 1111 1111 1111 1111
進行異或運算 結果:1111 1111 1111 1111 1011 0011 1111 0101
這樣做的好處是,可以將hashcode高位和低位的值進行混合做異或運算,而且混合後,低位的資訊中加入了高位的資訊,這樣高位的資訊被變相的保留了下來。摻雜的元素多了,那麼生成的hash值的隨機性會增大。
獲取位置:
接著我們看該重新產生的hashcode應該對應的位置。
原始碼中模運算是在這個indexFor( )函式裡完成的。
bucketIndex = indexFor(hash, table.length);
indexFor的程式碼也很簡單,就是把雜湊值和陣列長度做一個”與”操作
static int indexFor(int h, int length) {
return h & (length-1);
}
順便說一下,這也正好解釋了為什麼HashMap的陣列長度要取2的整次冪。因為這樣(陣列長度-1)正好相當於一個“低位掩碼”。“與”操作的結果就是雜湊值的高位全部歸零,只保留低位值,用來做陣列下好相當於一個“低位掩碼”。“與”操作的結果就是雜湊值的高位全部歸零,只保留低位值,用來做陣列下標訪問。以初始長度16為例,16-1=15。2進製表示是00000000 00000000 00001111。和某雜湊值“與”操作如下,結果就是截取了最低的四位值。
10100101 11000100 00100101
& 00000000 00000000 00001111
----------------------------------
00000000 00000000 00000101 //高位全部歸零,只保留末四位
整個流程如下:
這樣我們已經得到了該元素的在陣列中的位置。 在put時,由於根據的是hashcode來put元素的,假如當前陣列位置已經存在元素,則會通過連結串列形式在該位置追加元素。(jdk7)
在JDK8中,有所改進的是,當加入連結串列元素的數量達到某固定值時,則改為紅黑樹結構儲存。
//put(K key,V value)函式
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;
//如果table為空或者長度為0,則resize()
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//找到key值對應的槽並且是第一個,直接加入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e;
K k;
//第一個node的hash值即為要加入元素的hash
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))){
e = p;
}else if (p instanceof TreeNode)//第一個節點是TreeNode,即tree-bin
/*Tree version of putVal.
*final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,int h, K k, V v)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//不是TreeNode,即為連結串列,遍歷連結串列
for (int binCount = 0; ; ++binCount) {
/*到達連結串列的尾端也沒有找到key值相同的節點,
*則生成一個新的Node,並且判斷連結串列的節點個數是不是到達轉換成紅黑樹的上界
*達到,則轉換成紅黑樹
*/
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
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;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回舊的value值
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
擴容:
final Node<K,V>[] resize() {
// 當前table儲存
Node<K,V>[] oldTab = table;
// 儲存table大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 儲存當前閾值
int oldThr = threshold;
int newCap, newThr = 0;
// 之前table大小大於0
if (oldCap > 0) {
// 之前table大於最大容量
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
}
// 之前閾值大於0
else if (oldThr > 0)
newCap = oldThr;
// oldCap = 0並且oldThr = 0,使用預設值(如使用HashMap()建構函式,之後再插入一個元素會呼叫resize函式,會進入這一步)
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 新閾值為0
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"})
// 初始化table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 之前的table已經初始化過
if (oldTab != null) {
// 複製元素,重新進行hash
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 { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 將同一桶中的元素根據(e.hash & oldCap)是否為0進行分割,分成兩個不同的連結串列,完成rehash
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;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
說明:進行擴容,會伴隨著一次重新hash分配,並且會遍歷hash表中所有的元素,是非常耗時的。在編寫程式中,要儘量避免resize。 在resize前和resize後的元素佈局如下
說明:上圖只是針對了陣列下標為2的桶中的各個元素在擴容後的分配佈局,其他各個桶中的元素佈局可以以此類推。 從putVal原始碼中我們可以知道,當插入一個元素的時候size就加1,若size大於threshold的時候,就會進行擴容。假設我們的capacity大小為32,loadFator為0.75,則threshold為24 = 32 * 0.75,此時,插入了25個元素,並且插入的這25個元素都在同一個桶中,桶中的資料結構為紅黑樹,則還有31個桶是空的,也會進行擴容處理,其實,此時,還有31個桶是空的,好像似乎不需要進行擴容處理,但是是需要擴容處理的,因為此時我們的capacity大小可能不適當。我們前面知道,擴容處理會遍歷所有的元素,時間複雜度很高;前面我們還知道,經過一次擴容處理後,元素會更加均勻的分佈在各個桶中,會提升訪問效率。所以,說盡量避免進行擴容處理,也就意味著,遍歷元素所帶來的壞處大於元素在桶中均勻分佈所帶來的好處。
總結:
本文介紹了hashMap的資料結構,重點分析了一些原始碼建構函式和擴容函式。以及對hash演算法進行了簡單剖析。如果不足,請多指正。