今天就跟大家聊聊有關(guān)HashMap源碼怎么寫，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結(jié)了以下內(nèi)容，希望大家根據(jù)這篇文章可以有所收獲。
創(chuàng)新互聯(lián)公司是一家集網(wǎng)站建設(shè),樂亭企業(yè)網(wǎng)站建設(shè),樂亭品牌網(wǎng)站建設(shè),網(wǎng)站定制,樂亭網(wǎng)站建設(shè)報(bào)價(jià),網(wǎng)絡(luò)營銷,網(wǎng)絡(luò)優(yōu)化,樂亭網(wǎng)站推廣為一體的創(chuàng)新建站企業(yè)，幫助傳統(tǒng)企業(yè)提升企業(yè)形象加強(qiáng)企業(yè)競爭力?？沙浞譂M足這一群體相比中小企業(yè)更為豐富、高端、多元的互聯(lián)網(wǎng)需求。同時(shí)我們時(shí)刻保持專業(yè)、時(shí)尚、前沿，時(shí)刻以成就客戶成長自我，堅(jiān)持不斷學(xué)習(xí)、思考、沉淀、凈化自己，讓我們?yōu)楦嗟钠髽I(yè)打造出實(shí)用型網(wǎng)站。
源碼學(xué)習(xí)，邊看源碼邊加注釋，邊debug，邊理解。
基本屬性
常量
DEFAULT_INITIAL_CAPACITY：默認(rèn)數(shù)組的初始容量 - 必須是2的冪。
MAXIMUM_CAPACITY：數(shù)組的最大容量
DEFAULT_LOAD_FACTOR：哈希表的負(fù)載因子0.75
TREEIFY_THRESHOLD：在一個(gè)桶內(nèi)由樹轉(zhuǎn)換成鏈表的閾值
UNTREEIFY_THRESHOLD：又樹轉(zhuǎn)換成鏈表的閾值
MIN_TREEIFY_CAPACITY：在數(shù)組長度大于或等于64時(shí)才會(huì)進(jìn)行鏈表轉(zhuǎn)換成樹的操作，否則直接擴(kuò)容
全局變量
數(shù)據(jù)結(jié)構(gòu)
HashMap的數(shù)據(jù)結(jié)構(gòu)在jdk1.8之前采用的是數(shù)組+鏈表，jdk1.8之后采用了數(shù)組+鏈表/紅黑樹的結(jié)構(gòu)，如圖：
如圖所示當(dāng)鏈表長度大于8時(shí)，鏈表轉(zhuǎn)換成紅黑樹。
在jdk1.8中存儲(chǔ)數(shù)據(jù)的節(jié)點(diǎn)有兩種一種是鏈表節(jié)點(diǎn)Node一種是樹節(jié)點(diǎn)TreeNode：
Node：
static class Node implements Map.Entry {
final int hash;
final K key;
V value;
Node next;
...
TreeNode：
static final class TreeNode extends LinkedHashMap.Entry {
TreeNode parent; // red-black tree links
TreeNode left;
TreeNode right;
TreeNode prev; // needed to unlink next upon deletion
boolean red;
...
通過上面的繼承關(guān)系我們發(fā)現(xiàn)TreeNode是繼承自Node的。
如果元素小于8個(gè)，鏈表查詢成本高，新增成本低 如果元素大于8個(gè)，紅黑樹查詢成本低，新增成本高
常見的使用方式
@Test
public void testHashMap() {
Map map = new HashMap<>();
map.put("1", "1");
map.get("1");
map.size();
}這是我們使用HashMap最常見的使用方式，下面我就來看下每一步都是怎么實(shí)現(xiàn)的。測試代碼:
public class HashMapTest {
public static void main(String[] args) {
Map 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;
}
}
}構(gòu)造函數(shù)
我們使用HashMap第一步是先創(chuàng)建一個(gè)HashMap，從上面的語句來看HashMap繼承自Map接口，下面我們開看看new HashMap<>()都做了些什么：
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}原來啥都沒干，就只是對一個(gè)成員變量賦了一個(gè)初值?？磥頂?shù)組的初始化和鏈表的初始化等都是在后面發(fā)生的。
put() 方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}hash() 方法
static final int hash(Object key) {
int h;
// 計(jì)算key.hashCode（）并將更高位的散列擴(kuò)展（XOR）降低。采用位運(yùn)算主要是是加快計(jì)算速度
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}putVal() 方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 數(shù)組對象
Node[] tab;
// 通過key值找出對應(yīng)數(shù)組索引位的數(shù)據(jù) p = tab[i = (n - 1) & hash]
Node p;
// n 表示數(shù)組長度， i表示key值在數(shù)組上的索引位
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
// 判斷數(shù)組是否為null，如果是則調(diào)用resize()方法進(jìn)行初始化
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// (n-1)&hash= hash%(n-1)，通過該公式找出該值在數(shù)組上的索引位。 保證不發(fā)生數(shù)組越界。
// 如果該索引位為null，則直接將數(shù)據(jù)放到該索引位
tab[i] = newNode(hash, key, value, null);
else {
Node e;
K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 表示key完全相同
e = p;
else if (p instanceof TreeNode)
// 桶內(nèi)已經(jīng)是紅黑樹節(jié)點(diǎn)
e = ((TreeNode) p).putTreeVal(this, tab, hash, key, value);
else {
// 桶內(nèi)還是鏈表節(jié)點(diǎn)
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 通過自旋找到尾部節(jié)點(diǎn)，并將新數(shù)據(jù)添加在尾部節(jié)點(diǎn)后面
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果鏈表內(nèi)的數(shù)據(jù)已經(jīng)超過8個(gè)則嘗試將鏈表轉(zhuǎn)成紅黑樹（其實(shí)這個(gè)時(shí)候鏈表已經(jīng)有9個(gè)節(jié)點(diǎn)了，最后一個(gè)節(jié)點(diǎn)是上一步添加進(jìn)去的）
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完全相同的情況下，用新數(shù)據(jù)去覆蓋老數(shù)據(jù)的value值，并返回老數(shù)據(jù)的value值
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 判斷如果hash表的總數(shù)大于擴(kuò)容閾值的時(shí)候需要進(jìn)行擴(kuò)容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}putTreeVal() 插入紅黑樹節(jié)點(diǎn)
final TreeNode putTreeVal(HashMap map, Node[] tab,
int h, K k, V v) {
Class kc = null;
boolean searched = false;
// 找到根節(jié)點(diǎn)
TreeNode root = (parent != null) ? root() : this;
for (TreeNode p = root; ; ) {
// dir 表示兩個(gè)key的比較結(jié)果，ph表示p節(jié)點(diǎn)的hash值
int dir, ph;
K pk;
if ((ph = p.hash) > h)
// 父節(jié)點(diǎn)的hash值大于新節(jié)點(diǎn)hash值
dir = -1;
else if (ph < h)
// 父節(jié)點(diǎn)的hash值小于新節(jié)點(diǎn)hash值
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
// 表示key完全相同
return p;
else if ((kc == null &&
// 判斷對key是否實(shí)現(xiàn)Comparable接口
(kc = comparableClassFor(k)) == null) ||
// 使用Comparable來比較父節(jié)點(diǎn)和新節(jié)點(diǎn)的key值大小
(dir = compareComparables(kc, k, pk)) == 0) {
// 這個(gè)查找只會(huì)執(zhí)行一次
if (!searched) {
TreeNode q, ch;
searched = true;
// 從p的左子樹找到對應(yīng)key的節(jié)點(diǎn)
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
// 從p的右子樹找到對應(yīng)key的節(jié)點(diǎn)
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
//表示key完全相同的節(jié)點(diǎn)
return q;
}
// 使用默認(rèn)比較器比較兩個(gè)key的大小
dir = tieBreakOrder(k, pk);
}
TreeNode xp = p;
// 自旋找出新節(jié)點(diǎn)的父節(jié)點(diǎn)
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node xpn = xp.next;
TreeNode x = map.newTreeNode(h, k, v, xpn);
// 將新節(jié)點(diǎn)放到對應(yīng)的葉子節(jié)點(diǎn)位置
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode) xpn).prev = x;
// 調(diào)整樹的平衡
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
treeifyBin() 嘗試將鏈表轉(zhuǎn)換成樹的方法
final void treeifyBin(Node[] tab, int hash) {
int n, index;
Node e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// 檢查數(shù)組長度如果小于64則不進(jìn)行紅黑樹轉(zhuǎn)換，直接進(jìn)行擴(kuò)容
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode hd = null, tl = null;
do {
// 將key值對應(yīng)數(shù)組索引位上所有鏈表節(jié)點(diǎn)轉(zhuǎn)換成紅黑樹節(jié)點(diǎn)
TreeNode p = replacementTreeNode(e, null);
if (tl == null)
// 樹的根節(jié)點(diǎn)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
// 由鏈表轉(zhuǎn)換成了紅黑樹
hd.treeify(tab);
}
}
treeify() 將鏈表轉(zhuǎn)換成紅黑樹
final void treeify(Node[] tab) {
TreeNode root = null;
// for循環(huán)遍歷鏈表所有節(jié)點(diǎn)
for (TreeNode x = this, next; x != null; x = next) {
// 給下一個(gè)節(jié)點(diǎn)賦值
next = (TreeNode) x.next;
x.left = x.right = null;
// 給root節(jié)點(diǎn)賦值
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 p = root; ; ) {
int dir, ph;
K pk = p.key;
// 比較root節(jié)點(diǎn)和X節(jié)點(diǎn)的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節(jié)點(diǎn)添加到紅黑樹
TreeNode 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);
}
resize() 擴(kuò)容方法
final Node[] resize() {
// 擴(kuò)容前的數(shù)組
Node[] oldTab = table;
// 獲取數(shù)組長度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 擴(kuò)容閾值
int oldThr = threshold;
// 擴(kuò)容后的數(shù)組長度和擴(kuò)容閾值
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
// 如果數(shù)組容量已經(jīng)大于最大容量（1<<30）了那么將不在進(jìn)行擴(kuò)容
threshold = Integer.MAX_VALUE;
return oldTab;
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 1. 數(shù)組長度直接擴(kuò)容2倍
// 2. 擴(kuò)容閾值也擴(kuò)容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表示還沒有初始化，然后給數(shù)組初始大小和擴(kuò)容閾值賦值
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);
}
// 擴(kuò)容閾值賦值
threshold = newThr;
@SuppressWarnings({"rawtypes", "unchecked"})
// 根據(jù)newCap值創(chuàng)建數(shù)組
Node[] newTab = (Node[]) new Node[newCap];
table = newTab;
// oldTab != null表示是擴(kuò)容，否則表示是初始化
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node e;
if ((e = oldTab[j]) != null) {
// 將老數(shù)組的對應(yīng)索引位置為NULL，方便GC回收
oldTab[j] = null;
if (e.next == null)
// 如果對應(yīng)索引位（桶）只有一個(gè)節(jié)點(diǎn)，那直接從新計(jì)算該節(jié)點(diǎn)的索引位（桶的位置），并放到對應(yīng)的位置
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 如果原來桶內(nèi)節(jié)點(diǎn)樹樹節(jié)點(diǎn)，那么需要拆分樹
((TreeNode) e).split(this, newTab, j, oldCap);
else { // preserve order
// 和jdk1.7不一樣，這里擴(kuò)容后鏈表順序不會(huì)發(fā)生改變
// 低位桶的頭節(jié)點(diǎn)
Node loHead = null, loTail = null;
// 高位節(jié)點(diǎn)高位桶的頭節(jié)點(diǎn)
Node hiHead = null, hiTail = null;
Node next;
do {
// 保存下一個(gè)節(jié)點(diǎn)，待下次循環(huán)使用
next = e.next;
// e.hash & oldCap算法可以算出新的節(jié)點(diǎn)該分配到那個(gè)索引位，
// 這也是為什么數(shù)組長度一定要是2的n次冪，否則該算法不可用
if ((e.hash & oldCap) == 0) {
if (loTail == null)
// 設(shè)置低位桶的頭結(jié)點(diǎn)
loHead = e;
else
loTail.next = e;
loTail = e;
} else {
if (hiTail == null)
// 設(shè)置高位桶的頭結(jié)點(diǎn)
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;
// 設(shè)置低索引位的頭結(jié)點(diǎn)
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
// 設(shè)置高索引位的頭結(jié)點(diǎn)
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
從put方法的源碼我們發(fā)現(xiàn)：
HashMap數(shù)組的初始化時(shí)在put元素的時(shí)候發(fā)生的
發(fā)生擴(kuò)容條件有兩個(gè)：一個(gè)是一個(gè)桶內(nèi)鏈表數(shù)據(jù)大于8并且數(shù)組長度小于64；HashMap總size大于擴(kuò)容的閾值。任意滿足一個(gè)都會(huì)發(fā)生擴(kuò)容。
在擴(kuò)容的時(shí)候，jdk1.8鏈表的順序?qū)⒉粫?huì)再發(fā)生變化，從而解決了1.8以前鏈表擴(kuò)容引發(fā)的死循環(huán)問題。HashMap中是如何形成環(huán)形鏈表可參考這個(gè)
數(shù)組長度始終是2的n次冪。這樣做使我們可以直接使用位運(yùn)算來計(jì)算key的索引位；在擴(kuò)容的時(shí)候可以直接使用位運(yùn)算來計(jì)算高低位索引的節(jié)點(diǎn)。
鏈表轉(zhuǎn)換成樹的條件是只有當(dāng)一個(gè)桶的元素超過8個(gè)并且數(shù)組長度大于等于64。
鏈表轉(zhuǎn)換成樹只發(fā)生在一個(gè)桶內(nèi)，也就是說在HashMap的數(shù)據(jù)結(jié)構(gòu)中可以一些桶是鏈表，一些桶是紅黑樹。
紅黑樹部分可以參考
get() 方法
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}getNode() 方法
final Node getNode(int hash, Object key) {
Node[] tab;
Node first, e;
int n;
K k;
// 先根據(jù)hash值找到數(shù)據(jù)所在桶內(nèi)的根節(jié)點(diǎn)（頭結(jié)點(diǎn)）
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 如果根節(jié)點(diǎn)（頭結(jié)點(diǎn)）就是我們要找的直接的返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
// 樹結(jié)構(gòu)的情況
if (first instanceof TreeNode)
return ((TreeNode) first).getTreeNode(hash, key);
// 鏈表結(jié)構(gòu)情況
do {
// 自旋查找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
tableSizeFor() 方法
我們在初始化HashMap的時(shí)候，我們傳入的初始化大小可能不是2的n次冪。這時(shí)我們需要調(diào)用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非線程安全的表現(xiàn)
HashMap是一個(gè)線程不安全的類，主要表現(xiàn)在：
在并發(fā)操作下size的統(tǒng)計(jì)會(huì)出錯(cuò)
并發(fā)操作下添加節(jié)點(diǎn)有可能會(huì)丟失數(shù)據(jù)
在并發(fā)操作下JDK1.7及以前在擴(kuò)容的時(shí)候鏈表有可能會(huì)形成環(huán)形數(shù)據(jù)結(jié)構(gòu)，一旦形成環(huán)形數(shù)據(jù)結(jié)構(gòu)，Entry的next節(jié)點(diǎn)永遠(yuǎn)不為空，就會(huì)產(chǎn)生死循環(huán)獲取Entry。
HashMap空間效率
HashMap其實(shí)是一種空間利用率很低的數(shù)據(jù)結(jié)構(gòu)，以HashMap結(jié)構(gòu)為例，我們具體分析一下HashMap空間效率。
有效數(shù)據(jù)空間
在HashMap結(jié)構(gòu)中，只有Key和Value所存放的兩個(gè)長整型數(shù)據(jù)是有效數(shù)據(jù)，共16字節(jié)（2×8字節(jié)）。
實(shí)際占用空間
Key和Value這兩個(gè)長整型數(shù)據(jù)包裝成java.lang.Long對象之后，就分別具有8字節(jié)的Mark Word、8字節(jié)的Klass指針，再加8字節(jié)存儲(chǔ)數(shù)據(jù)的long值。然后這2個(gè)Long對象組成Map.Entry之后，又多了16字節(jié)的對象頭，然后一個(gè)8字節(jié)的next字段和4字節(jié)的int型的hash字段，為了對齊，還必須添加4字節(jié)的空白填充，最后還有HashMap中對這個(gè)Entry的8字節(jié)的引用，這樣增加兩個(gè)長整型數(shù)字，實(shí)際耗費(fèi)的內(nèi)存為(Long(24byte)×2)+Entry(32byte)+HashMap Ref(8byte)=88byte。
空間利用率
空間效率為有效數(shù)據(jù)空間除以實(shí)際占用空間，即16字節(jié)/88字節(jié)=18%，這確實(shí)太低了。
源碼
https://github.com/wyh-spring-ecosystem-student/spring-boot-student/tree/releases
spring-boot-student-concurrent 工程
layering-cache
為監(jiān)控而生的多級緩存框架 layering-cache這是我開源的一個(gè)多級緩存框架的實(shí)現(xiàn)，如果有興趣可以看一下
看完上述內(nèi)容，你們對HashMap源碼怎么寫有進(jìn)一步的了解嗎？如果還想了解更多知識(shí)或者相關(guān)內(nèi)容，請關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道，感謝大家的支持。
新聞標(biāo)題：HashMap源碼怎么寫
轉(zhuǎn)載注明：
http://weahome.cn/article/iicsss.html
重慶分公司
重慶分公司
