摘要
Java中Map是開發中經常使用的一個類，它主要用於存放鍵值對映射；在查詢時，根據對應的key獲取value；使用非常簡單，但是其中的知識點一點不少，並且是面試中必問的！博主希望通過這篇博客能幫助讀者深入瞭解HashMap的底層原理；
介紹
基於哈希表實現Map接口。 該實現提供了所有可選的映射操作，並允許null值和null鍵。 (HashMap類大致相當於Hashtable，只是它是不同步的，並且允許爲空。) 這個類不保證map的順序; 特別是，它不能保證順序會隨着時間的推移保持不變。
這個實現爲基本操作(get和put)提供了恆定時間的性能表現，前提是散列函數將元素適當地分散到存儲桶中。遍歷集合視圖所需的時間與HashMap實例的“容量”(桶的數量)加上它的大小(鍵值映射的數量)成正比。 因此，如果迭代性能很重要，那麼初始容量不要設置得太高(或者負載因子太低)是非常重要的。
HashMap實例有兩個參數影響其性能: 初始容量和負載因子。 capacity爲哈希表中桶的數量，初始容量爲哈希表創建時的容量。 負載因子是在哈希表容量自動增加之前允許達到的滿度的度量。 當哈希表中的條目數超過負載因子和當前容量的乘積時，哈希表爲rehash(即重新構建內部數據結構)，因此哈希表的桶數大約是原來的兩倍。
一般來說，默認的負載因子(0.75)在時間和空間成本之間提供了一個很好的權衡。 較高的值會減少空間開銷，但會增加查找成本(反映在HashMap類的大多數操作中，包括get和put)。 在設置map的初始容量時，應該考慮map中預期的條目數量及其負載因子，以儘量減少rehash操作的數量。 如果初始容量大於最大條目數除以負載因子，則不會發生重hash操作。
如果要在HashMap實例中存儲許多映射，那麼使用足夠大的容量創建它將使映射能夠更有效地存儲，而不是讓它根據需要執行自動重散列以增長表。 注意，這個實現不是同步的。 如果多個線程併發訪問一個哈希映射，並且至少有一個線程在結構上修改了這個映射，那麼它必須在外部進行同步。 (結構修改是添加或刪除一個或多個映射的任何操作; 僅僅改變與實例已經包含的鍵相關聯的值並不是結構上的修改。) 這通常通過對自然封裝映射的某些對象進行同步來完成。 如果不存在這樣的對象，則應該使用 Collections.synchronizedMap方法 “包裝”映射。 這最好在創建時完成，以防止意外的對map的不同步訪問: Map m = Collections.synchronizedMap(new HashMap(...));
這個類的所有“集合視圖方法”返回的迭代器都是快速失敗的:如果在迭代器創建後的任何時間映射在結構上被修改，除了通過迭代器自己的remove方法之外的任何方式，迭代器都會拋出ConcurrentModificationException。 因此，在面對併發修改時，迭代器會快速而乾淨地失敗，而不是冒着在未來某個不確定的時間發生任意的、不確定的行爲的風險。
請注意，迭代器的快速失敗行爲不能得到保證，因爲一般來說，在存在非同步的併發修改時，不可能做出任何硬保證。 快速失敗迭代器儘可能拋出ConcurrentModificationException。 因此，編寫依賴此異常來保證其正確性的程序是錯誤的:迭代器的快速失敗行爲應該只用於檢測錯誤。
這個類是Java集合框架的成員。
源碼分析
(1)、類定義
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable{
...
}
可以看出，HashMap繼承了AbstractMap，實現Map、Cloneable、Serializable接口。
(2)、Cloneable實現
我們從類定義上面瞭解到HashMap實現Cloneable克隆，源碼如下：
/**
* 返回這個HashMap實例的淺副本:鍵和值本身沒有被克隆。
*/
public Object clone() {
HashMap<K,V> result = null;
try {
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {
// assert false;
}
if (result.table != EMPTY_TABLE) {
result.inflateTable(Math.min(
(int) Math.min(
size * Math.min(1 / loadFactor, 4.0f),
// we have limits...
HashMap.MAXIMUM_CAPACITY),
table.length));
}
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
result.putAllForCreate(this);
return result;
}
(3)、HashMap變量
/**
* 默認初始容量—必須是2的冪。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
*最大容量，如果一個較大的值由帶參數的構造函數中的任何一個隱式指定，則使用該值。 必須是2的冪，<= 1<<30。
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默認的負載因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 當表沒有膨脹時共享的空表實例。
*/
static final Entry<?,?>[] EMPTY_TABLE = {};
/**
* 根據需要調整表的大小。 長度必須永遠是2的冪。
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
/**
* 此映射中包含的鍵值映射的數量。
*/
transient int size;
/**
* size擴容的閾值，要調整表容量大小的下一個size值(容量*負載因子)。
* @serial
*/
// If table == EMPTY_TABLE then this is the initial capacity at which the
// table will be created when inflated.
int threshold;
/**
* 哈希表的負載因子
* @serial
*/
final float loadFactor;
/**
* 結構化修改指的是改變HashMap中映射的數量或修改其內部結構(如rehash)。 該字段用於使HashMap的集合視圖上的迭代器快速失敗。
* (見 ConcurrentModificationException)。
*/
transient int modCount;
/**
* map容量的默認閾值，超過這個閾值將對String鍵使用替代散列。 由於字符串鍵的弱哈希碼計算，可選哈希減少了碰撞的發生率。
*
* 這個值可以通過定義系統屬性來重寫
* {@code jdk.map.althashing.threshold}。 屬性值{@code 1}強制使用備選哈希，而{@code -1}值確保備選哈希從未使用。
*/
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
(4)、靜態內部類Holder
/**
* holds values which can't be initialized until after VM is booted.
*/
private static class Holder {
/**
* 要切換到使用可選散列的表容量。
*/
static final int ALTERNATIVE_HASHING_THRESHOLD;
static {
String altThreshold = java.security.AccessController.doPrivileged(
new sun.security.action.GetPropertyAction(
"jdk.map.althashing.threshold"));
int threshold;
try {
threshold = (null != altThreshold)
? Integer.parseInt(altThreshold)
: ALTERNATIVE_HASHING_THRESHOLD_DEFAULT;
// 如果-1禁用替代哈希
if (threshold == -1) {
threshold = Integer.MAX_VALUE;
}
if (threshold < 0) {
throw new IllegalArgumentException("value must be positive integer.");
}
} catch(IllegalArgumentException failed) {
throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
}
ALTERNATIVE_HASHING_THRESHOLD = threshold;
}
}
(5)、HashMap構造
/**
* 使用指定的初始容量和加載因子構造一個空的HashMap。
*
* @param initialCapacity the initial capacity 初始容量
* @param loadFactor the load factor 負載因子
* @throws IllegalArgumentException 初始容量爲負值或負載因子爲非正值
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();
}
/**
* 構造一個空的HashMap，使用指定的初始容量和默認的負載因子(0.75)。
*
* @param initialCapacity 初始容量。
* @throws IllegalArgumentException 如果初始容量爲負。
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 構造一個空的HashMap，使用默認的初始容量(16)和默認的負載因子(0.75)。
*/
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
/**
* 構造一個新的HashMap，具有與指定的Map相同的映射。 HashMap是用默認負載因子(0.75)創建的，
* 並且初始容量足夠容納指定的<tt>Map</tt>中的映射。
*/
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
inflateTable(threshold);
putAllForCreate(m);
}
//子類的初始化鉤子。 在HashMap初始化之後，插入任何條目之前，在所有構造函數和僞構造函數(clone, readObject)中調用此方法。
//(在沒有這個方法的情況下，readObject將需要子類的顯式知識。)
void init() {
}
/**
* 膨脹 the table.
*/
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
int capacity = roundUpToPowerOf2(toSize);
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
/**
* Initialize the hashing mask value. We defer initialization until we
* really need it.
*/
final boolean initHashSeedAsNeeded(int capacity) {
boolean currentAltHashing = hashSeed != 0;
boolean useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean switching = currentAltHashing ^ useAltHashing;
if (switching) {
hashSeed = useAltHashing
? sun.misc.Hashing.randomHashSeed(this)
: 0;
}
return switching;
}
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
(6)、內部類Entry
該類是用來代表HashMap中的一個鍵值對類型.
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;//鍵
V value;//值
Entry<K,V> next;//相同hash槽位上的鏈表的下一個Entry
int hash;//鍵的hash值
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
/**
* This method is invoked whenever the value in an entry is
* overwritten by an invocation of put(k,v) for a key k that's already
* in the HashMap.
*/
void recordAccess(HashMap<K,V> m) {
}
/**
* This method is invoked whenever the entry is
* removed from the table.
*/
void recordRemoval(HashMap<K,V> m) {
}
}
(7)、put(K key, V value) 方法
該方法是HashMap的核心方法之一，用來向HashMap中存入一個鍵值對；
public V put(K key, V value) {
//空表膨脹
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//key爲null的鍵值對存入
if (key == null)
return putForNullKey(value);
//key不爲null,對key進行hash
int hash = hash(key);
//通過Key的hash和hash表的長度定位key的槽位
int i = indexFor(hash, table.length);
//用hash表上該槽位的鏈表遍歷，如果存在key相同,則替換value
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++;
//新增entry
addEntry(hash, key, value, i);
return null;
}
看了上面的這段源碼，詳細大家已經比較清楚put方法的主流程：
- 首先判斷是否hash表是否爲空表（第一次膨脹）;如果是空表，則使用容量閾值進行膨脹。
- 判斷key是否爲空，如果爲空，則調用putForNullKey(value)方法進行保存，並返回舊的value值/null
- 對key進行hash，並通過key的hash值和hash表長度定位槽位
- 用hash表上該槽位的鏈表遍歷，如果存在key相同,則替換value並返回舊的值
- 否則，在該槽位上新增加一項，返回null
我們接着上面進行源碼分支分析：
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
通過上面這段源碼，可以瞭解到，當put傳入的key鍵爲空時，HashMap首先遍歷hash表中，槽位爲0的Entry鏈表，如果存在key爲null的entry，則替換值並返回舊值;如果不存在key爲null的值，則將key鍵爲null的新鍵值對添加到槽位爲0的hash槽鏈表上。
/**
* 將具有指定鍵、值和哈希碼的新條目添加到指定的桶中。 這個方法負責在適當的時候調整表的大小。
*
* 子類重寫它以改變put方法的行爲。
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
//當hash表中的鍵值對大於擴容的閾值、並且當前hash槽位非空，則進行擴容
if ((size >= threshold) && (null != table[bucketIndex])) {
//擴容爲原來hash表長度的2倍
resize(2 * table.length);
//hash重新定位槽位
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
//插入到指定槽位
createEntry(hash, key, value, bucketIndex);
}
/**
* 與addEntry類似，不同的是這個版本在創建條目作爲Map構造或“僞構造”(克隆、反序列化)的一部分時使用。 這個版本不需要擔心調整表的大小。
*
* 子類重寫它來改變HashMap(Map)、clone和readObject的行爲。
*/
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++;
}
通過以上這段插入鍵值對的邏輯，我們可以瞭解到比較重要的三點（當然此處是HashMap1.7版本的邏輯）：
- HashMap空鍵entry存放在hash表的下標爲0的槽位的鏈表裏
- HashMap以2倍的速度進行擴容
- HashMap插入新的entry時，使用的是鏈表頭部插入方法
擴容邏輯源碼：
/**
* 將此映射的內容重新散列到具有更大容量的新數組中。 當此映射中的鍵數達到其閾值時，將自動調用此方法。
*
* 如果當前容量爲MAXIMUM_CAPACITY，此方法不會調整映射的大小，而是將閾值設置爲Integer.MAX_VALUE。 這具有防止未來調用的效果。
*
* @param newCapacity 新容量，必須是2的冪; 必須大於當前容量，除非當前容量爲MAXIMUM_CAPACITY(此時值無關)。
*/
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
/**
* 將當前表中的所有項轉移到newTable。
*/
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
/**
* 返回哈希碼h的索引。相當於h%length
*/
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
}
從以上代碼我們可以看出HashMap在resize的時候，hash表槽位上鍊表會發生倒置；在多線程擴容時，就有可能某一瞬間會產生環狀，訪問進入死循環；
/**
* 檢索對象哈希代碼，並對結果哈希應用一個補充哈希函數，以防止低質量的哈希函數。 這是至關重要的，因爲HashMap使用兩次方長度的哈希表，否則會 *遇到hashcode在較低位沒有差異的衝突。 注意:空鍵總是映射到散列0，因此索引0。
*/
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// 這個函數確保hashcode在每個位位置上的差異僅爲常數倍，衝突的次數是有限制的(默認負載因子約爲8)。
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
從上面的源碼可以瞭解到，當key爲string的時候，系統會使用sun.misc.Hashing.stringHash32來進行hash； 特別注意的是，當k爲非String且不等0的時候，該方法會調用k對象的hashCode方法，然後進行後續優化計算；因此，如果使用hashMap存的鍵值對key自定義對象時候，我們一般需要重寫hashCode方法;
(8)、get(Object key) 方法
/**
* 返回指定鍵映射到的值，如果這個映射不包含該鍵的映射，則返回{@code null}。
*
* 更正式地說，如果這個map包含一個從鍵{@code k}到值{@code v}的映射，
* 這樣{@code (key==null ? K ==null: key.equals(K))}，然後這個方法返回{@code v}; 否則返回{@code null}。 (最多隻能有一個這樣的映射。)
*
* {@code null}的返回值不一定表示映射不包含該鍵的映射; 也有可能映射顯式地將鍵映射爲{@code null}。
* {@link #containsKey containsKey}操作可以用來區分這兩種情況。
*/
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
/**
* 查找空鍵的get()的卸載版本。 空鍵映射到索引0。 爲了在兩個最常用的操作(get和put)中提高性能，這個空的情況被拆分爲單獨的方法，
* 但在其他操作中與條件合併。
*/
private V getForNullKey() {
if (size == 0) {
return null;
}
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
//返回HashMap中與指定鍵關聯的條目。 如果HashMap不包含鍵的映射，則返回null。
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;
}
通過以上源碼，我們可以知道；HashMap的get邏輯：如果鍵爲null，則直接去下標爲0的槽位上的entry鏈表查找；否則，通過indexFor方法hash%table.length來定位槽位；然後在該槽位的鏈表上循環搜索key。
(9)、remove(Object key) 方法
/**
* 如果存在，則從該映射中移除指定鍵的映射。
*
*@param key key的映射將被從映射中移除
*@返回以前與鍵關聯的值，如果鍵沒有映射的話，返回null。
* (一個null返回也可以表明先前關聯null與鍵的映射。)
*/
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
/**
* 刪除並返回HashMap中與指定鍵關聯的條目。 如果HashMap不包含此鍵的映射，則返回null。
*/
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;
}
(10)、clear() 方法
/**
* 從該映射中刪除所有映射。 這個調用返回後，映射將爲空。
*/
public void clear() {
modCount++;
Arrays.fill(table, null);
size = 0;
}
該方法通過使用Arrays.fill對Hash表進行控制填充來達到清空HashMap的效果；
JDK1.7 HashMap底層數據結構
通過上面的源碼分析，相信大家已經對JDK1.7中HashMap的底層數據結構非常清晰； 