溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
今天就跟大家聊聊有關HashMap源碼怎么寫，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。
源碼學習，邊看源碼邊加注釋，邊debug，邊理解。
DEFAULT_INITIAL_CAPACITY：默認數組的初始容量 - 必須是2的冪。
MAXIMUM_CAPACITY：數組的最大容量
DEFAULT_LOAD_FACTOR：哈希表的負載因子0.75
TREEIFY_THRESHOLD：在一個桶內由樹轉換成鏈表的閾值
UNTREEIFY_THRESHOLD：又樹轉換成鏈表的閾值
MIN_TREEIFY_CAPACITY：在數組長度大于或等于64時才會進行鏈表轉換成樹的操作，否則直接擴容
table：數組對象
size：HashMap大小
modCount：操作HashMap的總數 for fast-fail
threshold： 擴容的閾值
loadFactor：哈希表的負載因子，默認是DEFAULT_LOAD_FACTOR值
HashMap的數據結構在jdk1.8之前采用的是數組+鏈表，jdk1.8之后采用了數組+鏈表/紅黑樹的結構，如圖：
如圖所示當鏈表長度大于8時，鏈表轉換成紅黑樹。
在jdk1.8中存儲數據的節點有兩種一種是鏈表節點Node一種是樹節點TreeNode：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> 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是繼承自Node的。
如果元素小于8個，鏈表查詢成本高，新增成本低 如果元素大于8個，紅黑樹查詢成本低，新增成本高
@Test
public void testHashMap() {
Map<String, Object> map = new HashMap<>();
map.put("1", "1");
map.get("1");
map.size();
}這是我們使用HashMap最常見的使用方式，下面我就來看下每一步都是怎么實現的。測試代碼:
public class HashMapTest {
public static void main(String[] args) {
Map<User, Object> map = new HashMap<>();
for (; ; ) {
map.put(new User(), map.size());
if (map.size() > 1000) {
break;
}
}
map.size();
}
static class User {
@Override
public int hashCode() {
return 1;
}
}
}我們使用HashMap第一步是先創建一個HashMap，從上面的語句來看HashMap繼承自Map接口，下面我們開看看new HashMap<>()都做了些什么：
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}原來啥都沒干，就只是對一個成員變量賦了一個初值。看來數組的初始化和鏈表的初始化等都是在后面發生的。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
} static final int hash(Object key) {
int h;
// 計算key.hashCode（）并將更高位的散列擴展（XOR）降低。采用位運算主要是是加快計算速度
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
} final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 數組對象
Node<K, V>[] tab;
// 通過key值找出對應數組索引位的數據 p = tab[i = (n - 1) & hash]
Node<K, V> p;
// n 表示數組長度， i表示key值在數組上的索引位
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
// 判斷數組是否為null，如果是則調用resize()方法進行初始化
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// (n-1)&hash= hash%(n-1)，通過該公式找出該值在數組上的索引位。 保證不發生數組越界。
// 如果該索引位為null，則直接將數據放到該索引位
tab[i] = newNode(hash, key, value, null);
else {
Node<K, V> e;
K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 表示key完全相同
e = p;
else if (p instanceof TreeNode)
// 桶內已經是紅黑樹節點
e = ((TreeNode<K, V>) 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);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果鏈表內的數據已經超過8個則嘗試將鏈表轉成紅黑樹（其實這個時候鏈表已經有9個節點了，最后一個節點是上一步添加進去的）
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// key完全相同則走后面的value替換流程
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 在key完全相同的情況下，用新數據去覆蓋老數據的value值，并返回老數據的value值
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 判斷如果hash表的總數大于擴容閾值的時候需要進行擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}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; ; ) {
// dir 表示兩個key的比較結果，ph表示p節點的hash值
int dir, ph;
K pk;
if ((ph = p.hash) > h)
// 父節點的hash值大于新節點hash值
dir = -1;
else if (ph < h)
// 父節點的hash值小于新節點hash值
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
// 表示key完全相同
return p;
else if ((kc == null &&
// 判斷對key是否實現Comparable接口
(kc = comparableClassFor(k)) == null) ||
// 使用Comparable來比較父節點和新節點的key值大小
(dir = compareComparables(kc, k, pk)) == 0) {
// 這個查找只會執行一次
if (!searched) {
TreeNode<K, V> q, ch;
searched = true;
// 從p的左子樹找到對應key的節點
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
// 從p的右子樹找到對應key的節點
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
//表示key完全相同的節點
return q;
}
// 使用默認比較器比較兩個key的大小
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;
}
}
} final void treeifyBin(Node<K, V>[] tab, int hash) {
int n, index;
Node<K, V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// 檢查數組長度如果小于64則不進行紅黑樹轉換，直接進行擴容
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K, V> hd = null, tl = null;
do {
// 將key值對應數組索引位上所有鏈表節點轉換成紅黑樹節點
TreeNode<K, V> p = replacementTreeNode(e, null);
if (tl == null)
// 樹的根節點
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
// 由鏈表轉換成了紅黑樹
hd.treeify(tab);
}
}final void treeify(Node<K, V>[] tab) {
TreeNode<K, V> root = null;
// for循環遍歷鏈表所有節點
for (TreeNode<K, V> x = this, next; x != null; x = next) {
// 給下一個節點賦值
next = (TreeNode<K, V>) x.next;
x.left = x.right = null;
// 給root節點賦值
if (root == null) {
x.parent = null;
x.red = false;
root = x;
} else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K, V> p = root; ; ) {
int dir, ph;
K pk = p.key;
// 比較root節點和X節點的hash值大小
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
// 將X節點添加到紅黑樹
TreeNode<K, V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
// 平衡紅黑樹
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
} final Node<K, V>[] resize() {
// 擴容前的數組
Node<K, V>[] oldTab = table;
// 獲取數組長度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 擴容閾值
int oldThr = threshold;
// 擴容后的數組長度和擴容閾值
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
// 如果數組容量已經大于最大容量（1<<30）了那么將不在進行擴容
threshold = Integer.MAX_VALUE;
return oldTab;
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 1. 數組長度直接擴容2倍
// 2. 擴容閾值也擴容2倍
newThr = oldThr << 1; // double threshold
} else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 值為0表示還沒有初始化，然后給數組初始大小和擴容閾值賦值
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"})
// 根據newCap值創建數組
Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
table = newTab;
// oldTab != null表示是擴容，否則表示是初始化
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
if ((e = oldTab[j]) != null) {
// 將老數組的對應索引位置為NULL，方便GC回收
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
// 和jdk1.7不一樣，這里擴容后鏈表順序不會發生改變
// 低位桶的頭節點
Node<K, V> loHead = null, loTail = null;
// 高位節點高位桶的頭節點
Node<K, V> hiHead = null, hiTail = null;
Node<K, V> next;
do {
// 保存下一個節點，待下次循環使用
next = e.next;
// e.hash & oldCap算法可以算出新的節點該分配到那個索引位，
// 這也是為什么數組長度一定要是2的n次冪，否則該算法不可用
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);
// 如果j=0 并且oldCap=16，那么低位桶就是0的索引位，高位桶就是0+16的索引位
if (loTail != null) {
loTail.next = null;
// 設置低索引位的頭結點
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
// 設置高索引位的頭結點
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}從put方法的源碼我們發現：
HashMap數組的初始化時在put元素的時候發生的
發生擴容條件有兩個：一個是一個桶內鏈表數據大于8并且數組長度小于64；HashMap總size大于擴容的閾值。任意滿足一個都會發生擴容。
在擴容的時候，jdk1.8鏈表的順序將不會再發生變化，從而解決了1.8以前鏈表擴容引發的死循環問題。HashMap中是如何形成環形鏈表可參考這個
數組長度始終是2的n次冪。這樣做使我們可以直接使用位運算來計算key的索引位；在擴容的時候可以直接使用位運算來計算高低位索引的節點。
鏈表轉換成樹的條件是只有當一個桶的元素超過8個并且數組長度大于等于64。
鏈表轉換成樹只發生在一個桶內，也就是說在HashMap的數據結構中可以一些桶是鏈表，一些桶是紅黑樹。
紅黑樹部分可以參考
https://www.jianshu.com/p/7993731be0cf
public V get(Object key) {
Node<K, V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
} final Node<K, V> getNode(int hash, Object key) {
Node<K, V>[] tab;
Node<K, V> first, e;
int n;
K k;
// 先根據hash值找到數據所在桶內的根節點（頭結點）
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 如果根節點（頭結點）就是我們要找的直接的返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
// 樹結構的情況
if (first instanceof TreeNode)
return ((TreeNode<K, V>) first).getTreeNode(hash, key);
// 鏈表結構情況
do {
// 自旋查找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}我們在初始化HashMap的時候，我們傳入的初始化大小可能不是2的n次冪。這時我們需要調用tableSizeFor方法找出和cap最接近的2的n次冪的值。
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;
}HashMap是一個線程不安全的類，主要表現在：
在并發操作下size的統計會出錯
并發操作下添加節點有可能會丟失數據
在并發操作下JDK1.7及以前在擴容的時候鏈表有可能會形成環形數據結構，一旦形成環形數據結構，Entry的next節點永遠不為空，就會產生死循環獲取Entry。
HashMap其實是一種空間利用率很低的數據結構，以HashMap<Long，Long>結構為例，我們具體分析一下HashMap空間效率。
在HashMap<Long，Long>結構中，只有Key和Value所存放的兩個長整型數據是有效數據，共16字節（2×8字節）。
Key和Value這兩個長整型數據包裝成java.lang.Long對象之后，就分別具有8字節的Mark Word、8字節的Klass指針，再加8字節存儲數據的long值。然后這2個Long對象組成Map.Entry之后，又多了16字節的對象頭，然后一個8字節的next字段和4字節的int型的hash字段，為了對齊，還必須添加4字節的空白填充，最后還有HashMap中對這個Entry的8字節的引用，這樣增加兩個長整型數字，實際耗費的內存為(Long(24byte)×2)+Entry(32byte)+HashMap Ref(8byte)=88byte。
空間效率為有效數據空間除以實際占用空間，即16字節/88字節=18%，這確實太低了。
https://github.com/wyh-spring-ecosystem-student/spring-boot-student/tree/releases
spring-boot-student-concurrent 工程
為監控而生的多級緩存框架 layering-cache這是我開源的一個多級緩存框架的實現，如果有興趣可以看一下
看完上述內容，你們對HashMap源碼怎么寫有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
