溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
HashMap對于使用Java的小伙伴們來說最熟悉不過，每天都在使用它。這次主要是分析下HashMap的工作原理，為什么我會拿這個東西出來分析，主要是最近面試的小伙伴們，中被人問起HashMap，HashMap涉及的知識遠遠不止put和get那么簡單。
為什么叫做HashMap？內部是怎樣實現的呢？使用的時候大多數都是用String作為它的key呢？下面就讓我們來了解HashMap，并給你詳細解釋這些問題。
其實HashMap的由來是基于Hasing技術(Hasing),Hasing就是將很大的字符串或者任何對象轉換成一個用來代表它們的很小的值，這些更短的值就可以很方便的用來方便索引、加快搜索。
HashMap是一個用于存儲Key-Value鍵值對的集合，你可以用一個”key”去存儲數據。當你想獲得數據的時候，你可以通過”key”去得到數據，每一個鍵值對也叫做Entry。這些個鍵值對（Entry）分散存儲在一個數組當中，這個數組就是HashMap的主干。
HashMap作為一種數據結構，像數組和鏈表一樣用于常規的增刪改查，在存數據的時候(put)并不是隨便亂放，而是會先進行一次分配索引（可以理解為“分類”）的操作再存儲，一旦分配索引存儲之后，下次取(get)的時候就可以大大縮短查找的時間。我們知道數組在執行查、改的效率很高，而增、刪(不是尾部)的效率低，鏈表相反，HashMap則是把這兩者結合起來，看下HashMap的數據結構
先介紹一下HashMap的變量
size,就是HashMap的存儲大小。threshold是HashMap臨界值，也叫閥值，如果HashMap到達了臨界值，需要重新分配大小。loadFactor是負載因子， 默認為75%。閥值 = 當前數組長度?負載因子。modCount指的是HashMap被修改或者刪除的次數總數。
Entry分散存儲在一個Entry類型的數組table， table里的每一個數據都是一個Entry對象。Y軸方向代表的就是數組，X軸方向就是鏈表的存儲方式。
table里面存儲的Entry類型，Entry類里包含了hashcode變量，key,value 和另外一個Entry對象。因為這是一個鏈表結構。通過我找到你，你再找到他。不過這里的Entry并不是LinkedList，它是單獨為HashMap服務的一個內部單鏈表結構的類。
1、首先判斷Key是否為Null，如果為null，直接查找Enrty[0]，如果不是Null，先計算Key的HashCode，然后經過二次Hash，得到Hash值。
2、根據Hash值，對Entry[]的長度length求余，得到的就是Entry數組的index。
3、根據對應的索引找到對應的數組，就是找到了其所在的鏈表，然后按照鏈表的操作對Value進行插入、刪除和查詢操作。
hash 方法
我們都知道在Java中每個對象都有一個hashcode()方法用來返回該對象的 hash值。HashMap先對hashCode進行hash操作，然后再通過hash值進一步計算下標。
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash42((String) k);
}
h ^= k.hashCode();
// 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);
}
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}HashMap是怎么通過Hash查找數組的索引的呢，調用indexFor，其中h是hash值，length是數組的長度，這個按位與的算法其實就是h%length求余。
/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
其中h是hash值，length是數組的長度，這個按位與的算法其實就是h%length求余。
一般什么情況下利用該算法，典型的分組。例如怎么將100個數分組16組中，就是這個意思。應用非常廣泛。
static int indexFor(int h, int length) {
return h & (length-1);
}舉個例子
int h=15,length=16;
System.out.println(h & (length-1));
System.out.println(Integer.parseInt("0001111", 2) & Integer.parseInt("0001111", 2));
h=15+16;
System.out.println(h & (length-1));
System.out.println(Integer.parseInt("0011111", 2) & Integer.parseInt("0001111", 2));
h=15+16+16;
System.out.println(h & (length-1));
System.out.println(Integer.parseInt("0111111", 2) & Integer.parseInt("0001111", 2));
h=15+16+16+16;
System.out.println(h & (length-1));
System.out.println(Integer.parseInt("1111111", 2) & Integer.parseInt("0001111", 2));在做按位與的時候，始終是低位在做計算，高位不參與計算，因為高位都是0。這樣導致的結果就是只要是低位是一樣的，高位無論是什么，最后結果是一樣的，如果這樣依賴，hash碰撞始終在一個數組上，導致這個數組開始的鏈表無限長，那么在查詢的時候就速度很慢，又怎么算得上高性能的啊。所以hashmap必須解決這樣的問題，盡量讓key盡可能均勻的分配到數組上去。避免造成Hash堆積。
調用put方法時，盡管我們設法避免碰撞以提高HashMap的性能，還是可能發生碰撞。據說碰撞率還挺高，平均加載率到10%時就會開始碰撞。
HashMap初始化
默認情況下，大多數人都調用 HashMap hashMap = new HashMap();來初始化的，我們在這分析newHashMap（int initialCapacity, float loadFactor）的構造函數。
我們都知道在Java中每個對象都有一個hashcode()方法用來返回該對象的 hash值。HashMap先對hashCode進行hash操作，然后再通過hash值進一步計算下標。
代碼如下：
public HashMap(int initialCapacity, float loadFactor) {
// initialCapacity代表初始化HashMap的容量，它的最大容量是MAXIMUM_CAPACITY = 1 << 30。
// loadFactor代表它的負載因子，默認是是DEFAULT_LOAD_FACTOR=0.75，用來計算threshold臨界值的。 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;
this.threshold = tableSizeFor(initialCapacity);
}
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}由上面的代碼可以看出，初始化的時候需要知道初始化的容量大小，因為在后面要通過按位與的Hash算法計算Entry數組的索引，那么要求Entry的數組長度是2的N次方。
put操作
HashMap怎么存儲一個對象呢，代碼如下：
public V put(K key, V value) {
//數組為空時創建數組
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//①key為空單獨對待
if (key == null)
return putForNullKey(value);
//②根據key計算hash值
int hash = hash(key);
//②根據hash值和當前數組的長度計算在數組中的索引
int i = indexFor(hash, table.length);
//遍歷整條鏈表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//③hash值和key值都相同的情況，替換之前的值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
//返回被替換的值
return oldValue;
}
}
modCount++;
//③如果沒有找到key的hash相同的節點,直接存值或發生hash碰撞都走這
addEntry(hash, key, value, i);
return null;
}從代碼中可以看出，步驟如下：
1.首先會判斷可以是否為null，如果是null，就調用pullForNullKey（value）處理。代碼如下：
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;
}如果key為null的值，默認就存儲到table[0]開頭的鏈表了。然后遍歷table[0]的鏈表的每個節點Entry，如果發現其中存在節點Entry的key為null，就替換新的value，然后返回舊的value，如果沒發現key等于null的節點Entry，就增加新的節點。
(3) 然后遍歷以table[i]為頭節點的鏈表，如果發現有節點的hash，key都相同的節點時，就替換為新的value，然后返回舊的value。
如果沒有找到key的hash相同的節點，就增加新的節點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);
}（4）如果HashMap大小超過臨界值，就要重新設置大小，擴容，稍后講解。
附上一張流程圖，這個圖是從別的博主哪里copy的，感覺畫的不錯。
我們通過hashMap.get(K key) 來獲取存入的值，key的取值很簡單了。我們通過數組的index直接找到Entry，然后再遍歷Entry，當hashcode和key都一樣就是我們當初存入的值啦。
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}調用getEntry(key)拿到entry ,然后返回entry的value,來看getEntry(key)方法
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;
}相比put，get操作就沒這么多套路，只需要根據key值計算hash值，和數組長度取模，然后就可以找到在數組中的位置(key為空同樣單獨操作)，接著就是Entry遍歷，hash相等的情況下，如果key相等就知道了我們想要的值。
再get方法中有null的判斷，null取hash值總是0,再getNullKey(K key)方法中，也是按照遍歷方法來查找的。
眾所周知，HashMap不是線程安全的，但在某些容錯能力較好的應用中，如果你不想僅僅因為1%的可能性而去承受hashTable的同步開銷，HashMap使用了Fail-Fast機制來處理這個問題，你會發現modCount在源碼中是這樣聲明的。
調用put方法時，當HashMap的大小超過臨界值的時候，就需要擴充HashMap的容量了。代碼如下：
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
table = newTable;
//步驟④修改閥值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}如果大小超過最大容量就返回。否則就new 一個新的Entry數組，長度為舊的Entry數組長度的兩倍。然后將舊的Entry[]復制到新的Entry[].代碼如下：
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;
}
}
}到這里相信你對HashMap內部已經非常清楚了，如果本篇文章對你有幫助記得關注我，我會繼續更新文章，感謝支持！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
