無論是在平時的練習還是項目當中，HashMap用的是非常的廣，真可謂無處不在。平時用的時候只知道HashMap是用來存儲鍵值對的，卻不知道它的底層是如何實現的。
一、HashMap概述
HashMap基於哈希表的 Map 接口的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。（除了不同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）此類不保證映射的順序，特別是它不保證該順序恆久不變。
值得注意的是HashMap不是線程安全的，如果想要線程安全的HashMap，可以通過Collections類的靜態方法synchronizedMap獲得線程安全的HashMap。
1 Map map = Collections.synchronizedMap(new HashMap());
二、HashMap的數據結構
HashMap的底層主要是基於數組和鏈表來實現的，它之所以有相當快的查詢速度主要是因為它是通過計算散列碼來決定存儲的位置，能夠很快的計算出對象所存儲的位置。HashMap中主要是通過key的hashCode來計算hash值的，只要hashCode相同，計算出來的hash值就一樣。如果存儲的對象對多了，就有可能不同的對象所算出來的hash值是相同的，這就出現了所謂的hash沖突。學過數據結構的同學都知道，解決hash沖突的方法有很多，HashMap底層是通過鏈表來解決hash沖突的。
從上圖中可以看出，HashMap底層就是一個數組結構，數組中存放的是一個Entry對象，如果產生的hash沖突，也就是說要存儲的那個位置上面已經存儲了對象了，這時候該位置存儲的就是一個鏈表了。我們看看HashMap中Entry類的代碼：
1 static class Entry<K,V> implements Map.Entry<K,V> { 2 final K key; 3 V value; 4 Entry<K,V> next; 5 final int hash; 6 7 /** 8 * Creates new entry. 9 */ 10 Entry(int h, K k, V v, Entry<K,V> n) { 11 value = v; 12 next = n; //hash值沖突后存放在鏈表的下一個 13 key = k; 14 hash = h; 15 } 16 17 ......... 18 }
HashMap其實就是一個Entry數組，Entry對象中包含了鍵和值，其中next也是一個Entry對象，它就是用來處理hash沖突的，形成一個鏈表。
三、HashMap源碼分析
先看看HashMap類中的一些關鍵屬性：
1 transient Entry[] table;//存儲元素的實體數組 2 3 transient int size;//存放元素的個數 4 5 int threshold; //臨界值 當實際大小超過臨界值時，會進行擴容threshold = 加載因子*容量 6 7 final float loadFactor; //加載因子 8 9 transient int modCount;//被修改的次數
其中加載因子是表示Hsah表中元素的填滿的程度.若:加載因子越大,填滿的元素越多,好處是,空間利用率高了,但:沖突的機會加大了.反之,加載因子越小,填滿的元素越少,
好處是:沖突的機會減小了,但:空間浪費多了.沖突的機會越大,則查找的成本越高.反之,查找的成本越小.因而,查找時間就越小.因此,必須在 "沖突的機會"與"空間利用率"之間尋找一種平衡與折衷. 這種平衡與折衷本質上是數據結構中有名的"時-空"矛盾的平衡與折衷.
如果機器內存足夠，並且想要提高查詢速度的話可以將加載因子設置小一點；相反如果機器內存緊張，並且對查詢速度沒有什么要求的話可以將加載因子設置大一點。不過一般我們都不用去設置它，讓它取默認值0.75就好了。
下面看看HashMap的幾個構造方法：
1 public HashMap(int initialCapacity, float loadFactor) { 2 //確保數字合法 3 if (initialCapacity < 0) 4 throw new IllegalArgumentException("Illegal initial capacity: " + 5 initialCapacity); 6 if (initialCapacity > MAXIMUM_CAPACITY) 7 initialCapacity = MAXIMUM_CAPACITY; 8 if (loadFactor <= 0 || Float.isNaN(loadFactor)) 9 throw new IllegalArgumentException("Illegal load factor: " + 10 loadFactor); 11 12 // Find a power of 2 >= initialCapacity 13 int capacity = 1; //初始容量 14 while (capacity < initialCapacity) //確保容量為2的n次冪，使capacity為大於initialCapacity的最小的2的n次冪 15 capacity <<= 1; 16 17 this.loadFactor = loadFactor; 18 threshold = (int)(capacity * loadFactor); 19 table = new Entry[capacity]; 20 init(); 21 } 22 23 public HashMap(int initialCapacity) { 24 this(initialCapacity, DEFAULT_LOAD_FACTOR); 25 } 26 27 public HashMap() { 28 this.loadFactor = DEFAULT_LOAD_FACTOR; 29 threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR); 30 table = new Entry[DEFAULT_INITIAL_CAPACITY]; 31 init(); 32 }
我們可以看到在構造HashMap的時候如果我們指定了加載因子和初始容量的話就調用第一個構造方法，否則的話就是用默認的。默認初始容量為16，默認加載因子為0.75。我們可以看到上面代碼中13-15行，這段代碼的作用是確保容量為2的n次冪，使capacity為大於initialCapacity的最小的2的n次冪，至於為什么要把容量設置為2的n次冪，我們等下再看。
下面看看HashMap存儲數據的過程是怎樣的，首先看看HashMap的put方法：
1 public V put(K key, V value) { 2 if (key == null) //如果鍵為null的話，調用putForNullKey(value) 3 return putForNullKey(value); 4 int hash = hash(key.hashCode());//根據鍵的hashCode計算hash碼 5 int i = indexFor(hash, table.length); 6 for (Entry<K,V> e = table[i]; e != null; e = e.next) { //處理沖突的，如果hash值相同，則在該位置用鏈表存儲 7 Object k; 8 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同則覆蓋並返回舊值 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 }
我們慢慢的來分析這個函數，第2和3行的作用就是處理key值為null的情況，我們看看putForNullKey(value)方法：
1 private V putForNullKey(V value) { 2 for (Entry<K,V> e = table[0]; e != null; e = e.next) { 3 if (e.key == null) { //如果有key為null的對象存在，則覆蓋掉 4 V oldValue = e.value; 5 e.value = value; 6 e.recordAccess(this); 7 return oldValue; 8 } 9 } 10 modCount++; 11 addEntry(0, null, value, 0); //如果鍵為null的話，則hash值為0 12 return null; 13 }
注意：如果key為null的話，hash值為0，對象存儲在數組中索引為0的位置。
我們再回去看看put方法中第4行，它是通過key的hashCode值計算hash碼，下面是計算hash碼的函數：
1 //計算hash值的方法 通過鍵的hashCode來計算 2 static int hash(int h) { 3 // This function ensures that hashCodes that differ only by 4 // constant multiples at each bit position have a bounded 5 // number of collisions (approximately 8 at default load factor). 6 h ^= (h >>> 20) ^ (h >>> 12); 7 return h ^ (h >>> 7) ^ (h >>> 4); 8 }
得到hash碼之后就會通過hash碼去計算出應該存儲在數組中的索引，計算索引的函數如下：
1 static int indexFor(int h, int length) { //根據hash值和數組長度算出索引值 2 return h & (length-1); //這里不能隨便算取，用hash&(length-1)是有原因的，這樣可以確保算出來的索引是在數組大小范圍內，不會超出 3 }
這個方法非常巧妙，它通過 h & (table.length -1) 來得到該對象的保存位，而HashMap底層數組的長度總是 2 的n 次方，這是HashMap在速度上的優化。
當length總是 2 的n次方時，h& (length-1)運算等價於對length取模，也就是h%length，但是&比%具有更高的效率。
這看上去很簡單，其實比較有玄機的，我們舉個例子來說明：
假設數組長度分別為15和16，優化后的hash碼分別為8和9，那么&運算后的結果如下：
h & (table.length-1) hash table.length-1
8 & (15-1)： 0100 & 1110 = 0100
9 & (15-1)： 0101 & 1110 = 0100
-----------------------------------------------------------------------------------------------------------------------
8 & (16-1)： 0100 & 1111 = 0100
9 & (16-1)： 0101 & 1111 = 0101
從上面的例子中可以看出：當它們和15-1（1110）“與”的時候，產生了相同的結果，也就是說它們會定位到數組中的同一個位置上去，這就產生了碰撞，8和9會被放到數組中的同一個位置上形成鏈表，那么查詢的時候就需要遍歷這個鏈 表，得到8或者9，這樣就降低了查詢的效率。同時，我們也可以發現，當數組長度為15的時候，hash值會與15-1（1110）進行“與”，那么 最后一位永遠是0，而0001，0011，0101，1001，1011，0111，1101這幾個位置永遠都不能存放元素了，空間浪費相當大，更糟的是這種情況中，數組可以使用的位置比數組長度小了很多，這意味着進一步增加了碰撞的幾率，減慢了查詢的效率！而當數組長度為16時，即為2的n次方時，2n-1得到的二進制數的每個位上的值都為1，這使得在低位上&時，得到的和原hash的低位相同，加之hash(int h)方法對key的hashCode的進一步優化，加入了高位計算，就使得只有相同的hash值的兩個值才會被放到數組中的同一個位置上形成鏈表。
所以說，當數組長度為2的n次冪的時候，不同的key算得得index相同的幾率較小，那么數據在數組上分布就比較均勻，也就是說碰撞的幾率小，相對的，查詢的時候就不用遍歷某個位置上的鏈表，這樣查詢效率也就較高了。
上面說明了前面所說的HashMap容量總是取2的指數次冪的原因。下面我們繼續回到put方法里面，前面已經計算出索引的值了，看到第6到14行，如果數組中該索引的位置的鏈表已經存在key相同的對象，則將其覆蓋掉並返回原先的值。如果沒有與key相同的鍵，則調用addEntry方法創建一個Entry對象，addEntry方法如下：
1 void addEntry(int hash, K key, V value, int bucketIndex) { 2 Entry<K,V> e = table[bucketIndex]; //如果要加入的位置有值，將該位置原先的值設置為新entry的next,也就是新entry鏈表的下一個節點 3 table[bucketIndex] = new Entry<>(hash, key, value, e); 4 if (size++ >= threshold) //如果大於臨界值就擴容 5 resize(2 * table.length); //以2的倍數擴容 6 }
參數bucketIndex就是indexFor函數計算出來的索引值，第2行代碼是取得數組中索引為bucketIndex的Entry對象，第3行就是用hash、key、value構建一個新的Entry對象放到索引為bucketIndex的位置，並且將該位置原先的對象設置為新對象的next構成鏈表。
第4行和第5行就是判斷put后size是否達到了臨界值threshold，如果達到了臨界值就要進行擴容，HashMap擴容是擴為原來的兩倍。resize()方法如下：
1 void resize(int newCapacity) { 2 Entry[] oldTable = table; 3 int oldCapacity = oldTable.length; 4 if (oldCapacity == MAXIMUM_CAPACITY) { 5 threshold = Integer.MAX_VALUE; 6 return; 7 } 8 9 Entry[] newTable = new Entry[newCapacity]; 10 transfer(newTable);//用來將原先table的元素全部移到newTable里面 11 table = newTable; //再將newTable賦值給table 12 threshold = (int)(newCapacity * loadFactor);//重新計算臨界值 13 }
擴容是需要進行數組復制的，上面代碼中第10行為復制數組，復制數組是非常消耗性能的操作，所以如果我們已經預知HashMap中元素的個數，那么預設元素的個數能夠有效的提高HashMap的性能。
總結：以前對HashMap和HashTable的區別總是要死記，而且容易忘記。分析完源碼之后他們之前的區別都知道了，連細微的區別都能夠清楚，而且是記憶深刻。所以研究一下源碼，學習一下別人的設計思路可以學到很多東西的。