（轉載）Java中HashMap底層實現原理(JDK1.8)原始碼分析
阿新 • • 發佈：2018-12-31
近期在看一些java底層的東西，看到一篇分析hashMap不錯的文章，跟大家分享一下。
在JDK1.6，JDK1.7中，HashMap採用位桶+連結串列實現，即使用連結串列處理衝突，同一hash值的連結串列都儲存在一個連結串列裡。但是當位於一個桶中的元素較多，即hash值相等的元素較多時，通過key值依次查詢的效率較低。而JDK1.8中，HashMap採用位桶+連結串列+紅黑樹實現，當連結串列長度超過閾值（8）時，將連結串列轉換為紅黑樹，這樣大大減少了查詢時間。
簡單說下HashMap的實現原理：
首先有一個每個元素都是連結串列（可能表述不準確）的陣列，當新增一個元素（key-value）時，就首先計算元素key的hash值，以此確定插入陣列中的位置，但是可能存在同一hash值的元素已經被放在陣列同一位置了，這時就新增到同一hash值的元素的後面，他們在陣列的同一位置，但是形成了連結串列，同一各連結串列上的Hash值是相同的，所以說陣列存放的是連結串列。而當連結串列長度太長時，連結串列就轉換為紅黑樹，這樣大大提高了查詢的效率。
當連結串列陣列的容量超過初始容量的0.75時，再雜湊將連結串列陣列擴大2倍，把原連結串列陣列的搬移到新的陣列中
即HashMap的原理圖是：
一，JDK1.8中的涉及到的資料結構
1，位桶陣列
transient Node[] table;//儲存（位桶）的陣列3，紅黑樹//Node是單向連結串列，它實現了Map.Entry介面 static class Node implements Map.Entry { final int hash; final K key; V value; Node next; //建構函式Hash值 鍵 值 下一個節點 Node(int hash, K key, V value, Node 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 int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } //判斷兩個node是否相等,若key和value都相等，返回true。可以與自身比較為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; }
//紅黑樹 static final class TreeNode extends LinkedHashMap.Entry { TreeNode parent; // 父節點 TreeNode left; //左子樹 TreeNode right;//右子樹 TreeNode prev; // needed to unlink next upon deletion boolean red; //顏色屬性 TreeNode(int hash, K key, V val, Node next) { super(hash, key, val, next); } //返回當前節點的根節點 final TreeNode root() { for (TreeNode r = this, p;;) { if ((p = r.parent) == null) return r; r = p; } }
二，原始碼中的資料域
載入因子（預設0.75）：為什麼需要使用載入因子，為什麼需要擴容呢？因為如果填充比很大，說明利用的空間很多，如果一直不進行擴容的話，連結串列就會越來越長，這樣查詢的效率很低，因為連結串列的長度很大（當然最新版本使用了紅黑樹後會改進很多），擴容之後，將原來連結串列陣列的每一個連結串列分成奇偶兩個子連結串列分別掛在新連結串列陣列的雜湊位置，這樣就減少了每個連結串列的長度，增加查詢效率
HashMap本來是以空間換時間，所以填充比沒必要太大。但是填充比太小又會導致空間浪費。如果關注記憶體，填充比可以稍大，如果主要關注查詢效能，填充比可以稍小。
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//填充比
//當add一個元素到某個位桶，其連結串列長度達到8時將連結串列轉換為紅黑樹
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
transient Node[] table;//儲存元素的陣列
transient Set> entrySet;
transient int size;//存放元素的個數
transient int modCount;//被修改的次數fast-fail機制
int threshold;//臨界值 當實際大小(容量*填充比)超過臨界值時，會進行擴容
final float loadFactor;//填充比（......後面略）HashMap的構造方法有4種，主要涉及到的引數有，指定初始容量，指定填充比和用來初始化的Map
//建構函式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;
this.threshold = tableSizeFor(initialCapacity);//新的擴容臨界值
}
//建構函式2
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//建構函式3
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//建構函式4用m的元素初始化雜湊對映
public HashMap(Map m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
1，HashMap如何getValue值，看原始碼
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node getNode(int hash, Object key) {
Node[] tab;//Entry物件陣列
Node first,e; //在tab陣列中經過雜湊的第一個位置
int n;
K k;
/*找到插入的第一個Node，方法是hash值和n-1相與，tab[(n - 1) & hash]*/
//也就是說在一條鏈上的hash值相同的
if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {
/*檢查第一個Node是不是要找的Node*/
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))//判斷條件是hash值要相同，key值要相同
return first;
/*檢查first後面的node*/
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode)first).getTreeNode(hash, key);
/*遍歷後面的連結串列，找到key值和hash值都相同的Node*/
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}2，HashMap如何put(key，value);看原始碼
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab;
Node p;
int n, i;
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);
/*表示有衝突,開始處理衝突*/
else {
Node e;
K k;
/*檢查第一個Node，p是不是要找的值*/
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
/*指標為空就掛在後面*/
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果衝突的節點數已經達到8個，看是否需要改變衝突節點的儲存結構，
//treeifyBin首先判斷當前hashMap的長度，如果不足64，只進行
//resize，擴容table，如果達到64，那麼將衝突的儲存結構為紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
/*如果有相同的key值就結束遍歷*/
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
/*就是連結串列上有相同的key值*/
if (e != null) { // existing mapping for key，就是key的Value存在
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//返回存在的Value值
}
}
++modCount;
/*如果當前大小大於門限，門限原本是初始容量*0.75*/
if (++size > threshold)
resize();//擴容兩倍
afterNodeInsertion(evict);
return null;
}1，判斷鍵值對陣列tab[]是否為空或為null，否則以預設大小resize()；
2，根據鍵值key計算hash值得到插入的陣列索引i，如果tab[i]==null，直接新建節點新增，否則轉入3
3，判斷當前陣列中處理hash衝突的方式為連結串列還是紅黑樹(check第一個節點型別即可),分別處理
五，HasMap的擴容機制resize();
構造hash表時，如果不指明初始大小，預設大小為16（即Node陣列大小16），如果Node[]陣列中的元素達到（填充比*Node.length）重新調整HashMap大小 變為原來2倍大小,擴容很耗時
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
final Node[] resize() {
Node[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
/*如果舊錶的長度不是空*/
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
/*把新表的長度設定為舊錶長度的兩倍，newCap=2*oldCap*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
/*把新表的門限設定為舊錶門限的兩倍，newThr=oldThr*2*/
newThr = oldThr << 1; // double threshold
}
/*如果舊錶的長度的是0，就是說第一次初始化表*/
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);
}
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[] newTab = (Node[])new Node[newCap];
table = newTab;//把新表賦值給table
if (oldTab != null) {//原表不是空要把原表中資料移動到新表中
/*遍歷原來的舊錶*/
for (int j = 0; j < oldCap; ++j) {
Node e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)//說明這個node沒有連結串列直接放在新表的e.hash & (newCap - 1)位置
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode)e).split(this, newTab, j, oldCap);
/*如果e後邊有連結串列,到這裡表示e後面帶著個單鏈表，需要遍歷單鏈表，將每個結點重*/
else { // preserve order保證順序
////新計算在新表的位置，並進行搬運
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node next;
do {
next = e.next;//記錄下一個結點
//新表是舊錶的兩倍容量，例項上就把單鏈表拆分為兩隊，
//e.hash&oldCap為偶數一隊，e.hash&oldCap為奇數一對
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) {//lo隊不為null，放在新表原位置
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {//hi隊不為null，放在新表j+oldCap位置
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}六，JDK1.8使用紅黑樹的改進
在java jdk8中對HashMap的原始碼進行了優化，在jdk7中，HashMap處理“碰撞”的時候，都是採用連結串列來儲存，當碰撞的結點很多時，查詢時間是O（n）。
在jdk8中，HashMap處理“碰撞”增加了紅黑樹這種資料結構，當碰撞結點較少時，採用連結串列儲存，當較大時（>8個），採用紅黑樹（特點是查詢時間是O（logn））儲存（有一個閥值控制，大於閥值(8個)，將連結串列儲存轉換成紅黑樹儲存）
問題分析：
你可能還知道雜湊碰撞會對hashMap的效能帶來災難性的影響。如果多個hashCode()的值落到同一個桶內的時候，這些值是儲存到一個連結串列中的。最壞的情況下，所有的key都對映到同一個桶中，這樣hashmap就退化成了一個連結串列——查詢時間從O(1)到O(n)。
隨著HashMap的大小的增長，get()方法的開銷也越來越大。由於所有的記錄都在同一個桶裡的超長連結串列內，平均查詢一條記錄就需要遍歷一半的列表。
JDK1.8HashMap的紅黑樹是這樣解決的：
如果某個桶中的記錄過大的話（當前是TREEIFY_THRESHOLD = 8），HashMap會動態的使用一個專門的treemap實現來替換掉它。這樣做的結果會更好，是O(logn)，而不是糟糕的O(n)。
它是如何工作的？前面產生衝突的那些KEY對應的記錄只是簡單的追加到一個連結串列後面，這些記錄只能通過遍歷來進行查詢。但是超過這個閾值後HashMap開始將列表升級成一個二叉樹，使用雜湊值作為樹的分支變數，如果兩個雜湊值不等，但指向同一個桶的話，較大的那個會插入到右子樹裡。如果雜湊值相等，HashMap希望key值最好是實現了Comparable介面的，這樣它可以按照順序來進行插入。這對HashMap的key來說並不是必須的，不過如果實現了當然最好。如果沒有實現這個介面，在出現嚴重的雜湊碰撞的時候，你就並別指望能獲得性能提升了。本文章轉載自：http://www.2cto.com/kf/201606/515215.html