深度解析HashMap

時間  2019-11-17
標籤 深度 解析 hashmap 简体版
原文   原文鏈接

概述

HashMap對於使用Java的小夥伴們來講最熟悉不過，天天都在使用它。此次主要是分析下HashMap的工做原理，爲何我會拿這個東西出來分析，主要是最近面試的小夥伴們，中被人問起HashMap，HashMap涉及的知識遠遠不止put和get那麼簡單。java

爲何叫作HashMap？內部是怎樣實現的呢？使用的時候大多數都是用String做爲它的key呢？下面就讓咱們來了解HashMap，並給你詳細解釋這些問題。面試

HashMap名字的由來

其實HashMap的由來是基於Hasing技術(Hasing),Hasing就是將很大的字符串或者任何對象轉換成一個用來表明它們的很小的值，這些更短的值就能夠很方便的用來方便索引、加快搜索。
算法

什麼是HashMap

HashMap是一個用於存儲Key-Value鍵值對的集合，你能夠用一個」key」去存儲數據。當你想得到數據的時候，你能夠經過」key」去獲得數據，每個鍵值對也叫作Entry。這些個鍵值對（Entry）分散存儲在一個數組當中，這個數組就是HashMap的主幹。數組

HashMap做爲一種數據結構，像數組和鏈表同樣用於常規的增刪改查，在存數據的時候(put)並非隨便亂放，而是會先進行一次分配索引（能夠理解爲「分類」）的操做再存儲，一旦分配索引存儲以後，下次取(get)的時候就能夠大大縮短查找的時間。咱們知道數組在執行查、改的效率很高，而增、刪(不是尾部)的效率低，鏈表相反，HashMap則是把這二者結合起來，看下HashMap的數據結構

先介紹一下HashMap的變量安全

size,就是HashMap的存儲大小。threshold是HashMap臨界值，也叫閥值，若是HashMap到達了臨界值，須要從新分配大小。loadFactor是負載因子， 默認爲75%。閥值 = 當前數組長度✖負載因子。modCount指的是HashMap被修改或者刪除的次數總數。bash

HashMap的存儲結構



Entry分散存儲在一個Entry類型的數組table， table裏的每個數據都是一個Entry對象。Y軸方向表明的就是數組，X軸方向就是鏈表的存儲方式。數據結構

table裏面存儲的Entry類型，Entry類裏包含了hashcode變量，key,value 和另一個Entry對象。由於這是一個鏈表結構。經過我找到你，你再找到他。不過這裏的Entry並非LinkedList，它是單獨爲HashMap服務的一個內部單鏈表結構的類。
app

數組的特色是特色是查詢快，時間複雜度是O(1)，插入和刪除的操做比較慢，時間複雜度是O(n)。而鏈表的存儲方式是非連續的，大小不固定，特色與數組相反，插入和刪除快，查詢速度慢。HashMap引用他們，選取了他們的有段，能夠說是在查詢，插入和刪除的操做，都會有些提速。
函數

HashMap的基本原理

一、首先判斷Key是否爲Null，若是爲null，直接查找Enrty[0]，若是不是Null，先計算Key的HashCode，而後通過二次Hash，獲得Hash值。
源碼分析

二、根據Hash值，對Entry[]的長度length求餘，獲得的就是Entry數組的index。

三、根據對應的索引找到對應的數組，就是找到了其所在的鏈表，而後按照鏈表的操做對Value進行插入、刪除和查詢操做。

Hash碰撞

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.stringHash32((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，就增長新的節點。

2. 計算key的hashcode，再用計算的結果二次hash，經過indexFor(hash, table.length);找到Entry數組的索引i。

(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的，感受畫的不錯。


get操做

咱們經過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)方法中，也是按照遍歷方法來查找的。

modCount的做用

衆所周知，HashMap不是線程安全的，但在某些容錯能力較好的應用中，若是你不想僅僅由於1%的可能性而去承受hashTable的同步開銷，HashMap使用了Fail-Fast機制來處理這個問題，你會發現modCount在源碼中是這樣聲明的。

reSize

調用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內部已經很是清楚了，若是本篇文章對你有幫助記得點贊和評論，或者關注我，我會繼續更新文章，感謝支持！
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程