閱讀優秀的源碼是提升程式設計技巧的重要手段之一。
如有不對的地方，歡迎指正~
轉載請注明出處
https://blog.lzoro.com 。
前言
基于
JDK1.8
基本說明
常量
以下常量皆為HashMap類中定義
| 預設值 | 說明 | |
|---|---|---|
| DEFAULT_INITIAL_CAPACITY | 1<<4=(16) | 預設初始容量 |
| MAXIMUM_CAPACITY | 1 << 30 | 最大容量 |
| DEFAULT_LOAD_FACTOR | 0.75 | 預設負載因子（當存儲比例超過該參數時會觸發hashmap擴容） |
| TREEIFY_THRESHOLD | 8 | 連結清單 -> 樹化門檻值 |
| UNTREEIFY_THRESHOLD | 6 | 樹 -> 連結清單化門檻值 |
| MIN_TREEIFY_CAPACITY | 64 | 樹化後表格最小容量(至少4倍于TREEIFY_THRESHOLD) |
節點(靜态内部類)
HashMap的實際負責K,V存儲的是
transient Node<K,V>[] table
，而這裡的
Node<K,V>
則是HashMap的一個靜态内部類，如下
/**
* 基本Hash節點，用于大多數Entries
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //Hahs
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;
}
/**
* 擷取Key
*/
public final K getKey() { return key; }
/**
* 擷取Value
*/
public final V getValue() { return value; }
/**
* ToString
*/
public final String toString() { return key + "=" + value; }
/**
* HashCode
*/
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
/**
* Value設定
*/
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
/**
* Equal方法
*/
public final boolean equals(Object o) {
//位址比較
if (o == this)
return true;
//是否是Map.Entry執行個體
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
//隻有當Key和value都相等時，才傳回true
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
靜态工具集
在正式了解HashMap的初始化/存取之前，還有一個應該熟悉的是HashMap提供的靜态工具集
/**
* 計算關鍵字key的hashCode()并将Hash高位和地位進行異或(XORs)
* 這個與HashMap中的Table下标計算有關
* 哈希桶(table)的長度都是2的n次幂，So,index僅和hash的低n位有關
* 将高16位和低16進行異或，讓高16位參與運算，防止頻繁碰撞。
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
* 如果x的類是C且C實作了Comparable，則傳回x的class,否則傳回null
* 如：`class C implements Comparable<C>`的形式
*
*/
static Class<?> comparableClassFor(Object x) {
//判斷x是否是Comparable執行個體
if (x instanceof Comparable) {
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
if ((c = x.getClass()) == String.class) // bypass checks
return c;
if ((ts = c.getGenericInterfaces()) != null) {
for (int i = 0; i < ts.length; ++i) {
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType)t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
return null;
}
/**
* 如果x不為null且x的Class為1`kc`,則傳回k.compareTo(x)
* 否則傳回0
*/
@SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
static int compareComparables(Class<?> kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable)k).compareTo(x));
}
/**
* 傳回大于等于cap的最小的2的n次幂
* 超過MAXIMUM_CAPACITY，則傳回MAXIMUM_CAPACITY
*
* 有點抽象，舉個例子，如這裡的cap為11
* n = 11-1=10
* 10的二進制 -> 0000 1010
* n |= n >>> 1 -> 0000 1010
* 0000 0101
* 0000 1111
*
* n |= n >>> 2 -> 0000 1111
* 0000 0011
* 0000 1111
*
* n |= n >>> 4 -> 0000 1111
* 0000 0000
* 0000 1111
*
* n |= n >>> 8 -> 0000 1111
* 0000 0000
* 0000 1111
* n |= n >>> 16 0000 1111
* 0000 0000
* 0000 1111
*
* 此時n的二級制為0000 1111，即15
* 既不小于0，也不大于MAXIMUN_CAPACITY，是以傳回n+1
*
* 結果是16，即大于11的且是最小的2的n次幂
*
* 具體的原理可以google哈~
*
* 膜拜Java大神，膝蓋奉上。
*/
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的常量和靜态工具集之後，在運用方法之前，還需了解下HashMap是怎麼被初始化的。
先看下成員變量
/**
* 負責存儲的哈希桶(table), 首次使用的時候進行初始化，在必要的時候進行擴容.
* 配置設定時，長度總是2的n次幂
* (在某些操作中可以容忍長度為零，以允許目前不需要的引導機制)
*/
transient Node<K,V>[] table;
/**
* 緩存entrySet
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* map的size
*/
transient int size;
/**
* HashMap在結構上的修改次數
* 該字段用于fail-fast政策
* 就是當使用疊代器時，如果發現預期的modCount與實際不合時抛出ConcurrentModificationException
*/
transient int modCount;
/**
* 下次resize時的哈希桶大小(capacity * load factor).
*
* @serial
*/
int threshold;
/**
* hash table的負載因子
*
* @serial
*/
final float loadFactor;
接下來是HashMap提供的4個構造方法
/**
* 利用指定的容量和負載因子構造一個空的HashMap
*
* @param initialCapacity 初始化容量
* @param loadFactor 負載因子
* @throws 初始容量為負數/負載因子為<=0時會抛出IllegalArgumentException
*/
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;
//這裡實際上并初始化數組，隻是利用上面講到的tableSizeFor計算了長度
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 利用指定的容量和預設負載因子(0.75).構造一個空的HashMap
*
* @param initialCapacity 初始化容量
* @throws 初始容量為負數時會抛出IllegalArgumentException
*/
public HashMap(int initialCapacity) {
//實際調用的是上面的構造函數
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 利用預設初始容量(16)和預設負載因子(0.75).構造一個空的HashMap
*/
public HashMap() {
//其他成員變量都是預設值
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* 根據給定的Map和預設的初始容量以及預設負載因子構造一個HashMap
*
* @param m
* @throws NullPointerException if the specified map is null
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
//這個方法放在後面說明
putMapEntries(m, false);
}
看了上面四個構造方面，除了利用給定的Map來進行構造（第四個），其他三個都隻是進行成員變量的指派，并未真正進行空間的配置設定。
第四個構造函數，内部其實是調用了
putMapEntries
進行初始化并且存放元素，方法内部調用了另外幾個關鍵方法，如
tableSizeFor
(前面已提到)，
resize
初始化/擴容和
putVal
存放元素(後續會分析)。
/**
* 實作 Map.putAll 和 構造函數
*
* @param m the map
* @param evict false when initially constructing this map, else
* true (relayed to method afterNodeInsertion).
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
//如果給定的map是空的話，則不進行其他操作
if (s > 0) {
//map不為空
//如果哈希桶還未初始化
if (table == null) { // pre-size
//計算相關門檻值
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
//這裡的計算後，不立即進行初始化/擴容
threshold = tableSizeFor(t);
}
else if (s > threshold)
//初始化/擴容
resize();
//存放元素
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
關鍵方法
put
用過HashMap的小夥伴肯定都知道這個方法，哈？沒用過的話。那還是先去用用吧。
可以看到
put
方法，先是對
key
進行hash（上面的靜态工具集有提到）,然後調用
putVal
進行實際存儲，另外還有
putIfAbsent
方法，該方法隻在map不存在相應的鍵值對時進行放入。
/**
* 将給定的key和value存儲到map當中
* 若容器中已存在該key的話，舊的value會被新的value替代
*/
public V put(K key, V value) {
//可以看到這裡
return putVal(hash(key), key, value, false, true);
}
/**
* 如果存在，就不覆寫舊值
*/
@Override
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}
putVal具體實作
/**
* 實作Map.put和相關方法
*
* @param hash key的hash
* @param key key
* @param value value
* @param onlyIfAbsent 如果為true，不改變舊值
* @param evict 如果為false，則表将采取creation模式.
* @return 前一個值，如果沒有則傳回null
*/
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未被初始化的話，則調用resize進行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//哈希桶下标計算i=(n-1)&hash，并判斷桶中該位置有沒有元素
if ((p = tab[i = (n - 1) & hash]) == 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))))
//如果給點節點的hash和key跟桶上找到的節點相等，則将舊的p節點指派給e
e = p;
else if (p instanceof TreeNode)
//如果p節點是樹節點(紅黑樹)
//插入一個樹節點
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果以上兩者皆不是，則證明目前連結清單還未樹化
//根據定位的p節點，進行操作
for (int binCount = 0; ; ++binCount) {
//判斷p節點的後續節點是否存在
if ((e = p.next) == null) {
//不存在則建立一個新節點進行插入
p.next = newNode(hash, key, value, null);
//連結清單長度超過樹化門檻值，則執行樹化
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//樹化
treeifyBin(tab, hash);
break;
}
//如果p的下一個節點e跟給定節點一緻，則跳出循環
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//把e指派給p，進行連結清單周遊
p = e;
}
}
//如果e不為null
if (e != null) { // existing mapping for key
//擷取舊值
V oldValue = e.value;
//判斷入參條件onlyIfAbsent/舊值是否為null
if (!onlyIfAbsent || oldValue == null)
//将新值指派給e節點
e.value = value;
//空實作 - 主要是為了linkedHashMap的一些後續處理工作
afterNodeAccess(e);
return oldValue;
}
}
//增加modCount - 在上面有給出這個變量的含義
++modCount;
//若達到擴容門檻值，則進行擴容
if (++size > threshold)
//擴容
resize();
//空實作 與 afterNodeAccess同理
afterNodeInsertion(evict);
return null;
}
再跟蹤下上面的幾個方法
newNode
、
putTreeVal
treeifyBin
resize
newNode是建立一個新節點，其實就是内部類
Node
的一個執行個體，比較簡單
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
putTreeVal是樹化後插入節點的實作，
treeifyBin
是對連結清單進行樹化。
這裡的操作涉及到
紅黑樹
的操作，如果對
紅黑樹
不了解的話，建議可以先了解下相關概念和算法，由于篇幅關系，關于
紅黑樹
後面另開章節分析。
這裡簡單介紹一下基礎概念。
紅黑樹（Red Black Tree） 是一種自平衡二叉查找樹，性質如下：
- 1.節點非黑即紅
- 2.根節點是黑色
- 3.每個葉節點（NIL節點，空節點）是黑色的
- 4.每個紅色節點的兩個子節點都是黑色(從每個葉子到根的所有路徑上不能有兩個連續的紅色節點)
- 5.從任一節點到其每個葉子的所有路徑都包含相同數目的黑色節點
resize是擴容的方法，下面看下具體實作
/**
* 初始化或者是将哈希桶(table)大小加倍。
* 如果為空，則按threshold配置設定空間
* 否則，由于采取2的n次幂擴充，容器中的元素在新table中要麼呆在原索引處, 要麼有一個2的n次幂的位移
*
* @return the table
*/
final Node<K,V>[] resize() {
//舊的哈希桶
Node<K,V>[] oldTab = table;
//舊的容量/長度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//舊的threshold
int oldThr = threshold;
//新的相關标量
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
//舊的容量大于等于MAXIMUM_CAPACITY
//則将threshod指派為Integer.MAX_VALUE
threshold = Integer.MAX_VALUE;
//此時不再進行擴容，傳回舊的哈希桶
return oldTab;
}
//新的容量為舊容量的的2倍
//判斷新容量是否小于最大值且舊容量大于預設值
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//對新的threshold指派(2倍于舊的)
newThr = oldThr << 1; // double threshold
}
//判斷舊的threshold
//這種情況下，初始容量為threshold的
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//threshold初始化為0，則表明是使用預設值
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//判斷新的threshold是否為0
if (newThr == 0) {
//計算新的threshold，為新的容量*負載因子
float ft = (float)newCap * loadFactor;
//進行最大值判斷
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将計算出來的threshold指派到成員變量threshold
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//根據計算的容量建立一個哈希桶
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//成員變量table指向新的哈希桶
table = newTab;
//判斷舊的哈希桶是否為null
if (oldTab != null) {
//下面通過循環來移動将舊哈希桶移動到新的哈希桶
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//沒有後續節點
if (e.next == null)
//将該節點存放到新的哈希桶
//使用的是2的n次幂的擴充(指長度擴為原來2倍)，是以，元素的位置要麼是在原位置，要麼是在原位置再移動2次幂的位置。
//eg.1
//擴容前
//e.hash = 8 -> 0000 1000
//oldCap-1 = 15 -> 0000 1111
& -> 0000 1000
// 結果 = 8
//擴容後
//e.hash = 8 -> 0000 1000
//newCap-1 = 31 -> 0001 1111
// & -> 0000 1000
// 結果 = 8 是以位置不變
//eg.2
//擴容前
//e.hash = 16 -> 0001 0000
//oldCap-1 = 15 -> 0000 1111
& -> 0000 0000
// 結果 = 0
//擴容後
//e.hash = 16 -> 0001 0000
//newCap-1 = 31 -> 0001 1111
// & -> 0001 1000
// 結果 = 16
//位置移動了0 + 16(2的4次幂，也是原來的容量oldCap)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果是樹化後的節點，則進行split
((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;
//舊連結清單遷移新連結清單
do {
//取出後續節點
next = e.next;
//這裡的e.hash & oldCap 目的是取出高位的1bit來判斷是否為0，跟上面的 & (oldCap - 1)不同，這裡是取出高位1bit來判斷是否需要移動
//eg.1
// e.hash = 8 -> 0000 1000
// oldCap = 16 -> 0001 0000
& -> 0000 0000
結果 = 0
//如果為0，不需要移動
// e.hash = 16 -> 0001 0000
// oldCap = 16 -> 0001 0000
& -> 0001 0000
結果 = 16
//如果不為0
//不需要移動
if ((e.hash & oldCap) == 0) {
//不需要移動時，以loHead為首節點，維護連結清單順序
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
//需要移動時，以hiHead為首節點，維護連結清單順序
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;//最後一個節點的next指向的是自己，是以置為null
newTab[j] = loHead;//在新的哈希桶中存放連結清單
}
if (hiTail != null) {
hiTail.next = null;//同上面
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//傳回新的哈希桶
return newTab;
}
這裡先抛開
紅黑樹
，單看哈希桶和連結清單，大緻可以将擴容總結如下：
1、計算新的容量和門檻值
2、根據新的容量建立新的哈希桶
3、将舊桶中的元素節點存放到新的哈希桶
3.1、判斷桶中的節點是否有後續節點，沒有的話，确認下标後存放元素
3.2、判斷是否樹化，如果是，則進行紅黑樹操作(後續分析)
3.3、桶中節點存在後續節點(連結清單)，則進行連結清單的順序維護後，存放到新的哈希桶
4、傳回擴容後的哈希桶
get
現在出門都是成雙成對了(單身狗出門随時一嘴狗糧)，是以HashMap裡面既然有
put
來存放元素，肯定也有擷取元素的方法，就是現在要分析的
get
，另外還有jdk1.8新增的
getOrDefault
内部主要還是調用了
hash
方法對key進行哈希運算，然後調用
getNode
取得節點。
/**
* 如果存在對應的鍵值對，則根據對應的key，傳回value，否則傳回null
*
* 更精确點說，如果在該map中，存在一個key跟給定的key相同
* (同為null，或者調用equal為true)，則傳回該key對應的value,否則傳回null
*
* null傳回值不一定表示map沒有包含此key的映射
* 也有可能是映射的value的确是null
* 可以使用containsKey操作來區分這兩種情況（指定的key不存在/key存在但value為null）
*
* @see #put(Object, Object)
*/
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 給定key如果不存在的話，就傳回預設值
*/
@Override
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
/**
* 實作 Map.get 和其他相關方法
*
* @param hash key的哈希
* @param key key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
//相關變量
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//檢查哈希桶是否為null，長度是否大于0，計算下标取出元素判斷是否為null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//對應的下标存在元素，則證明該key存在映射
//每次都對元素(連結清單首節點)進行檢查判斷
//如果是要找的節點，則傳回
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);
}
}
//如果未搜尋到節點，則傳回null
return null;
}
remove
成雙成對，不存在的。這裡還有一個
remove
方法，用來移除鍵值對。
/**
* 根據給定的key從map中移除指定鍵值對
*/
public V remove(Object key) {
Node<K,V> e;
//調用下方的removeNode來實作移除
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
* 根據給定的key和value從map中移除指定鍵值對
*/
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
/**
* 實作 Map.remove 和相關方法
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//前置判斷，包括哈希桶是否為null，長度是否為0以及是否存在元素等
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//以下開始查找節點，跟getNode的類似，不再贅述
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
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)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//存在節點
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
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 - 1
--size;
//空實作
afterNodeRemoval(node);
return node;
}
}
return null;
}
clear
清空hashmap的操作
/**
* 清空所有鍵值對映射
* 調用結束後map将會被置空
*/
public void clear() {
Node<K,V>[] tab;
//操作計數 + 1
modCount++;
//判斷哈希桶是否已經初始化
if ((tab = table) != null && size > 0) {
size = 0;
//循環清空
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
containsValue
調用該方法判斷map中是否存在對應的value
/**
* 如果map中存在指定value，則傳回true
*
* @param value value whose presence in this map is to be tested
* @return <tt>true</tt> if this map maps one or more keys to the
* specified value
*/
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
//判斷哈希桶是否被初始化過
if ((tab = table) != null && size > 0) {
//哈希桶循環查詢
for (int i = 0; i < tab.length; ++i) {
//哈希桶上每個元素，進行循環查詢
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
//存在值則傳回
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
其他方法
除了上面羅列的一些關鍵方法外，Hashmap還提供了以下方法，不再具體分析源碼。
- keySet----------------- 擷取所有的key(Set)
- values----------------- 擷取所有的值(Collection)
- entrySet--------------- 擷取鍵值對集合(Set)
- computeIfAbsent---- 值不存在則放入
- merge------------------ 給定的key沒有綁定，則進行綁定，否則替換原key的值
- forEach---------------- 循環
- replace/replaceAll--- 替換
注意
HashMap非線程安全，如果在并發場景下，使用HashMap要小心。
另外，如果需要線程安全的Map，可以移步
ConcurrentHashMap
當然，不care效率的話，HashTable也是OK的。
總結
1、關鍵常量，如樹化門檻值等，見文章頭部。
1、關鍵成員變量
- table 哈希桶
- loadFactor 負載因子
- threshold 門檻值
2、構造時，除了指定map進行構造外，其他構造函數均未初始化哈希桶。
3、通過hash來确認元素在桶中的位置，是以hash要足夠分散，否則容易造成碰撞導緻性能問題。
4、其他的諸如put、get、remove等關鍵操作的流程已在上訴源碼中分析，之後抽空看能不能畫個圖更直覺。
5、其他的待補充。
篇幅有點長，溜了溜了，如果對你有幫助無妨給個贊呗~~3Q
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)