HashMap的特點
- 不允許重複的key,支持Null值和Null鍵(Null鍵會被放在第一位)
- 元素是無序的-不能保證存儲順序
- 是線程不安全的(存在高併發問題)
- 性能較高
Java8HashMap採用的是數組+鏈表+紅黑樹的數據結構 ,結構如下
繼承和實現情況
HashMap實現了Map<K,V>, Cloneable, Serializable接口,並繼承AbstractMap<K,V>類
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
成員變量
主要包含一些字段和常量
/* ---------------- 常量 -------------- */
/**
* 默認的初始容量(2的4次方)-是2冪次方
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量爲2的30次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默認的負載因子,如果沒有指定的話就使用0.75
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 當鏈表元素達到8個的時候從鏈表結構變成紅黑樹結構
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 存儲計數閾值,用於在存儲期間取消(分割)存儲
* 調整操作。應該小於TREEIFY_THRESHOLD,在大多數6網孔與收縮檢測下去除。
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 容器可能被treeified的最小表容量。(否則,如果容器中有太多節點,就會調整表的大小。)
* 應該至少4 * TREEIFY_THRESHOLD以避免衝突在大小調整和樹化閾值之間。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/* ---------------- 字段 -------------- */
/**
* 具體存儲數據的地方
*/
transient Node<K,V>[] table;
/**
* entrySet()方法中的數據
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 實際存儲的key-value鍵值對的個數
*/
transient int size;
/**
* 這個HashMap在結構上被修改的次數
* 結構修改是指改變映射的數量
* HashMap或修改其內部結構(例如,重新哈希)。的集合視圖上的迭代器
* HashMap很快失敗。(見ConcurrentModificationException)。
*/
transient int modCount;
/**
* 閾值,當table == {}時,該值爲初始容量(初始容量默認爲16);當table被填充了,也就是爲
* table分配內存空間後,threshold一般爲 capacity*loadFactory
*/
int threshold;
/**
* 負載因子,代表了table的填充度有多少,默認是0.75
*/
final float loadFactor;
構造函數
//默認構造,所有的字段都是使用默認值
//負載因子默認值0.75
//容量默認值16
public HashMap() {
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);
//超過容量最大值就指定爲容量最大值(2的30次方)
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的冪次方且最接近並大於給定容量
* 比如給定 給定13,那得出的值應該是2的4次方=16
*/
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;
}
//給定一個集合
public HashMap(Map<? extends K, ? extends V> m) {
//使用默認字段構造HashMap
this.loadFactor = DEFAULT_LOAD_FACTOR;
//將集合中的元素放在新的map中
putMapEntries(m, false);
}
//將元素全部放在新生成的map中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
//元素個數大於才需要進行put操作
if (s > 0) {
//如果table是空,需要計算負載因子和閾值
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);
}
//如果給定的map的size大於閾值,需要對新的map進行擴容
else if (s > threshold)
resize();
//循環獲取數據並拷貝到新map中
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);
}
}
}
擴容函數:resize()
- 該方法主要是在初始化數組和數組擴容的時候使用,如果是擴容的話大多數情況是擴容爲原容量的2倍(如果擴容到最大值,以後就不在需要擴容)
- 有數據的時候需要完成數據的遷移
//主要進行map的擴容
final Node<K, V>[] resize() {
// 定義舊的table保存當前table
Node<K, V>[] oldTab = table;
// 定義舊的容量保存當前table的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 定義舊的閾值保存當前閾值
int oldThr = threshold;
// 初始化新的table容量和閾值
int newCap, newThr = 0;
//1.如果舊的容量>0(說明是需要擴容的-舊的容量大於最的容量就直接擴容到最大整型,否則容量翻倍)
if (oldCap > 0) {
// 若舊table容量已超過最大容量,更新閾值爲Integer.MAX_VALUE(最大整形值),
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab; //這樣以後就不會自動擴容了
}
// 容量翻倍,使用左移,效率更高
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 閾值翻倍
newThr = oldThr << 1; // double threshold
}
//2.如果舊的閾值是>0說明之前已經初始化過Map,第一次put的時候
else if (oldThr > 0) // initial capacity was placed in threshold
//當table沒初始化時,threshold持有初始容量,threshold = tableSizeFor(t);
newCap = oldThr;
//3.使用默認初始化後,第一次put的時候
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 新閾值爲0
if (newThr == 0) {
float ft = (float) newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
(int) ft : Integer.MAX_VALUE);
}
threshold = newThr;
// 初始化table-使用新的容量
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;
//如果該數組位置是一個元素的鏈表,直接遷移就好
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 若節點是 TreeNode 節點,要進行 紅黑樹的 rehash 操作
else if (e instanceof TreeNode)
((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
// 若是鏈表,進行鏈表的 rehash 操作根據(e.hash & oldCap)是否爲0進行分割(代碼後有圖解,可以回過頭再來看),分成兩個不同的鏈表,完成rehash
// 需要將此鏈表拆成兩個鏈表,放到新的數組中,並且保留原來的先後順序
// loHead、loTail 對應一條鏈表,hiHead、hiTail 對應另一條鏈表
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 判斷節點位置rehash 後是否發生改變
//最高位==0,這是索引不變的鏈表。
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//最高位==1 (這是索引發生改變的鏈表)
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
// 原bucket位置的尾指針不爲空(即還有node)
loTail.next = null;
// 第一條鏈表
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
// 第二條鏈表的新的位置是 j + oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
}
put() 過程分析
- 根據table判斷是否進行擴容
- 根據hash值找到數組的下標-如果當前位置沒有值,直接初始化Node並放置在這個位置
- 如果hash對應的下標下有值,如果是鏈表的話進行鏈表的尾插法插入數據(Java7中是頭插法),如果數量達到8個需要將鏈表變成紅黑樹結構
- 如果是紅黑樹,則進行紅黑樹的數據插入
- 最後再次判斷是否需要擴容
- 返回null或者返回被替換位置的舊值
//實際是調用putVal()方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 第四個參數 onlyIfAbsent 如果是 true,那麼只有在不存在該 key 時纔會進行 put 操作
// 第五個參數 evict在進行方法增強的時候纔會使用到
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果數組是null或者是數組長度是0,會觸發擴容操作
// 第一次 resize 和後續的擴容有些不一樣,因爲這次是數組從 null 初始化到默認的 16 或自定義的初始容量
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 找到具體的數組下標,如果此位置沒有值,那麼直接初始化一下 Node 並放置在這個位置就可以了
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 數組該位置有數據
else {
Node<K,V> e; K k;
// 首先,判斷該位置的第一個數據和我們要插入的數據,key 是不是"相等",如果是,取出這個節點
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果該節點是代表紅黑樹的節點,調用紅黑樹的插值方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 到這裏,說明數組該位置上是一個鏈表
for (int binCount = 0; ; ++binCount) {
// 插入到鏈表的最後面(Java7 是插入到鏈表的最前面)
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// TREEIFY_THRESHOLD 爲 8,所以,如果新插入的值是鏈表中的第 8 個
// 會觸發下面的 treeifyBin,也就是將鏈表轉換爲紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果在該鏈表中找到了"相等"的 key(== 或 equals)
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 此時 break,那麼 e 爲鏈表中[與要插入的新值的 key "相等"]的 node
break;
p = e;
}
}
// e!=null 說明存在舊值的key與要插入的key"相等"
// 對於我們分析的put操作,下面這個 if 其實就是進行 "值覆蓋",然後返回舊值
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);//空實現
return oldValue;
}
}
++modCount;
// 如果 HashMap 由於新插入這個值導致 size 已經超過了閾值,需要進行擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);//方法是空實現-可自行實現
return null;
}
get() 過程分析
- 計算 key 的 hash 值,根據 hash 值找到對應數組下標: hash & (length-1)
- 判斷數組該位置處的元素是否剛好就是我們要找的,如果是直接獲取找到的數據,否則繼續向下執行
- 判斷該元素類型是否是 TreeNode,如果是,用紅黑樹的方法取數據,否則,繼續執行
- 遍歷鏈表,直到找到相等(==或equals)的 key
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;
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;
}
對於其他的操作方法,基本邏輯大致爲:
- 根據key獲取hash值
- 根據hash值定位到數組的角標
- 獲取角標下的數組元素,如果是鏈表,按照鏈表的操作方式進行操作,如果是紅黑樹按照紅黑樹的操作方式進行操作