Java集合之HashMap

時間 2019-11-09

標籤 java 集合 hashmap 欄目 Java 简体版

原文原文鏈接

1. HashMap概述：
　　HashMap是基於哈希表的Map接口的非同步實現（Hashtable跟HashMap很像，惟一的區別是Hashtalbe中的方法是線程安全的，也就是同步的）。此實現提供全部可選的映射操做，並容許使用null值和null鍵。此類不保證映射的順序，特別是它不保證該順序恆久不變。java

四個關注點在HashMap上的答案算法

關注點	結論
HashMap是否容許空	Key和Value都容許爲空
HashMap是否容許重複數據	Key重複會覆蓋、Value容許重複
HashMap是否有序	無序，特別說明這個無序指的是遍歷HashMap的時候，獲得的元素的順序基本不多是put的順序
HashMap是否線程安全	非線程安全

2. HashMap的數據結構：
　　在java編程語言中，最基本的結構就是兩種，一個是數組，另一個是模擬指針（引用），全部的數據結構均可以用這兩個基本結構來構造的，HashMap也不例外。HashMap其實是一個「鏈表的數組」的數據結構，每一個元素存放鏈表頭結點的數組，即數組和鏈表的結合體。編程

從上圖中能夠看出，HashMap底層就是一個數組結構，數組中的每一項又是一個鏈表。當新建一個HashMap的時候，就會初始化一個數組。源碼以下：數組

/**
 * 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的底層主要是基於數組和鏈表來實現的，它之因此有至關快的查詢速度主要是由於它是經過計算散列碼來決定存儲的位置。HashMap中主要是經過key的hashCode來計算hash值的，只要hashCode相同，計算出來的hash值就同樣。若是存儲的對象對多了，就有可能不一樣的對象所算出來的hash值是相同的，這就出現了所謂的hash衝突。學過數據結構的同窗都知道，解決hash衝突的方法有不少，HashMap底層是經過鏈表來解決hash衝突的。數據結構

圖中，紫色部分即表明哈希表，也稱爲哈希數組，數組的每一個元素都是一個單鏈表的頭節點，鏈表是用來解決衝突的，若是不一樣的key映射到了數組的同一位置處，就將其放入單鏈表中。編程語言

對於 HashMap 及其子類而言，它們採用 Hash 算法來決定集合中元素的存儲位置。當系統開始初始化 HashMap 時，系統會建立一個長度爲 capacity 的 Entry 數組，這個數組裏能夠存儲元素的位置被稱爲「桶（bucket）」，每一個 bucket 都有其指定索引，系統能夠根據其索引快速訪問該 bucket 裏存儲的元素。函數

　　不管什麼時候，HashMap 的每一個「桶」只存儲一個元素（也就是一個 Entry），因爲 Entry 對象能夠包含一個引用變量（就是 Entry 構造器的的最後一個參數）用於指向下一個 Entry，所以可能出現的狀況是：HashMap 的 bucket 中只有一個 Entry，但這個 Entry 指向另外一個 Entry ——這就造成了一個 Entry 鏈。性能

3. HashMap的構造函數：優化

HashMap提供了三個構造函數：
HashMap()：構造一個具備默認初始容量 (16) 和默認加載因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity)：構造一個帶指定初始容量和默認加載因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity, float loadFactor)：構造一個帶指定初始容量和加載因子的空 HashMap。
在這裏提到了兩個參數：初始容量，加載因子。這兩個參數是影響HashMap性能的重要參數，其中容量表示哈希表中桶的數量，初始容量是建立哈希表時的容量，加載因子是哈希表在其容量自動增長以前能夠達到多滿的一種尺度，它衡量的是一個散列表的空間的使用程度，負載因子越大表示散列表的裝填程度越高，反之愈小。對於使用鏈表法的散列表來講，查找一個元素的平均時間是O(1+a)，所以若是負載因子越大，對空間的利用更充分，然然後果是查找效率的下降；若是負載因子過小，那麼散列表的數據將過於稀疏，對空間形成嚴重浪費。系統默認負載因子爲0.75，通常狀況下咱們是無需修改的。

若:加載因子越大,填滿的元素越多,好處是,空間利用率高了,但:衝突的機會加大了.鏈表長度會愈來愈長,查找效率下降。
反之,加載因子越小,填滿的元素越少,好處是:衝突的機會減少了,但:空間浪費多了.表中的數據將過於稀疏（不少空間還沒用，就開始擴容了）

當哈希表中條目數超出了當前容量*加載因子(其實就是HashMap的實際容量)時，則對該哈希表進行rehash操做，將哈希表擴充至兩倍的桶數。

4.HashMap的存取實現

（1）存儲

public V put(K key, V value) {
    //當key爲null，調用putForNullKey方法，保存null與table第一個位置中，這是HashMap容許爲null的緣由
    if (key == null)
        return putForNullKey(value);
    //計算key的hash值
    int hash = hash(key.hashCode());                  ------(1)
    //計算key hash 值在 table 數組中的位置
    int i = indexFor(hash, table.length);             ------(2)
    //從i出開始迭代 e,找到 key 保存的位置
    for (Entry<K, V> e = table[i]; e != null; e = e.next) {
        Object k;
        //判斷該條鏈上是否存在相同的key值
        //若存在相同，則直接覆蓋value，返回舊value
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;    //舊值 = 新值
              e.value = value;
            e.recordAccess(this);
            return oldValue;     //返回舊值
        }
    }
    //修改次數增長1
    modCount++;
    //將key、value添加至i位置處
     addEntry(hash, key, value, i);
    return null;
}

經過源碼咱們能夠清晰看到HashMap保存數據的過程爲：首先判斷key是否爲null，若爲null，則直接調用putForNullKey方法，將value放置在數組第一個位置上。若不爲空則根據key的hashCode從新計算hash值，而後根據hash值獲得這個元素在table數組中的位置（即下標），若是table數組在該位置處已經存放有其餘元素了，則經過比較是否存在相同的key，若存在則覆蓋原來key的value，不然將該元素保存在鏈頭（最早保存的元素放在鏈尾）。若table在該處沒有元素，就直接將該元素放到此數組中的該位置上。這個過程看似比較簡單，其實深有內幕。有以下幾點：
一、先看迭代處。此處迭代緣由就是爲了防止存在相同的key值，若發現兩個key值相同時，HashMap的處理方式是用新value替換舊value，這裏並無處理key，這就解釋了HashMap中沒有兩個相同的key。另外，注意一點，對比Key是否相同，是先比HashCode是否相同，HashCode相同再判斷equals是否爲true，這樣大大增長了HashMap的效率。
二、在看（1）、（2）處。這裏是HashMap的精華所在。首先是hash方法，該方法爲一個純粹的數學計算，就是計算h的hash值。此算法加入了高位計算，防止低位不變，高位變化時，形成的hash衝突。

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

爲何要通過這樣的運算呢？這就是HashMap的高明之處。先看個例子，一個十進制數32768(二進制1000 0000 0000 0000)，通過上述公式運算以後的結果是35080(二進制1000 1001 0000 1000)。看出來了嗎？或許這樣還看不出什麼，再舉個數字61440(二進制1111 0000 0000 0000)，運算結果是65263(二進制1111 1110 1110 1111)，如今應該很明顯了，它的目的是讓「1」變的均勻一點，散列的本意就是要儘可能均勻分佈。

咱們知道對於HashMap的table而言，數據分佈須要均勻（最好每項都只有一個元素，這樣就能夠直接找到），不能太緊也不能太鬆，太緊會致使查詢速度慢，太鬆則浪費空間。計算hash值後，怎麼才能保證table元素分佈均與呢？咱們會想到取模，可是因爲取模的消耗較大，HashMap是這樣處理的：調用indexFor方法。

static int indexFor(int h, int length) {
    return h & (length-1);
}

HashMap的底層數組長度老是2的n次方，在構造函數中存在：capacity <<= 1;這樣作老是可以保證HashMap的底層數組長度爲2的n次方。當length爲2的n次方時，h&(length - 1)就至關於對length取模，也就是h%length，可是&比%具備更高的效率，速度比直接取模快得多，這是HashMap在速度上的一個優化。至於爲何是2的n次方下面解釋。
咱們回到indexFor方法，該方法僅有一條語句：h&(length - 1)，這句話除了上面的取模運算外還有一個很是重要的責任：均勻分佈table數據和充分利用空間。這裏咱們假設length爲16(2^n)和15，h爲五、六、7。

當length=15時，6和7的結果同樣，這樣表示他們在table存儲的位置是相同的，也就是產生了碰撞，六、7就會在一個位置造成鏈表，這樣就會致使查詢速度下降。誠然這裏只分析三個數字不是不少，那麼咱們就看0-15。

從上面的圖表中咱們看到總共發生了8此碰撞，同時發現浪費的空間很是大，有一、三、五、七、九、十一、1三、15處沒有記錄，也就是沒有存放數據。這是由於他們在與14進行&運算時，獲得的結果最後一位永遠都是0，即000一、00十一、010一、01十一、100一、10十一、110一、1111位置處是不可能存儲數據的，空間減小，進一步增長碰撞概率，這樣就會致使查詢速度慢。而當數組長度爲16時，即爲2的n次方時，2ⁿ-1獲得的二進制數的每一個位上的值都爲1（好比(2⁴-1)₂=1111），這使得在低位上&時，獲得的和原hash的低位相同，加之hash(int h)方法對key的hashCode的進一步優化，加入了高位計算，就使得只有相同的hash值的兩個值纔會被放到數組中的同一個位置上造成鏈表。因此說當length = 2^n時，不一樣的hash值發生碰撞的機率比較小，這樣就會使得數據在table數組中分佈較均勻，查詢速度也較快。

這裏咱們再來複習put的流程：當咱們想一個HashMap中添加一對key-value時，系統首先會計算key的hash值，而後根據hash值確認在table中存儲的位置。若該位置沒有元素，則直接插入。不然迭代該處元素鏈表並依此比較其key的hash值。若是兩個hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k))),則用新的Entry的value覆蓋原來節點的value。若是兩個hash值相等但key值不等，則將該節點插入該鏈表的鏈頭。具體的實現過程見addEntry方法，以下：

void addEntry(int hash, K key, V value, int bucketIndex) {
    //獲取bucketIndex處的Entry
    Entry<K, V> e = table[bucketIndex];
    //將新建立的 Entry 放入 bucketIndex 索引處，並讓新的 Entry 指向原來的 Entry 
    table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
    //若HashMap中元素的個數超過極限了，則容量擴大兩倍
    if (size++ >= threshold)
        resize(2 * table.length);
}

這個方法中有兩點須要注意：
一是鏈的產生。這是一個很是優雅的設計。系統老是將新的Entry對象添加到bucketIndex處。若是bucketIndex處已經有了對象，那麼新添加的Entry對象將指向原有的Entry對象，造成一條Entry鏈，可是若bucketIndex處沒有Entry對象，也就是e==null,那麼新添加的Entry對象指向null，也就不會產生Entry鏈了。
2、擴容問題。
隨着HashMap中元素的數量愈來愈多，發生碰撞的機率就愈來愈大，所產生的鏈表長度就會愈來愈長，這樣勢必會影響HashMap的速度，爲了保證HashMap的效率，系統必需要在某個臨界點進行擴容處理。該臨界點在當HashMap中元素的數量等於table數組長度*加載因子。可是擴容是一個很是耗時的過程，由於它須要從新計算這些數據在新table數組中的位置並進行復制處理。因此若是咱們已經預知HashMap中元素的個數，那麼預設元素的個數可以有效的提升HashMap的性能。

根據上面 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 鏈的頭部。

（2）讀取

相對於HashMap的存而言，取就顯得比較簡單了。經過key的hash值找到在table數組中的索引處的Entry，而後返回該key對應的value便可。

public V get(Object key) {
    // 若爲null，調用getForNullKey方法返回相對應的value
    if (key == null)
        return getForNullKey();
    // 根據該 key 的 hashCode 值計算它的 hash 碼  
    int hash = hash(key.hashCode());
    // 取出 table 數組中指定索引處的值
    for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
        Object k;
        //若搜索的key與查找的key相同，則返回相對應的value
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
            return e.value;
    }
    return null;
}

有了上面存儲時的hash算法做爲基礎，理解起來這段代碼就很容易了。從上面的源代碼中能夠看出：從HashMap中get元素時，首先計算key的hashCode，找到數組中對應位置的某一元素，而後經過key的equals方法在對應位置的鏈表中找到須要的元素。

當 HashMap 的每一個 bucket 裏存儲的 Entry 只是單個 Entry ——也就是沒有經過指針產生 Entry 鏈時，此時的 HashMap 具備最好的性能：當程序經過 key 取出對應 value 時，系統只要先計算出該 key 的 hashCode() 返回值，在根據該 hashCode 返回值找出該 key 在 table 數組中的索引，而後取出該索引處的 Entry，最後返回該 key 對應的 value 便可。

從上面代碼中能夠看出，若是 HashMap 的每一個 bucket 裏只有一個 Entry 時，HashMap 能夠根據索引、快速地取出該 bucket 裏的 Entry；在發生「Hash 衝突」的狀況下，單個 bucket 裏存儲的不是一個 Entry，而是一個 Entry 鏈，系統只能必須按順序遍歷每一個 Entry，直到找到想搜索的 Entry 爲止——若是剛好要搜索的 Entry 位於該 Entry 鏈的最末端（該 Entry 是最先放入該 bucket 中），那系統必須循環到最後才能找到該元素。

3) 概括起來簡單地說，HashMap 在底層將 key-value 當成一個總體進行處理，這個總體就是一個 Entry 對象。HashMap 底層採用一個 Entry[] 數組來保存全部的 key-value 對，當須要存儲一個 Entry 對象時，會根據hash算法來決定其在數組中的存儲位置，在根據equals方法決定其在該數組位置上的鏈表中的存儲位置；當須要取出一個Entry時，也會根據hash算法找到其在數組中的存儲位置，再根據equals方法從該位置上的鏈表中取出該Entry。

5.再談HashCode的重要性

前面講到了，HashMap中對Key的HashCode要作一次rehash，防止一些糟糕的Hash算法生成的糟糕的HashCode，那麼爲何要防止糟糕的HashCode？

糟糕的HashCode意味着的是Hash衝突，即多個不一樣的Key可能獲得的是同一個HashCode，糟糕的Hash算法意味着的就是Hash衝突的機率增大，這意味着HashMap的性能將降低，表如今兩方面：

(1)、有10個Key，可能6個Key的HashCode都相同，另外四個Key所在的Entry均勻分佈在table的位置上，而某一個位置上卻鏈接了6個Entry。這就失去了HashMap的意義，HashMap這種數據結構性高性能的前提是，Entry均勻地分佈在table位置上，但如今確是1 1 1 1 6的分佈。因此，咱們要求HashCode有很強的隨機性，這樣就儘量地能夠保證了Entry分佈的隨機性，提高了HashMap的效率。

(2)、HashMap在一個某個table位置上遍歷鏈表的時候的代碼：

if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

看到，因爲採用了"&&"運算符，所以先比較HashCode，HashCode都不相同就直接pass了，不會再進行equals比較了。HashCode由於是int值，比較速度很是快，而equals方法每每會對比一系列的內容，速度會慢一些。Hash衝突的機率大，意味着equals比較的次數勢必增多，必然下降了HashMap的效率了。