歡迎大家關注Java經驗分享,裡面大量BATJ面試題,Java技術乾貨、行業雜談,也歡迎大家投稿~
java經驗分享?zhuanlan.zhihu.com
HashMap在日常開發中基本是天天見的,而且都知道什麼時候需要用HashMap,根據Key存取Value,但是存和取的時候那些操作卻是很少去研究。同時在面試中也是面試官們必問的。以下是基於JDK1.8
以下是基於JDK1.8
先看看HashMap的結構圖:
// hashMap數組的初始容量 16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 負載因子 0.75f; static final float DEFAULT_LOAD_FACTOR = 0.75f; // 樹形化閾值 8 static final int TREEIFY_THRESHOLD = 8; // 解除樹形化閾值 6 static final int UNTREEIFY_THRESHOLD = 6; // 樹形化的另一條件 Map數組的長度閾值 64 static final int MIN_TREEIFY_CAPACITY = 64 // 這個就是hashMap的內部數組了,而Node則是鏈表節點對象。 transient Node<K,V>[] table; // 數組擴容閾值。 int threshold;
initialCapacity 數組的初始容量為16。可以在構造方法中指定。必須是2的冪次方。(16 → 32 → 64 ...)
initialCapacity
loadFactor 載入因子 0.75f。 所謂的載入因子就是HashMap的容量達到0.75時的時候會試試擴容resize(), (例:假設有一個 HashMap 的初始容量為 16 ,那麼擴容的閥值就是 0.75 * 16 = 12 。也就是說,在你打算存入第 13 個值的時候,HashMap 會先執行擴容)。載入因子也能通過構造方法中指定,如果指定大於1,則數組不會擴容,犧牲了性能不過提升了內存。
loadFactor
resize()
TREEIFY_THRESHOLD 樹形化閾值。當鏈表的節點個數大於等於這個值時,會將鏈錶轉化為紅黑樹。
TREEIFY_THRESHOLD
UNTREEIFY_THRESHOLD 解除樹形化閾值。當鏈表的節點個數小於等於這個值時,會將紅黑樹轉換成普通的鏈表。
UNTREEIFY_THRESHOLD
MIN_TREEIFY_CAPACITY樹形化閾值的第二條件。當數組的長度小於這個值時,就算樹形化閾達標,鏈表也不會轉化為紅黑樹,而是優先擴容數組resize()。
MIN_TREEIFY_CAPACITY
threshold 數組擴容閾值。即:HashMap數組總容量 * 載入因子。當前容量大於或等於該值時會執行擴容resize()。擴容的容量為當前 HashMap 總容量的兩倍。比如,當前 HashMap 的總容量為 16 ,那麼擴容之後為 32 。
threshold
// table 內部數組是節點類型 static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; //下一個節點 //省略... }
拉鏈法的散列表是通過鏈表解決碰撞問題的,所以HashMap的內部數組是節點類型。 hash值是經過hash()方法處理過的hashCode,也就是數組的索引 bucket,為了使hashCode分布更加隨機。
hash
hash()
數組的索引 bucket
java.util.HashMap<K, V>.Node<K, V> java.util.LinkedMap<K, V>.Entry<K, V> java.util.HashMap<K, V>.TreeNOde<K, V>
TreeNode是Node是子類,繼承關係如下:Node是單向鏈表節點,Entry是雙向鏈表節點,TreeNode是紅黑樹節點。TreeNode的代碼400多行都是寫的紅黑樹。這個有點難度..可以自行去了解。
HashMap是基於拉鏈法實現的一個散列表,內部由數組和鏈表和紅黑樹實現。
// 默認數組初始容量為16,負載因子為0.75f 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); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY;
// NaN:Not a Number。例如給-1開方就會得到NaN。 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor;
// 這個方法可以將任意一個整數轉換成2的次方。 // 例如輸入10,則會返回16。 // 另外,有人可能疑惑,不是說threshold是 數組容量 * loadFactor得到的嗎? // 是的,在第一次put操作,擴充數組時,會將這個threshold作為數組容量,然後再重新計算這個值。 this.threshold = tableSizeFor(initialCapacity); }
在使用指定數組的初始容量時上面說過,數組容量必須是2的次方。所以就需要通過演算法將我們給定的數值轉換成2的次方。
// 這個方法可以將任意一個整數轉換成2的次方。 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採用hash演算法來決定集合中元素的存儲位置,每當系統初始化HashMap時,會創建一個為capacity的數組,這個數組裡面可以存儲元素的位置被成為桶(bucket), 每個bucket都有其指定索引。可以根據該索引快速訪問存儲的元素。
capacity
桶(bucket)
bucket
public V put(K key, V value) { // 傳入的key經過了 hash(key) 方法 return putVal(hash(key), key, value, false, true); } // 特殊處理的hashCode static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
在Java中每個對象都會擁有一個hashCode()方法,這個就是散列函數,通過這個方法會返回一個32位的整數,使用這麼大的值作為哈希值其實是為了盡量避免發生碰撞(相同),例如兩個不同對象的hashCode一樣的話那就是發生了碰撞。但是如果用這麼長的數字來當做索引肯定是不行的,那需要數組有多大才行?所以我們需要把這個hashCode縮小到規定數組的長度範圍內。
hashCode()
上面的代碼只是用hashCode的高16位與低16位進行異或運算。hash()方法就是將hashCode進一步的混淆,增加其「隨機度」,試圖減少插入HashMap時的hash衝突。
「隨機度」,試
圖減少插入HashMap時的hash衝突
在putVal方法中,有一行這樣的代碼
if ((p = tab[i = (n - 1) & hash]) == null)
i = (n - 1) & hash,n是數組長度,hash就是通過hash()方法進行高低位異或運算得出來的hash值。
i = (n - 1) & hash
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
// onlyIfAbsent:當存入鍵值對時,如果該key已存在,是否覆蓋它的value。false為覆蓋,true為不覆蓋 參考putIfAbsent()方法。 // evict:用於子類LinkedHashMap。 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { HashMap.Node<K,V>[] tab; // tab:內部數組 HashMap.Node<K,V> p; // p:hash對應的索引位中的首節點 int n, i; // n:內部數組的長度 i:hash對應的索引位
// 首次put時,內部數組為空,擴充數組。 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 計算數組索引,獲取該索引位置的首節點,如果為null,添加一個新的節點 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { HashMap.Node<K,V> e; K k; // 如果首節點的key和要存入的key相同,那麼直接覆蓋value的值。 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; // 如果首節點是紅黑樹的,將鍵值對插添加到紅黑樹 else if (p instanceof HashMap.TreeNode) e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // 此時首節點為鏈表,如果鏈表中存在該鍵值對,直接覆蓋value。 // 如果不存在,則在末端插入鍵值對。然後判斷鏈表是否大於等於7,嘗試轉換成紅黑樹。 // 注意此處使用「嘗試」,因為在treeifyBin方法中還會判斷當前數組容量是否到達64, // 否則會放棄次此轉換,優先擴充數組容量。 else { // 走到這裡,hash碰撞了。檢查鏈表中是否包含key,或將鍵值對添加到鏈表末尾 for (int binCount = 0; ; ++binCount) { // p.next == null,到達鏈表末尾,添加新節點,如果長度足夠,轉換成樹結構。 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } // 檢查鏈表中是否已經包含key if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } }
// 覆蓋value的方法。 if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; // fail-fast機制
// 如果元素個數大於閾值,擴充數組。 if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }
細心看注釋部分,總結來說就是以下幾個步驟:
1.檢查數組是否為空,執行resize()擴充;
(沒發生碰撞)
(bucket)
(發生碰撞)
① key和首節點的key相同,覆蓋old value(保證key的唯一性);否則執行②或③
(保證key的唯一性)
// 把鏈錶轉換為紅黑色 final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; // 如果當前數組容量太小(小於64),放棄轉換,擴充數組。 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); } else if ((e = tab[index = (n - 1) & hash]) != null) { // 將鏈錶轉成紅黑樹... } }
HashMap在jdk1.8之後引入了紅黑樹的概念,表示若桶中鏈表元素超過8時,會自動轉化成紅黑樹;若桶中元素小於等於6時,樹結構還原成鏈表形式。
紅黑樹的平均查找長度是log(n),長度為8,查找長度為log(8)=3,鏈表的平均查找長度為n/2,當長度為8時,平均查找長度為8/2=4,這才有轉換成樹的必要;鏈表長度如果是小於等於6,6/2=3,雖然速度也很快的,但是轉化為樹結構和生成樹的時間並不會太短。
以6和8來作為平衡點是因為,中間有個差值7可以防止鏈表和樹之間頻繁的轉換。假設,如果設計成鏈表個數超過8則鏈錶轉換成樹結構,鏈表個數小於8則樹結構轉換成鏈表,如果一個HashMap不停的插入、刪除元素,鏈表個數在8左右徘徊,就會頻繁的發生樹轉鏈表、鏈錶轉樹,效率會很低。
概括起來就是:鏈表:如果元素小於8個,查詢成本高,新增成本低,紅黑樹:如果元素大於8個,查詢成本低,新增成本高。
final HashMap.Node<K,V>[] resize() { HashMap.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) { threshold = Integer.MAX_VALUE; return oldTab; } // 否則數組容量擴充一倍。(2的N次方) else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } // 如果數組還沒創建,但是已經指定了threshold(這種情況是帶參構造創建的對象),threshold的值為數組長度 // 在 "構造函數" 那塊內容進行過說明。 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; // 這種情況是通過無參構造創建的對象 else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } // 可能是上面newThr = oldThr << 1時,最高位被移除了,變為0。 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"}) HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap]; table = newTab;
// 下面代碼是將原來數組的元素轉移到新數組中。問題在於,數組長度發生變化。 // 那麼通過hash%數組長度計算的索引也將和原來的不同。 // jdk 1.7中是通過重新計算每個元素的索引,重新存入新的數組,稱為rehash操作。 // 這也是hashMap無序性的原因之一。而現在jdk 1.8對此做了優化,非常的巧妙。 if (oldTab != null) {
// 遍歷原數組 for (int j = 0; j < oldCap; ++j) { // 取出首節點 HashMap.Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; // 如果鏈表只有一個節點,那麼直接重新計算索引存入新數組。 if (e.next == null) newTab[e.hash & (newCap - 1)] = e; // 如果該節點是紅黑樹,執行split方法,和鏈表類似的處理。 else if (e instanceof HashMap.TreeNode) ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 此時節點是鏈表 else { // preserve order // loHead,loTail為原鏈表的節點,索引不變。 HashMap.Node<K,V> loHead = null, loTail = null; // hiHeadm, hiTail為新鏈表節點,原索引 + 原數組長度。 HashMap.Node<K,V> hiHead = null, hiTail = null; HashMap.Node<K,V> next;
// 遍歷鏈表 do { next = e.next; // 新增bit為0的節點,存入原鏈表。 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } // 新增bit為1的節點,存入新鏈表。 else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); // 原鏈表存回原索引位 if (loTail != null) { loTail.next = null; newTab[j] = loHead; } // 新鏈表存到:原索引位 + 原數組長度 if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
擴充數組不單單只是讓數組長度翻倍,將原數組中的元素直接存入新數組中這麼簡單。
因為元素的索引是通過hash&(n - 1)得到的,那麼數組的長度由n變為2n,重新計算的索引就可能和原來的不一樣了。
在jdk1.7中,是通過遍歷每一個元素,每一個節點,重新計算他們的索引值,存入新的數組中,稱為rehash操作。
而java1.8對此進行了一些優化,沒有了rehash操作。因為當數組長度是通過2的次方擴充的,那麼會發現以下規律:
元素的位置要麼是在原位置,要麼是在原位置再移動2次冪的位置。因此,在擴充HashMap的時候,不需要像JDK1.7的實現那樣重新計算hash,只需要看看原來的hash值新增的那個bit是1還是0就好了,是0的話索引沒變,是1的話索引變成「原索引+oldCap」。
先計算新數組的長度和新的閾值(threshold),然後將舊數組的內容遷移到新數組中,和1.7相比不需要執行rehash操作。因為以2次冪擴展的數組可以簡單通過新增的bit判斷索引位。
public V get(Object key) { Node<K,V> e; // 也會獲取節點時也調用了hash()方法 return (e = getNode(hash(key), key)) == null ? null : e.value; }
final Node<K,V> getNode(int hash, Object key) { // tab:內部數組 first: 索引位首節點 n: 數組長度 k: 索引位首節點的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) { // 如果索引位首節點的hash==key的hash 或者 key和索引位首節點的k相同 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 { // 發送碰撞 key.equals(k) if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }
總結起來就是以下步驟
(bucket的第一個節點)
呃..
Map m = Collections.synchronizeMap(hashMap);
查看第序號3的總結。
put() 查看序號4.3的總結。
兩個對象的hashCode相同所以它們的bucket位置相同,會發生hash碰撞。HashMap使用鏈表存儲對象,這個Entry會存儲在鏈表中,存儲時會檢查鏈表中是否包含key (key != null && key.equals(k),或將鍵值對添加到鏈表尾部。如果鏈表長度大於或等於8,鏈錶轉換紅黑樹 ...
(key != null && key.equals(k)
兩個對象的hashCode相同所以它們的bucket位置相同,找到bucket位置之後,會調用keys.equals()方法去找到鏈表中正確的節點 (key != null && key.equals(k)。
使用final修飾的對象、或不可變的對象作為鍵,使用(Integer、String)(是不可變、final的,而且已經重寫了equals和hashCode方法)這樣的wrapper類作為鍵是非常好的,(我們可以使用自定義的對象作為鍵嗎?答:當然可以,只要它遵守了equals和hashCode方法定義規則,並且當對象插入到Map中之後將不會再改變。)
會調用resize()進行數組擴容。
當多線程的情況下,可能產生條件競爭。
因為如果兩個線程都發現HashMap需要重新調整大小了,它們會同時試著調整大小。在調整大小的過程中,存儲在鏈表中的元素的次序會反過來,因為移動到新的bucket位置的時候,HashMap並不會將元素放在鏈表的尾部,而是放在頭部,這是為了避免尾部遍歷(tail traversing)。如果條件競爭發生了,那麼就死循環了。這個時候,你可以質問面試官,為什麼這麼奇怪,要在多線程的環境下使用HashMap呢?:)
由於HashMap的容量是有限的,如果HashMap中的數組的容量很小,假如只有2個,那麼如果要放進10個keys的話,碰撞就會非常頻繁,此時一個O(1)的查找演算法,就變成了鏈表遍歷,性能變成了O(n),這是Hash表的缺陷。
為了解決這個問題,HashMap設計了一個閾值,其值為容量的0.75,當HashMap所用容量超過了閾值後,就會自動擴充其容量。
在多線程的情況下,當重新調整HashMap大小的時候,就會存在條件競爭,因為如果兩個線程都發現HashMap需要重新調整大小了,它們會同時試著調整大小。在調整大小的過程中,存儲在鏈表中的元素的次序會反過來,因為移動到新的bucket位置的時候,HashMap並不會將元素放在鏈表的尾部,而是放在頭部,這是為了避免尾部遍歷。如果條件競爭發生了,那麼就會產生死循環了。 (又繞回了上一個問題 :)
必須重寫hashCode和equals方法
如果key為null會放在第一個bucket(即下標0)位置, 而且是在鏈表最前面(即第一個位置)
java經驗分享?zhuanlan.zhihu.com 推薦閱讀: