一.基礎知識
之前寫過一篇jdk7版的HashMap,今天在此基礎上面講講jdk8中的HashMap。先來看看他們的不同。java源碼系列。
1.jdk7中,擴容插入使用的是前插法,jdk8中使用的是尾插法。
2.jdk7中使用的是數組+鏈表的數據結構,查找時間複雜度取決於鏈表的長度爲 O(n)。jdk8中使用的是數組+鏈表+紅黑樹(鏈表的個數大於8的時候,擴展爲紅黑樹)的數據結構,將查找的時間複雜度爲降爲 O(logN)。
3.jdk7中定義的每個節點叫entry,jdk8中變成了node,不過裏面的值還是hash,key,value,next,如下(jdk8)
final int hash;
final K key;
V value;
Node<K,V> next;
4,.jdk7是先擴容後添加值,jdk8是先添加值後擴容。
二.圖譜與結構
簡單給兩張圖,對比一下吧。
HashMap實現了Map,支持序列化和克隆。
三.源碼分析
老規矩,看看初始化,添加,刪除,獲取方法。
1.初始化
它有四個初始化方法
public HashMap() { //數組容量是16,負載因子是0.75,超過16*0.75 = 12就要擴容。
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(int initialCapacity) { //設置初始容量
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);
}
public HashMap(Map<? extends K, ? extends V> m) { //初始集合類型的HashMap
this.loadFactor = DEFAULT_LOAD_FACTOR; //裝載因子是0.75
putMapEntries(m, false); //將整個map添加進去,說到底還是一個一個的添加操作,這裏就不細講了,看下面的添加方法
}
2.添加方法
HashMap的添加方法也有好幾種,不過原理都差不多,就挑pul(k,v)方法來說說吧。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true); //添加值,第一個參數是hash值,第二個是key,第三個是value,第四個表示如果值存在覆不覆蓋原值,第五個表示如果是false,table是創建模式
}
static final int hash(Object key) { //這是取key的的hashcode和高位參數
int h;
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; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; //如果table裏面沒有值,需要進行一個擴容
if ((p = tab[i = (n - 1) & hash]) == null) //如果用key hash到table(數組)裏面沒有數據,就創建一個新的節點放在table[i]位置上
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)))) //如果table上面有值了,hash,key相等的話,暫別表table索引上的值賦值給e
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); //將新建的node添加到列表裏面
if (binCount >= TREEIFY_THRESHOLD - 1) // 如果大於閾值,就需要轉成紅黑樹
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) //如果找到了相同的值(比較的key)
break;
p = e;
}
}
if (e != null) { // 如果找到key相同的
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null) //需要將老值替換
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold) //如果大於閾值,需要擴容
resize();
afterNodeInsertion(evict);
return null;
}
final Node<K,V>[] resize() { //看官看好了,開始擴容
Node<K,V>[] oldTab = table; //先記錄一下老表
int oldCap = (oldTab == null) ? 0 : oldTab.length; //記錄老表裏面的值長度
int oldThr = threshold; //老的閾值
int newCap, newThr = 0; //新表長度和閾值默認爲0
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) { //閾值限制
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && //新的表長度是老表長度的兩倍 <<n 表示2的n次方
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 老閾值*2
}
else if (oldThr > 0)
newCap = oldThr;
else { // 最開始沒有值的情況下,初始化數據 表的長度是16,閾值是12
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<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //初始新表
table = newTab;
if (oldTab != null) { //如果老表裏面是有值的
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { //遍歷老表數據
oldTab[j] = null; //值賦值爲null,方便gc釋放內存
if (e.next == null) //走到表的最後一個
newTab[e.hash & (newCap - 1)] = e; //找到新表的索引,並賦值爲e
else if (e instanceof TreeNode) //如果是紅黑樹,進行相應的處理
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 可以保證順序
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) { //e.hash 和 老表的長度進行與操作,如果==0放在低鏈
if (loTail == null) //一開始爲空的時候,指向e
loHead = e;
else
loTail.next = e; //逐步添加node
loTail = e;
}
else {//e.hash 和 老表的長度進行與操作,如果不等於0放在高鏈
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead; //低鏈放到表的j索引
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead; //高鏈放到j+老表的長度上面
}
}
}
}
}
return newTab; //至此擴容完成
}
3.刪除方法
刪除方法有三個,就先看看remove(o)吧。
public V remove(Object key) { //移除一個對象
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ? //可能值爲空,如果不爲空,返回對象的值
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) { //matchValue 如果false就直接用key判斷是否相同就好了,如果true的話,不僅要看key相同,還會去比較value要一樣才刪除 movable如果是true就會從table中移除
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) { //判空並且找到table裏面的索引值
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //如果找到了key相同的
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode) //紅黑樹
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) { //在table這個索引裏面依次查找值,找到了就結束
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) { //如果找到了key相同的,如果matchValue爲false就直接進入操作,如果是true,之後還會進一步判斷值是否相等
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p) //判斷是鏈表第一個值,鏈表頭指向它的下一個
tab[index] = node.next;
else
p.next = node.next; //不是是鏈表第一個值,扣掉要刪除的節點
++modCount;
--size; //數據減少了一個
afterNodeRemoval(node);
return node;
}
}
return null;
}
4.獲取方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value; //如果值爲空,返回null,不爲空,返回值
}
final Node<K,V> getNode(int hash, Object key) { //獲取元素
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) { //判空並且找到table裏面的索引值
if (first.hash == hash &&
((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)))) //key相同,返回這個節點(node)
return e;
} while ((e = e.next) != null);
}
}
return null;
}
到此,jdk8版的HashMap源碼就講完了!
四.總結
HashMap是一個常用類,但是請注意使用jdk7和jdk8的不同,同時如果有多線程的操作,請使用 ConcurrentHashMap,或者Collections.synchronizeMap(map)。其實Collections.synchronizeMap(map)裏面用的就是synchronized
SynchronizedMap(Map<K,V> m) {
this.m = Objects.requireNonNull(m); //map不能爲空,要不然會拋出異常
mutex = this;
}
public V put(K key, V value) {
synchronized (mutex) {return m.put(key, value);}
}
大家想過沒有爲什麼要使用兩個鏈表來實現同一條鏈上面的擴容?
簡單來說就是爲了提高資源利用率。怎麼解釋呢。
向HashMap中一次加入
1,2,4,8,16,32,64
首先在數組上面有0號位置有很多hash值一樣的數據。
0 8->16->32
1 1
2 2
4 4
當再加入64時,原表需要擴容
0 16->32
1 1
2 2
4 4
8 8
e.hash & oldCap) != 0 這個判斷將符合條件的值放到高鏈(hi)中
e.hash & oldCap) == 0 這個判斷將符合條件的值放到低鏈(lo)中
這樣就在擴容的時候離散了數據,是表的利用率增加了。
但是還可以進行深入思路,有沒有什麼好的方案可以將表中的數值填充完全呢?
比如從數據中,明顯看出坑位3,5,7 沒有填好。