Java中HashMap的實現原理

一、Java中的hashCode和equals

1、關於hashCode

1. hashCode的存在主要是用於查詢的快捷性，如Hashtable，HashMap等，hashCode是用來在雜湊儲存結構中確定物件的儲存地址的
2. 如果兩個物件相同，就是適用於equals(java.lang.Object) 方法，那麼這兩個物件的hashCode一定要相同
3. 如果物件的equals方法被重寫，那麼物件的hashCode也儘量重寫，並且產生hashCode使用的物件，一定要和equals方法中使用的一致，否則就會違反上面提到的第2點
4. 兩個物件的hashCode相同，並不一定表示兩個物件就相同，也就是不一定適用於equals(java.lang.Object) 方法，只能夠說明這兩個物件在雜湊儲存結構中，如Hashtable，他們“存放在同一個籃子裡“

再歸納一下就是hashCode是用於查詢使用的，而equals是用於比較兩個物件的是否相等的。

以下對hashCode的解讀摘自其他部落格：

1.hashcode是用來查詢的，如果你學過資料結構就應該知道，在查詢和排序這一章有
例如記憶體中有這樣的位置
0  1  2  3  4  5  6  7 
而我有個類，這個類有個欄位叫ID,我要把這個類存放在以上8個位置之一，如果不用hashcode而任意存放，那麼當查詢時就需要到這八個位置裡挨個去找，或者用二分法一類的演算法。
但如果用hashcode那就會使效率提高很多。
我們這個類中有個欄位叫ID,那麼我們就定義我們的hashcode為ID％8，然後把我們的類存放在取得得餘數那個位置。比如我們的ID為9，9除8的餘數為1，那麼我們就把該類存在1這個位置，如果ID是13，求得的餘數是5，那麼我們就把該類放在5這個位置。這樣，以後在查詢該類時就可以通過ID除 8求餘數直接找到存放的位置了。
2.但是如果兩個類有相同的hashcode怎麼辦那（我們假設上面的類的ID不是唯一的），例如9除以8和17除以8的餘數都是1，那麼這是不是合法的，回答是：可以這樣。那麼如何判斷呢？在這個時候就需要定義 equals了。
也就是說，我們先通過 hashcode來判斷兩個類是否存放某個桶裡，但這個桶裡可能有很多類，那麼我們就需要再通過 equals 來在這個桶裡找到我們要的類。
那麼。重寫了equals()，為什麼還要重寫hashCode()呢？
想想，你要在一個桶裡找東西，你必須先要找到這個桶啊，你不通過重寫hashcode()來找到桶，光重寫equals()有什麼用啊

2、關於equals

1.equals和==
==用於比較引用和比較基本資料型別時具有不同的功能：
比較基本資料型別，如果兩個值相同，則結果為true
而在比較引用時，如果引用指向記憶體中的同一物件，結果為true;

equals()作為方法，實現物件的比較。由於==運算子不允許我們進行覆蓋，也就是說它限制了我們的表達。因此我們複寫equals()方法，達到比較物件內容是否相同的目的。而這些通過==運算子是做不到的。

2.object類的equals()方法的比較規則為：如果兩個物件的型別一致，並且內容一致，則返回true,這些類有：
java.io.file,java.util.Date,java.lang.string,包裝類（Integer,Double等）
String s1=new String("abc");
String s2=new String("abc");
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
執行結果為false true

二、HashMap的實現原理

1.    HashMap概述

    HashMap是基於雜湊表的Map介面的非同步實現。此實現提供所有可選的對映操作，並允許使用null值和null鍵。此類不保證對映的順序，特別是它不保證該順序恆久不變。

    在java程式語言中，最基本的結構就是兩種，一個是陣列，另外一個是模擬指標（引用），所有的資料結構都可以用這兩個基本結構來構造的，HashMap也不例外。HashMap實際上是一個“連結串列雜湊”的資料結構，即陣列和連結串列的結合體。

從上圖中可以看出，HashMap底層就是一個陣列結構，陣列中的每一項又是一個連結串列。當新建一個HashMap的時候，就會初始化一個陣列。

其中Java原始碼如下：

/**
 * The table, resized as necessary. Length MUST Always be a power of two.
 */
transient Entry[] table;

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    final int hash;
    ……
}

可以看出，Entry就是陣列中的元素，每個 Map.Entry 其實就是一個key-value對，它持有一個指向下一個元素的引用，這就構成了連結串列。

2、HashMap實現儲存和讀取

1）儲存

 1 public V put(K key, V value) {
 2     // HashMap允許存放null鍵和null值。
 3     // 當key為null時，呼叫putForNullKey方法，將value放置在陣列第一個位置。
 4     if (key == null)
 5         return putForNullKey(value);
 6     // 根據key的keyCode重新計算hash值。
 7     int hash = hash(key.hashCode());
 8     // 搜尋指定hash值在對應table中的索引。
 9     int i = indexFor(hash, table.length);
10     // 如果 i 索引處的 Entry 不為 null，通過迴圈不斷遍歷 e 元素的下一個元素。
11     for (Entry<K,V> e = table[i]; e != null; e = e.next) {
12         Object k;
13         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
14             // 如果發現已有該鍵值，則儲存新的值，並返回原始值
15             V oldValue = e.value;
16             e.value = value;
17             e.recordAccess(this);
18             return oldValue;
19         }
20     }
21     // 如果i索引處的Entry為null，表明此處還沒有Entry。
22     modCount++;
23     // 將key、value新增到i索引處。
24     addEntry(hash, key, value, i);
25     return null;
26 }

根據hash值得到這個元素在陣列中的位置（即下標），如果陣列該位置上已經存放有其他元素了，那麼在這個位置上的元素將以連結串列的形式存放，新加入的放在鏈頭，最先加入的放在鏈尾。如果陣列該位置上沒有元素，就直接將該元素放到此陣列中的該位置上。

hash(int h)方法根據key的hashCode重新計算一次雜湊。此演算法加入了高位計算，防止低位不變，高位變化時，造成的hash衝突。

1 static int hash(int h) {
2     h ^= (h >>> 20) ^ (h >>> 12);
3     return h ^ (h >>> 7) ^ (h >>> 4);
4 }

我們可以看到在HashMap中要找到某個元素，需要根據key的hash值來求得對應陣列中的位置。如何計算這個位置就是hash演算法。前面說過HashMap的資料結構是陣列和連結串列的結合，所以我們當然希望這個HashMap裡面的元素位置儘量的分佈均勻些，儘量使得每個位置上的元素數量只有一個，那麼當我們用hash演算法求得這個位置的時候，馬上就可以知道對應位置的元素就是我們要的，而不用再去遍歷連結串列，這樣就大大優化了查詢的效率。

根據上面 put 方法的原始碼可以看出，當程式試圖將一個key-value對放入HashMap中時，程式首先根據該 key的 hashCode() 返回值決定該 Entry 的儲存位置：如果兩個 Entry 的 key 的 hashCode() 返回值相同，那它們的儲存位置相同。如果這兩個 Entry 的 key 通過 equals 比較返回 true，新新增 Entry 的 value 將覆蓋集合中原有 Entry的 value，但key不會覆蓋。如果這兩個 Entry 的 key 通過 equals 比較返回 false，新新增的 Entry 將與集合中原有 Entry 形成 Entry 鏈，而且新新增的 Entry 位於 Entry 鏈的頭部——具體說明繼續看 addEntry() 方法的說明。

通過這種方式就可以高效的解決HashMap的衝突問題。

2）讀取

 1 public V get(Object key) {
 2     if (key == null)
 3         return getForNullKey();
 4     int hash = hash(key.hashCode());
 5     for (Entry<K,V> e = table[indexFor(hash, table.length)];
 6         e != null;
 7         e = e.next) {
 8         Object k;
 9         if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
10             return e.value;
11     }
12     return null;
13 }

從HashMap中get元素時，首先計算key的hashCode，找到陣列中對應位置的某一元素，然後通過key的equals方法在對應位置的連結串列中找到需要的元素。

3）歸納起來簡單地說，HashMap 在底層將 key-value 當成一個整體進行處理，這個整體就是一個 Entry 物件。HashMap 底層採用一個 Entry[] 陣列來儲存所有的 key-value 對，當需要儲存一個 Entry 物件時，會根據hash演算法來決定其在陣列中的儲存位置，在根據equals方法決定其在該陣列位置上的連結串列中的儲存位置；當需要取出一個Entry時，也會根據hash演算法找到其在陣列中的儲存位置，再根據equals方法從該位置上的連結串列中取出該Entry。

3、HashMap的resize

       當hashmap中的元素越來越多的時候，碰撞的機率也就越來越高（因為陣列的長度是固定的），所以為了提高查詢的效率，就要對hashmap的陣列進行擴容，陣列擴容這個操作也會出現在ArrayList中，所以這是一個通用的操作，很多人對它的效能表示過懷疑，不過想想我們的“均攤”原理，就釋然了，而在hashmap陣列擴容之後，最消耗效能的點就出現了：原陣列中的資料必須重新計算其在新陣列中的位置，並放進去，這就是resize。

       那麼hashmap什麼時候進行擴容呢？當hashmap中的元素個數超過陣列大小*loadFactor時，就會進行陣列擴容，loadFactor的預設值為0.75，也就是說，預設情況下，陣列大小為16，那麼當hashmap中元素個數超過16*0.75=12的時候，就把陣列的大小擴充套件為2*16=32，即擴大一倍，然後重新計算每個元素在陣列中的位置，而這是一個非常消耗效能的操作，所以如果我們已經預知hashmap中元素的個數，那麼預設元素的個數能夠有效的提高hashmap的效能。比如說，我們有1000個元素new HashMap(1000), 但是理論上來講new HashMap(1024)更合適，不過上面annegu已經說過，即使是1000，hashmap也自動會將其設定為1024。 但是new HashMap(1024)還不是更合適的，因為0.75*1000 < 1000, 也就是說為了讓0.75 * size > 1000, 我們必須這樣new HashMap(2048)才最合適，既考慮了&的問題，也避免了resize的問題。

 

總結：HashMap的實現原理：

1. 利用key的hashCode重新hash計算出當前物件的元素在陣列中的下標
2. 儲存時，如果出現hash值相同的key，此時有兩種情況。(1)如果key相同，則覆蓋原始值；(2)如果key不同（出現衝突），則將當前的key-value放入連結串列中
3. 獲取時，直接找到hash值對應的下標，在進一步判斷key是否相同，從而找到對應值。
4. 理解了以上過程就不難明白HashMap是如何解決hash衝突的問題，核心就是使用了陣列的儲存方式，然後將衝突的key的物件放入連結串列中，一旦發現衝突就在連結串列中做進一步的對比。