還不清楚HashMap嗎?讀完這篇你就懂了!

概述

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

爲什麼叫做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被修改或者刪除的次數總數。

HashMap的存儲結構

還不清楚HashMap嗎?讀完這篇你就懂了!

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

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

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

HashMap的基本原理

1、首先判斷Key是否爲Null,如果爲null,直接查找Enrty[0],如果不是Null,先計算Key的HashCode,然後經過二次Hash,得到Hash值。

2、根據Hash值,對Entry[]的長度length求餘,得到的就是Entry數組的index。

3、根據對應的索引找到對應的數組,就是找到了其所在的鏈表,然後按照鏈表的操作對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,就增加新的節點。

  1. 計算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的,感覺畫的不錯。
還不清楚HashMap嗎?讀完這篇你就懂了!

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內部已經非常清楚了,如果本篇文章對你有幫助記得關注我,我會繼續更新文章,感謝支持!

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章