HashMap
哈希表
在介紹HashMap以前，先介紹一下哈希表的概念。html
哈希表（Hash table，也叫作散列表），是根據關鍵碼值（Key Value）而直接進行訪問的數據結構。也就是說，它經過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫作散列函數，存放記錄的數組叫作散列表。java
記錄的存儲位置 = f（關鍵字）面試
這裏的對應關係 f 稱爲散列函數，又稱爲哈希（Hash函數）函數，採用散列技術將記錄存儲在一塊連續的存儲空間中，這塊連續存儲空間稱爲散列表或哈希表（Hash Table）。算法
哈希表就是把key經過一個固定的算法函數即將所謂的哈希函數轉換成一個整型數字，而後就將改數字對數組的長度進行取餘，取餘結果就看成數組的下標，將value存儲在以該數字爲下標的數組空間裏。而當使用哈希表進行查詢的時候，就是再次使用哈希函數將key轉換爲對應的數組下標，並定位到該空間獲取value，如此一來，就能夠充分利用到數組的定位性能進行數據定位。數組
數組的特色是：尋址容易、插入和刪除困難安全
鏈表的特色是：尋址困難、插入和刪除容易數據結構
那麼咱們能不能綜合二者的特性，作出一種尋址容易，插入刪除也容易的數據結構？答案是確定的，這就是咱們提到的哈希表，哈希表有多種不一樣的實現方法，接下來解釋的是最經常使用的一種方法----拉鍊法，能夠理解爲「鏈表的數組」：併發
左邊很明顯是個數組，數組的每一個成員包括一個指針，指向一個鏈表的頭，固然這個鏈表可能爲空，也可能元素不少。咱們根據元素的一些特徵把元素分配到不一樣的鏈表中去，也是根據這些特徵，找到正確的鏈表，再從鏈表中找出這個元素。app
初始HashMap
以前講了ArrayList、LinkedList，就這二者而言，反映的是兩種思想：dom
（1）ArrayList以數組形式實現，順序插入、查找快，插入、刪除慢
（2）LinkedList以鏈表形式實現，順序插入、查找較慢，插入、刪除較快
那麼是否有一種數據結構可以結合上面兩種的優勢呢？答案就是HashMap
HashMap是一種很是常見、方便和有用的集合，是一種鍵值對（K-V）形式的存儲結構。
四個關注點在HashMap上的答案
| 關 注 點 | 結 論 |
| HashMap是否容許空 | Key和Value都容許爲空 |
| HashMap是否容許重複數據 | Key重複會覆蓋、Value容許重複 |
| HashMap是否有序 | 無序，特別說明這個無序指的是遍歷HashMap的時候，獲得的元素的順序基本不多是put的順序 |
| HashMap是否線程安全 | 非線程安全 |
源碼解析
HashMap的存儲結構如上圖所示（JDK1.8之後，當鏈表長度大於8的時候，鏈表會變爲紅黑樹）。
看一下HashMap的存儲單元Entry的源碼結構：
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; ... }
HashMap是採用Entry數組來存儲key-value對，每個鍵值對組成了一個Entry實體，Entry類其實是一個單向的鏈表結構，它裏面包含next指針、key的hash值、value、key，其中next指針能夠鏈接下一個Entry實體，HashMap是以此來解決hash衝突的問題的，由於HashMap是按照key的hash值來計算Entry在HashMap中存儲的位置的，若是hash值相同，而key不相等，那麼就用鏈表來解決這種hash衝突。
構造函數
HashMap() //無參構造方法 HashMap(int initialCapacity) //指定初始容量的構造方法 HashMap(int initialCapacity, float loadFactor) //指定初始容量和負載因子 HashMap(Map<? extends K,? extends V> m) //指定集合，轉化爲HashMap
HashMap的KPI
void clear() Object clone() boolean containsKey(Object key) boolean containsValue(Object value) Set<Entry<K, V>> entrySet() V get(Object key) boolean isEmpty() Set<K> keySet() V put(K key, V value) void putAll(Map<? extends K, ? extends V> map) V remove(Object key) int size() Collection<V> values()
HashMap的簽名
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
從簽名能夠看出：
（1）HashMap繼承於AbstractMap類，實現了Map接口。Map是「key-value鍵值對」接口，AbstractMap實現了「鍵值對」的通用函數接口。
（2）HashMap是經過「拉鍊法」實現的哈希表，它裏面包含有幾個重要的成員變量：table、size、threshold、loadFactor、modCount。
table：是Entry[]類型的數組，Entry其實是一個單向鏈表。哈希表的「key-value鍵值對」都是存儲在Entry數組中的
size：HashMap的大小，也是HashMap保存的鍵值對的數量
threshold：HashMap的閥值，用於判斷是否須要調整HashMap的容量。threshold的值 = 容量 * 加載因子，當HashMap中存儲數據的數量達到threshold時，就須要將HashMap的容量加倍
loadFactor：加載因子
modCount：用來實現fail-fast機制的
添加方法（JDK1.7）
public V put(K key, V value) { if (table == EMPTY_TABLE) { //是否初始化 inflateTable(threshold); } if (key == null) //放置在0號位置 return putForNullKey(value); int hash = hash(key); //計算hash值 int i = indexFor(hash, table.length); //計算在Entry[]中的存儲位置 for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(hash, key, value, i); //添加到Map中 return null; }
在該方法中，添加鍵值對時，首先進行的是table是否初始化的判斷，若是沒有進行初始化（分配空間也就是Entry[]數組的長度爲0）。而後進行key是否爲null的判斷，若是key == null，放置在Entry[]的0號位置。而後計算Entry[]數組的存儲位置，判斷該位置上是否已經有元素，若是已經有元素存在，則遍歷該Entry[]數組上的單鏈表，判斷key是否存在，若是key已經存在，則用新的value值，替換舊的value值，並將舊的value值返回；若是key不存在於HashMap中，程序將對應的key-value值，生成Entry[]實體，添加到HashMap中的Entry[]數組中。
注意：JDK1.6和之前的版本，初始化時的容量是16，在JDK1.7之後，採用懶加載的方式，到真正放入元素的時候再初始化長度，長度也是16（使用無參構造器時）。
addEntry()
/* * hash hash值 * key 鍵值 * value value值 * bucketIndex Entry[]數組中的存儲索引 * / void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); //擴容操做，將數據元素從新計算位置後放入newTable中，鏈表的順序與以前的順序相反 hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex); } void createEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<>(hash, key, value, e); size++; }
添加Entry[]的操做，在添加以前先進行容量的判斷，若是當前容量達到了閥值，而且須要存儲到Entry[]數組中，先進行擴容操做，擴充的容量爲table長度的兩倍，從新計算hash值和數組存儲的位置，擴容後的鏈表順序與擴容前的鏈表順序相反，而後將新添加的Entry實體存放到當前Entry[]位置鏈表的頭部。
注意：在JDK1.8以前，新插入的元素都是放在了鏈表的頭部位置，可是這種操做在高併發的環境下容易致使死鎖，因此在JDK1.8及之後，新插入的元素都放在了鏈表的尾部。
獲取方法
public V get(Object key) { if (key == null) //返回table[0] 的value值 return getForNullKey(); Entry<K,V> entry = getEntry(key); return null == entry ? null : entry.getValue(); } final Entry<K,V> getEntry(Object key) { if (size == 0) { return null; } int hash = (key == null) ? 0 : hash(key); for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } return null; }
在get方法中，首先計算hash值，而後調用indexFor方法獲得該key在table中的存儲位置，獲得該位置的單鏈表，遍歷列表找到key和指定key內容相等的Entry，返回Entry.value值。
刪除方法
public V remove(Object key) { Entry<K,V> e = removeEntryForKey(key); return (e == null ? null : e.value); } final Entry<K,V> removeEntryForKey(Object key) { if (size == 0) { return null; } int hash = (key == null) ? 0 : hash(key); int i = indexFor(hash, table.length); Entry<K,V> prev = table[i]; Entry<K,V> e = prev; while (e != null) { Entry<K,V> next = e.next; Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { modCount++; size--; if (prev == e) table[i] = next; else prev.next = next; e.recordRemoval(this); return e; } prev = e; e = next; } return e; }
刪除操做，先計算指定key的hash值，而後計算出table中的存儲位置，判斷當前位置是否存在Entry實體，若是沒有，直接返回，若當前位置有Entry實體存在，則開始遍歷列表。定義了三個Entry引用，分別爲pre、e、next。在循環遍歷的過程當中，首先判斷pre和e是否相等，若相等則代表table當前位置只有一個元素，直接將table[i] = next = null。若造成了 pre -> e ->next 的鏈接關係，判斷e的key是否和指定的key相等，若相等則讓pre -> next，e 失去引用。
上述源碼皆是JDK1.7的源碼。
JDK1.8的改變
在Jdk1.8中HashMap的實現方式作了一些改變，可是基本思想仍是沒有變得，只是在一些地方作了優化，下面來看一下這些改變的地方,數據結構的存儲由數組+鏈表的方式，變化爲數組+鏈表+紅黑樹的存儲方式，在性能上進一步獲得提高。
數據存儲方式
當鏈表長度大於8的時候，鏈表將會轉化爲紅黑樹存儲，對極端狀況下的HashMap性能大大提高。
put方法簡單解析
public V put(K key, V value) { //調用putVal()方法完成 return putVal(hash(key), key, value, false, true); } 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是否初始化，不然初始化操做 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //計算存儲的索引位置，若是沒有元素，直接賦值 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)))) 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); //鏈表長度8，將鏈表轉化爲紅黑樹存儲 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; } } if (e != null) { // existing mapping for 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; }
HashMap的table爲何是 transient的
一個很小的細節：
transient Node<K,V>[] 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); }
HashMap的長度爲何要求是2的冪次方？
HashMap爲了存取高效，要儘可能較少碰撞，就是要儘可能把數據分配均勻，每一個鏈表長度大體相同，這個實現就在把數據存到哪一個鏈表中的算法，這個算法實際就是取模，hash%length，計算機中直接求餘效率不如位移運算，源碼中作了優化hash&(length-1)，hash%length==hash&(length-1)的前提是length是2的n次方；爲何這樣能均勻分佈減小碰撞呢？2的n次方實際就是1後面n個0，2的n次方-1 實際就是n個1：
例如長度爲9時候，3&(9-1)=0 2&(9-1)=0 ，都在0上，碰撞了；
例如長度爲8時候，3&(8-1)=3 2&(8-1)=2 ，不一樣位置上，不碰撞；
其實就是按位「與」的時候，每一位都能 &1 ，也就是和1111……1111111進行與運算
0000 0011 3
& 0000 1000 8
= 0000 0000 0
0000 0010 2
& 0000 1000 8
= 0000 0000 0
----------------------------------------------------------------------------
0000 0011 3
& 0000 0111 7
= 0000 0011 3
0000 0010 2
& 0000 0111 7
= 0000 0010 2
固然若是不考慮效率直接求餘便可（就不須要要求長度必須是2的n次方了）；
總結：
（1）爲了更高的效率（位移運算比取餘速度快，效率高）
（2）爲了更好的利用空間，減小重複率，好比說：當數組長度爲15的時候，hashcode的值會與14（1110）進行「與」，那麼最後一位永遠是0，而0001，0011，0101，1001，1011，0111，1101這幾個位置永遠都不能存放元素了，空間浪費至關大，更糟的是這種狀況中，數組可使用的位置比數組長度小了不少，這意味着進一步增長了碰撞的概率，減慢了查詢的效率！
capacity 永遠都是 2 次冪，那麼若是咱們指定 initialCapacity 不爲 2次冪時呢，是否是就破壞了這個規則？
答案是不會的，HashMap的tableSizeFor方法作了處理，能保證n永遠都是2次冪。
/** * Returns a power of two size for the given target capacity. */ static final int tableSizeFor(int cap) { //cap-1後，n的二進制最右一位確定和cap的最右一位不一樣，即一個爲0，一個爲1，例如cap=17（00010001），n=cap-1=16（00010000） int n = cap - 1; //n = (00010000 | 00001000) = 00011000 n |= n >>> 1; //n = (00011000 | 00000110) = 00011110 n |= n >>> 2; //n = (00011110 | 00000001) = 00011111 n |= n >>> 4; //n = (00011111 | 00000000) = 00011111 n |= n >>> 8; //n = (00011111 | 00000000) = 00011111 n |= n >>> 16; //n = 00011111 = 31 //n = 31 + 1 = 32, 即最終的cap = 32 = 2 的 (n=5)次方 return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
總結：能夠確保capacity爲大於或等於cap的最接近cap的二次冪，好比cap=13,則capacity=16;cap=16,capacity=16;cap=17,capacity=32。
參考：https://www.cnblogs.com/xrq730/p/5030920.html
-
每一个你不满意的现在，都有一个你没有努力的曾经。