Java中HashMap的實現原理

最近面試中被問及Java中HashMap的原理，瞬間無言以對，所以痛定思痛以爲研究一番。

1、Java中的hashCode和equals

一、關於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()有什麼用啊

二、關於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

2、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對，它持有一個指向下一個元素的引用，這就構成了鏈表。

二、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。

三、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的對象放入鏈表中，一旦發現衝突就在鏈表中作進一步的對比。

 

1.轉載註明：http://www.cnblogs.com/yuanblog/p/4441017.html

2.本文爲我的筆記、心得，可能引用其它文章，因此博客只在私自範圍內供你們學習參考。

參考博文：

http://www.cnblogs.com/yxnchinahlj/archive/2010/09/27/1836556.html

http://blog.csdn.net/fenglibing/article/details/8905007

http://zhangshixi.iteye.com/blog/672697