初識HashMap安全
以前的List,講了ArrayList、LinkedList,最後講到了CopyOnWriteArrayList,就前二者而言,反映的是兩種思想:數據結構
(1)ArrayList以數組形式實現,順序插入、查找快,插入、刪除較慢app
(2)LinkedList以鏈表形式實現,順序插入、查找較慢,插入、刪除方便
那麼是否有一種數據結構可以結合上面兩種的優勢呢?有,答案就是HashMap。
HashMap是一種很是常見、方便和有用的集合,是一種鍵值對(K-V)形式的存儲結構,下面將仍是用圖示的方式解讀HashMap的實現原理,
四個關注點在HashMap上的答案
關 注 點 | 結 論 |
HashMap是否容許空 | Key和Value都容許爲空 |
HashMap是否容許重複數據 | Key重複會覆蓋、Value容許重複 |
HashMap是否有序 | 無序,特別說明這個無序指的是遍歷HashMap的時候,獲得的元素的順序基本不多是put的順序 |
HashMap是否線程安全 | 非線程安全 |
添加數據
首先看一下HashMap的一個存儲單元Entry:
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next; int hash; ... }
以前一篇寫LinkedList的文章,裏面寫到LinkedList是一個雙向鏈表,從HashMap的Entry看得出,Entry組成的是一個單向鏈表,由於裏面只有Entry的後繼Entry,而沒有Entry的前驅Entry。用圖表示應該是這麼一個數據結構:
接下來,假設我有這麼一段代碼:
1 public static void main(String[] args) 2 { 3 Map<String, String> map = new HashMap<String, String>(); 4 map.put("111", "111"); 5 map.put("222", "222"); 6 }
看一下作了什麼。首先從第3行開始,new了一個HashMap出來:
1 public HashMap() { 2 this.loadFactor = DEFAULT_LOAD_FACTOR; 3 threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR); 4 table = new Entry[DEFAULT_INITIAL_CAPACITY]; 5 init(); 6 }
注意一下第5行的init()是個空方法,它是HashMap的子類好比LinkedHashMap構造的時候使用的。DEFAULT_INITIAL_CAPACITY爲16,也就是說,HashMap在new的時候構造出了一個大小爲16的Entry數組,Entry內全部數據都取默認值,如圖示爲:
看到new出了一個大小爲16的Entry數組來。接着第4行,put了一個Key和Value同爲111的字符串,看一下put的時候底層作了什麼:
1 public V put(K key, V value) { 2 if (key == null) 3 return putForNullKey(value); 4 int hash = hash(key.hashCode()); 5 int i = indexFor(hash, table.length); 6 for (Entry<K,V> e = table[i]; e != null; e = e.next) { 7 Object k; 8 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 9 V oldValue = e.value; 10 e.value = value; 11 e.recordAccess(this); 12 return oldValue; 13 } 14 } 15 16 modCount++; 17 addEntry(hash, key, value, i); 18 return null; 19 }
1 static int hash(int h) { 2 // This function ensures that hashCodes that differ only by 3 // constant multiples at each bit position have a bounded 4 // number of collisions (approximately 8 at default load factor). 5 h ^= (h >>> 20) ^ (h >>> 12); 6 return h ^ (h >>> 7) ^ (h >>> 4); 7 }
1 static int indexFor(int h, int length) { 2 return h & (length-1); 3 }
看一下put方法的幾個步驟:
一、第2行~第3行就是HashMap容許Key值爲空的緣由,空的Key會默認放在第0位的數組位置上
二、第4行拿到Key值的HashCode,因爲HashCode是Object的方法,所以每一個對象都有一個HashCode,對這個HashCode作一次hash計算。按照JDK源碼註釋的說法,此次hash的做用是根據給定的HashCode對它作一次打亂的操做,防止一些糟糕的Hash算法產生的糟糕的Hash值,至於爲何要防止糟糕的Hash值,HashMap添加元素的最後會講到
三、第5行根據從新計算的HashCode,對Entry數組的大小取模獲得一個Entry數組的位置。看到這裏使用了&,移位加快一點代碼運行效率。另外,這個取模操做的正確性依賴於length必須是2的N次冪,這個熟悉二進制的朋友必定理解,所以注意HashMap構造函數中,若是你指定HashMap初始數組的大小initialCapacity,若是initialCapacity不是2的N次冪,HashMap會算出大於initialCapacity的最小2的N次冪的值,做爲Entry數組的初始化大小。這裏爲了講解方便,咱們假定字符串111和字符串222算出來的i都是1
四、第6行~第14行會先判斷一下原數據結構中是否存在相同的Key值,存在則覆蓋並返回,不執行後面的代碼。注意一下recordAccess這個方法,它也是HashMap的子類好比LinkedHashMap用的,HashMap中這個方法爲空。另外,注意一點,對比Key是否相同,是先比HashCode是否相同,HashCode相同再判斷equals是否爲true,這樣大大增長了HashMap的效率,對HashCode不熟悉的朋友能夠看一下個人這篇文章講講HashCode的做用
五、第16行的modeCount++是用於fail-fast機制的,每次修改HashMap數據結構的時候都會自增一次這個值
而後就到了關鍵的addEntry方法了:
void addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K,V>(hash, key, value, e); if (size++ >= threshold) resize(2 * table.length); }
Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; }
假設new出來的Entry地址爲0x00000001,那麼,put("111", "111")用圖表示應該是這樣的:
每個新增的Entry都位於table[1]上,另外,裏面的hash是rehash以後的hash而不是Key最原始的hash。看到table[1]上存放了111---->111這個鍵值對,它持有原table[1]的引用地址,所以能夠尋址到原table[1],這就是單向鏈表。 再看一下put("222", "222")作了什麼,一張圖就能夠理解了:
新的Entry再次佔據table[1]的位置,而且持有原table[1],也就是111---->111這個鍵值對。
至此,HashMap進行put數據的過程就呈現清楚了。不過還有一個問題,就是HashMap如何進行擴容,再看一下addEntry方法:
1 void addEntry(int hash, K key, V value, int bucketIndex) { 2 Entry<K,V> e = table[bucketIndex]; 3 table[bucketIndex] = new Entry<K,V>(hash, key, value, e); 4 if (size++ >= threshold) 5 resize(2 * table.length); 6 }
看到第4行~第5行,也就是說在每次放置完Entry以後都會判斷是否須要擴容。這裏不講擴容是由於HashMap擴容在不正確的使用場景下將會致使死循環,這是一個值得探討的話題,也是我工做中實際遇到過的一個問題,所以下一篇文章將會詳細說明爲何不正確地使用HashMap會致使死循環。
刪除數據
有一段代碼:
1 public static void main(String[] args) 2 { 3 Map<String, String> map = new HashMap<String, String>(); 4 map.put("111", "111"); 5 map.put("222", "222"); 6 map.remove("111"); 7 }
第6行刪除元素,看一下刪除元素的時候作了什麼,第4行~第5行添加了兩個鍵值對就沿用上面的圖,HashMap刪除指定鍵值對的源代碼是:
1 public V remove(Object key) { 2 Entry<K,V> e = removeEntryForKey(key); 3 return (e == null ? null : e.value); 4 }
1 final Entry<K,V> removeEntryForKey(Object key) { 2 int hash = (key == null) ? 0 : hash(key.hashCode()); 3 int i = indexFor(hash, table.length); 4 Entry<K,V> prev = table[i]; 5 Entry<K,V> e = prev; 6 7 while (e != null) { 8 Entry<K,V> next = e.next; 9 Object k; 10 if (e.hash == hash && 11 ((k = e.key) == key || (key != null && key.equals(k)))) { 12 modCount++; 13 size--; 14 if (prev == e) 15 table[i] = next; 16 else 17 prev.next = next; 18 e.recordRemoval(this); 19 return e; 20 } 21 prev = e; 22 e = next; 23 } 24 25 return e; 26 }
分析一下remove元素的時候作了幾步:
一、根據key的hash找到待刪除的鍵值對位於table的哪一個位置上
二、記錄一個prev表示待刪除的Entry的前一個位置Entry,e能夠認爲是當前位置
三、從table[i]開始遍歷鏈表,假如找到了匹配的Entry,要作一個判斷,這個Entry是否是table[i]:
(1)是的話,也就是第14行~第15行,table[i]就直接是table[i]的下一個節點,後面的都不須要動
(2)不是的話,也就是第16行~第17行,e的前一個Entry也就是prev,prev的next指向e的後一個節點,也就是next,這樣,e所表明的Entry就被踢出了,e的先後Entry就連起來了
remove("111")用圖表示就是:
整個過程只須要修改一個節點的next的值便可,很是方便。
修改數據
修改元素也是put,看一下源代碼:
1 public V put(K key, V value) { 2 if (key == null) 3 return putForNullKey(value); 4 int hash = hash(key.hashCode()); 5 int i = indexFor(hash, table.length); 6 for (Entry<K,V> e = table[i]; e != null; e = e.next) { 7 Object k; 8 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 9 V oldValue = e.value; 10 e.value = value; 11 e.recordAccess(this); 12 return oldValue; 13 } 14 } 15 modCount++; 16 addEntry(hash, key, value, i); 17 return null; 18 }
這個其實前面已經提到過了,第6行~第14行就是修改元素的邏輯,若是某個Key已經在數據結構中存在的話,那麼就會覆蓋原value,也就是第10行的代碼。
插入數據
所謂"插入元素",在個人理解裏,必定是基於數據結構是有序的前提下的。像ArrayList、LinkedList,再遠點說就是數據庫,一條一條都是有序的。
而HashMap,它的順序是基於HashCode,HashCode是一個隨機性很強的數字,因此HashMap中的Entry徹底是隨機存放的。HashMap又不像LinkedHashMap這樣維護了插入元素的順序,因此對HashMap這個數據結構談插入元素是沒有意義的。
因此,HashMap並無插入的概念。
再談HashCode的重要性
前面講到了,HashMap中對Key的HashCode要作一次rehash,防止一些糟糕的Hash算法生成的糟糕的HashCode,那麼爲何要防止糟糕的HashCode?
糟糕的HashCode意味着的是Hash衝突,即多個不一樣的Key可能獲得的是同一個HashCode,糟糕的Hash算法意味着的就是Hash衝突的機率增大,這意味着HashMap的性能將降低,表如今兩方面:
一、有10個Key,可能6個Key的HashCode都相同,另外四個Key所在的Entry均勻分佈在table的位置上,而某一個位置上卻鏈接了6個Entry。這就失去了HashMap的意義,HashMap這種數據結構性高性能的前提是,Entry均勻地分佈在table位置上,但如今確是1 1 1 1 6的分佈。因此,咱們要求HashCode有很強的隨機性,這樣就儘量地能夠保證了Entry分佈的隨機性,提高了HashMap的效率。
二、HashMap在一個某個table位置上遍歷鏈表的時候的代碼:
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
看到,因爲採用了"&&"運算符,所以先比較HashCode,HashCode都不相同就直接pass了,不會再進行equals比較了。HashCode由於是int值,比較速度很是快,而equals方法每每會對比一系列的內容,速度會慢一些。Hash衝突的機率大,意味着equals比較的次數勢必增多,必然下降了HashMap的效率了。
HashMap的table爲何是transient的
一個很是細節的地方:
transient Entry[] table;
看到table用了transient修飾,也就是說table裏面的內容全都不會被序列化,不知道你們有沒有想過這麼寫的緣由?
在我看來,這麼寫是很是必要的。由於HashMap是基於HashCode的,HashCode做爲Object的方法,是native的:
public native int hashCode();
這意味着的是:HashCode和底層實現相關,不一樣的虛擬機可能有不一樣的HashCode算法。再進一步說得明白些就是,可能同一個Key在虛擬機A上的HashCode=1,在虛擬機B上的HashCode=2,在虛擬機C上的HashCode=3。
這就有問題了,Java自誕生以來,就以跨平臺性做爲最大賣點,好了,若是table不被transient修飾,在虛擬機A上能夠用的程序到虛擬機B上能夠用的程序就不能用了,失去了跨平臺性,由於:
一、Key在虛擬機A上的HashCode=100,連在table[4]上
二、Key在虛擬機B上的HashCode=101,這樣,就去table[5]上找Key,明顯找不到
整個代碼就出問題了。所以,爲了不這一點,Java採起了重寫本身序列化table的方法,在writeObject選擇將key和value追加到序列化的文件最後面:
private void writeObject(java.io.ObjectOutputStream s) throws IOException { Iterator<Map.Entry<K,V>> i = (size > 0) ? entrySet0().iterator() : null; // Write out the threshold, loadfactor, and any hidden stuff s.defaultWriteObject(); // Write out number of buckets s.writeInt(table.length); // Write out size (number of Mappings) s.writeInt(size); // Write out keys and values (alternating) if (i != null) { while (i.hasNext()) { Map.Entry<K,V> e = i.next(); s.writeObject(e.getKey()); s.writeObject(e.getValue()); } } }
而在readObject的時候重構HashMap數據結構:
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the threshold, loadfactor, and any hidden stuff s.defaultReadObject(); // Read in number of buckets and allocate the bucket array; int numBuckets = s.readInt(); table = new Entry[numBuckets]; init(); // Give subclass a chance to do its thing. // Read in size (number of Mappings) int size = s.readInt(); // Read the keys and values, and put the mappings in the HashMap for (int i=0; i<size; i++) { K key = (K) s.readObject(); V value = (V) s.readObject(); putForCreate(key, value); } }
一種麻煩的方式,但卻保證了跨平臺性。
這個例子也告訴了咱們:儘管使用的虛擬機大多數狀況下都是HotSpot,可是也不能對其它虛擬機無論不顧,有跨平臺的思想是一件好事。
HashMap和Hashtable的區別
HashMap和Hashtable是一組類似的鍵值對集合,它們的區別也是面試常被問的問題之一,我這裏簡單總結一下HashMap和Hashtable的區別:
一、Hashtable是線程安全的,Hashtable全部對外提供的方法都使用了synchronized,也就是同步,而HashMap則是線程非安全的
二、Hashtable不容許空的value,空的value將致使空指針異常,而HashMap則無所謂,沒有這方面的限制
三、上面兩個缺點是最主要的區別,另一個區別可有可無,我只是提一下,就是兩個的rehash算法不一樣,Hashtable的是:
private int hash(Object k) { // hashSeed will be zero if alternative hashing is disabled. return hashSeed ^ k.hashCode(); }
這個hashSeed是使用sun.misc.Hashing類的randomHashSeed方法產生的。HashMap的rehash算法上面看過了,也就是:
static int hash(int h) { // This function ensures that hashCodes that differ only by // constant multiples at each bit position have a bounded // number of collisions (approximately 8 at default load factor). h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }