HashMap底層實現原理

時間 2019-11-15

標籤 hashmap 底層實現原理简体版

原文原文鏈接

HashMap概述

HashMap實現了Map接口，咱們經常使用HashMap進行put和get操做讀存鍵值對數據。下面介紹基於jdk1.8深刻了解HashMap底層原理。java

HashMap數據結構

HashMap實際是一種「數組+鏈表」數據結構。在put操做中，經過內部定義算法尋止找到數組下標，將數據直接放入此數組元素中，若經過算法獲得的該數組元素已經有了元素（俗稱hash衝突，鏈表結構出現的實際意義也就是爲了解決hash衝突的問題）。將會把這個數組元素上的鏈表進行遍歷，將新的數據放到鏈表末尾。node

存儲數據的對象

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;        
}複製代碼

咱們從jdk1.8源代碼看出存儲對象Node實際是實現Map.Entry對象接口。算法

hash：經過hash算法的出來的值。hash值的算法咱們看下HashMap源代碼的實現數組

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }複製代碼

不一樣的數據類型的hashCode計算的方法不同，咱們看下String和Integer兩種數據類型的hashCode算法安全

String.hashCode()bash

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }複製代碼

經過將字符串轉換成char數組，使用公式s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]進行計算得出最後的值。val[i]值是對應字符的ASCII值.在看到這裏的時候，這裏爲何使用了一個31做爲相乘因子（能爲啥，還不是爲了性能考慮，那爲何使用31性能能獲得優化呢），這裏能夠延伸討論。數據結構

Integer.hashCode()app

public static int hashCode(int value) {
        return value;
    }複製代碼

直接返回值.性能

key：存儲數據的key優化

value：存儲數據的value

next：下一個數據，出現哈希衝突時，該數組元素會出現鏈表結構，會使用next指向鏈表中下一個元素對象

鏈表結構致使的問題

經過哈希算法從尋止上可以高效的找到對應的下標，可是隨着數據的增加，哈希衝突碰撞過多。在尋找數據上，找到該來鏈表，會經過遍歷在尋找對應數據，如此將會使得get數據效率愈來愈低。在jdk1.8中，鏈表元素數量大於等於8將會重組該鏈表結構造成爲「紅黑樹結構」，這種結構使得在hash衝突碰撞過多狀況下，get效率比鏈表的效率高不少。

HashMap put存儲數據是如何處理的

HashMap有幾個重要的變量

transient Node<K,V>[] table;
int threshold;
final float loadFactor;
int modCount;  
int size;複製代碼

table：存儲數組的變量，初始長度爲16經過源代碼看出在第一次進行resize擴容（java是靜態語言，在定義數組初始化時，須要定義數組的長度，在map數據增加後，內部機制會進行從新定義一個數組作到擴容的操做）初始化時，會將默認靜態變量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;複製代碼

賦給數組長度進行初始化。

loadFactor：數據的增加因子，默認爲0.75。在進行擴容操做會使用到。

threshold：容許的最大的存儲的元素數量，經過length數組長度*loadFactor增加因子得出

modCount：記錄內部結構發生變化的次數，put操做（覆蓋值不計算）以及其餘...

size：實際存儲的元素數量

put的流程

直接經過源代碼分析

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 判斷數組是否爲空，長度是否爲0，是則進行擴容數組初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 經過hash算法找到數組下標獲得數組元素，爲空則新建
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
             // 找到數組元素，hash相等同時key相等，則直接覆蓋
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 該數組元素在鏈表長度>8後造成紅黑樹結構的對象
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // 該數組元素hash相等，key不等，同時鏈表長度<8.進行遍歷尋找元素，有就覆蓋無則新建
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        // 新建鏈表中數據元素
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 鏈表長度>=8 結構轉爲 紅黑樹
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }複製代碼

便於理解，花了一下圖。以下圖示（畫工不是很好，見諒見諒）

下圖是一位大神級別畫的圖，引用一下便於理解

一、首選判斷table是否爲空，數組長度爲空，將會進行第一次初始化。（在實例化HashMap是，並不會進行初始化數組）

二、進行第一次resize()擴容以後。開始經過hash算法尋址找到數組下標。若數組元素爲空，則建立新的數組元素。若數組元素不爲空，同時hash相等，key不相等，同時不是TreeNode數據對象，將遍歷該數組元素下的鏈表元素。若找到對應的元素，則覆蓋，若是沒有找到，就新建元素，放入上一個鏈表元素的next中，在放入元素以後，若是條件知足"鏈表元素長度>8"，則將該鏈表結構轉爲"紅黑樹結構"。

三、找到對應的數組元素或者鏈表元素，同時建立新的數據元素或者覆蓋元素以後。若是條件知足元素大小size>容許的最大元素數量threshold，則再一次進行擴容操做。每次擴容操做，新的數組大小將是原始的數組長度的兩倍。

四、put操做完成。

調用put方法示例

下面經過使用例子介紹這個過程

HashMap<Integer, String> hashMap = new HashMap<Integer, String>(4, 0.75f);// 1
int a1 = 1;
int a2 = 2;
int a3 = 5;
System.out.println(String.valueOf(a1&3) + " " + String.valueOf(a2&3)+ " " + String.valueOf(a3&3));// 1 2 1 數組下標
hashMap.put(a1, "1");// 2
hashMap.put(a2, "2");// 3
hashMap.put(a3, "5");// 4複製代碼

一、建立了一個HashMap對象，初始化initialCapacity爲4，增加因子爲0.75。threshold初始化爲4

二、進行了第一次put，由於table爲空，進行了第一次resize()擴容操做，數組進行初始化，默認爲16. threshold變爲3。同時經過hash算法（數組長度n-1 & hash）即爲1。

三、第二次put操做，同時獲取數組下標爲2，此時數組下標爲2當前沒有數組元素，則直接建立數據元素放入

四、第三次put操做，獲得數組下標爲1已經有了一個數組元素。同時咱們知道存儲數據的Node對象中又一個next，則新的此時的數據元素放入上一個鏈表中next爲空的Node中的next中。

造成了以下圖的數據結構

結論：經過hash算法進行計算的出來的數組下標，有必定機率會致使hash衝突，那在一個數組元素中，存在hash值同樣的key，key卻不相等。爲了解決這一個hash衝突問題，使用了鏈表結構進行處理。

HashMap擴容resize()

java是靜態方法，在數組進行初始化時，必須給一個數組長度。HashMap定義默認的數組長度爲16。條件知足元素size>容許的最大元素數量threshold。則進行擴容。通常來講，在put操做中，HashMap至少進行了一次擴容（第一次爲初始化）。

咱們在原有的示例加入以下

int a4 = 6;
hashMap.put(a4, "6");複製代碼

造成了新的結構，以下圖

放入了2:2的next中，此時size=4,threshold>3，條件知足size>threshold，進行擴容resize()操做

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            // 超過最大限制，不進行擴容
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 進行原始長度*2擴容
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        // 第一次初始化
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 第一次初始化
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        // 新的最大容許元素數量值
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        // 新的數組     
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            // 遍歷老數組
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 直接按照原始索引放入新數組中
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        // 遍歷鏈表
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            //　放入原索引
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
　　　　　　　　　　　　　　　// 原索引＋oldCap
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }複製代碼

在put6:6以後，直接就執行了擴容，新數組長度爲8，新的結構以下

在新的結構中，將原始的數組下標爲1和2鏈表元素均勻分佈新數組的其餘數組元素中。此間擴容的變化的過程以下

老數組長度爲4，經過算法得出數據的下標1:1爲1,5:5爲1,2:2和6:6爲2

1(1:1 == > 5:5)

2(2:2 == > 6:6)複製代碼

在進行擴容操做是，數組元素鏈表中的第一個數組下標不會產生變化，在遍歷鏈表其餘元素中經過算法"e.hash & oldCap"!=0則將鏈表元素放入新數據數組下標爲[原始數據下標+原始數據長度]

再次引用大神的圖，便於理解擴容的數據移動變化

在擴容操做中，因無需從新計算hash值，同時均勻將鏈表衝突的元素均勻分佈到新的數組中。這設計實在是巧妙。

get尋找數據

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }複製代碼