HashMap 原理

數據結構

JDK 8 和JDK 7 的區別

1.爲了加快查詢效率，java8的hashmap引入了紅黑樹結構，當數組長度大於默認閾值64時，且當某一鏈表的元素>8時，該鏈表就會轉成紅黑樹結構，查詢效率更高。（問題來了，什麼是紅黑樹？什麼是B+樹？（mysql索引有B+樹索引）什麼是B樹？什麼是二叉查找樹？）數據結構方面的知識點會更新在【數據結構專題】，這裏不展開。

這裏只簡單的介紹一下紅黑樹：

紅黑樹是一種自平衡二叉樹，擁有優秀的查詢和插入/刪除性能，廣泛應用於關聯數組。對比AVL樹，AVL要求每個結點的左右子樹的高度之差的絕對值（平衡因子）最多爲1，而紅黑樹通過適當的放低該條件（紅黑樹限制從根到葉子的最長的可能路徑不多於最短的可能路徑的兩倍長，結果是這個樹大致上是平衡的），以此來減少插入/刪除時的平衡調整耗時，從而獲取更好的性能，而這雖然會導致紅黑樹的查詢會比AVL稍慢，但相比插入/刪除時獲取的時間，這個付出在大多數情況下顯然是值得的。

2.優化擴容方法，在擴容時保持了原來鏈表中的順序，避免出現死循環

HashMap 的存儲結構是一個 Entry數組，和一個單向鏈表。JDK1.8之後鏈表結構如果超過 8 鏈表變成爲紅黑樹

容量(capacity)：每次擴容是 2*n 一定是2的n次方？！源碼中有個roundUpToPowerOf2(toSize); 方法 20 ->32

負責因子（loadFactor）： 0.75

擴容閥值（threshold）：0.75*capacity 到到這個值 hashmap擴容 <<=1

與hashtable比較

hashtabe 初始值 11 每次擴容 2*n+1

hashtable 採用的是synchronized 加鎖，保證線程安全，推薦使用concurrentHashMap 採用分段鎖的方式，效率更高

JDK 7 中hashmap 怎麼 put，get?

public V put(K key, V value) {
    // 當插入第一個元素的時候，需要先初始化數組大小
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    // 如果 key 爲 null，感興趣的可以往裏看，最終會將這個 entry 放到 table[0] 中
    if (key == null)
        return putForNullKey(value);
    // 1. 求 key 的 hash 值
    int hash = hash(key);
    // 2. 找到對應的數組下標
    int i = indexFor(hash, table.length);
    // 3. 遍歷一下對應下標處的鏈表，看是否有重複的 key 已經存在，
    //    如果有，直接覆蓋，put 方法返回舊值就結束了
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
 
    modCount++;
    // 4. 不存在重複的 key，將此 entry 添加到鏈表中，細節後面說
    addEntry(hash, key, value, i);
    return null;
}

先看數組初始化的函數 inflateTable

private void inflateTable(int toSize) {
    // 保證數組大小一定是 2 的 n 次方。
    // 比如這樣初始化：new HashMap(20)，那麼處理成初始數組大小是 32
    int capacity = roundUpToPowerOf2(toSize);
    // 計算擴容閾值：capacity * loadFactor
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    // 算是初始化數組吧
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity); //ignore
}

找到數組下標

原理: 使用 key 的 hash 值對數組長度進行取模就可以了, 這個也是因爲長度是 2的n次方纔可以這麼幹

static int indexFor(int hash, int length) {
    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
    return hash & (length-1);
}

添加節點到鏈表中

原理：找到數組下標後，會先進行 key 判重，如果沒有重複，就準備將新值放入到鏈表的表頭。

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 如果當前 HashMap 大小已經達到了閾值，並且新值要插入的數組位置已經有元素了，那麼要擴容
    if ((size >= threshold) && (null != table[bucketIndex])) {
        // 擴容，後面會介紹一下
        resize(2 * table.length);
        // 擴容以後，重新計算 hash 值
        hash = (null != key) ? hash(key) : 0;
        // 重新計算擴容後的新的下標
        bucketIndex = indexFor(hash, table.length);
    }
    // 往下看
    createEntry(hash, key, value, bucketIndex);
}

// 這個很簡單，其實就是將新值放到鏈表的表頭，然後 size++
void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

添加節點最重要的是先判斷是否需要擴容,需要的話先擴容，再把節點放到擴容後的數組相應位置的鏈表的表頭。

數組擴容

插入新值時，如果當前的數組已經到達了數組的閥值，並且插入的數組上已經有元素，會觸發擴容，擴容後，數組爲原來的兩倍

擴容時將一個新的數組替換爲原來的小數組，並且將原數組中的值插入到新數組中去。

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 = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

由於是雙倍擴容，遷移過程中，會將原來 table[i] 中的鏈表的所有節點，分拆到新的數組的 newTable[i] 和 newTable[i + oldLength] 位置上。如原來數組長度是 16，那麼擴容後，原來 table[0] 處的鏈表中的所有元素會被分配到新數組中 newTable[0] 和 newTable[16] 這兩個位置。

數組遷移 transfer

    void transfer(Entry[] newTable) {
             Entry[] src = table;                   //src引用了舊的Entry數組
             int newCapacity = newTable.length;
             for (int j = 0; j < src.length; j++) { //遍歷舊的Entry數組
                 Entry<K,V> e = src[j];             //取得舊Entry數組的每個元素
                 if (e != null) {
                     src[j] = null;//釋放舊Entry數組的對象引用（for循環後，舊的Entry數組不再引用任何對象）
                     do {// 頭插法建立鏈表
                         Entry<K,V> next = e.next;
                        int i = indexFor(e.hash, newCapacity); //！！重新計算每個元素在數組中的位置
                        e.next = newTable[i]; //標記[1]
                        newTable[i] = e;      //將元素放在數組上
                       e = next;             //訪問下一個Entry鏈上的元素
                    } while (e != null);
                }
            }
        }

總結: JDK7中HashMap如何put

putval方法：

判斷table 是否爲空或者null ,如果是，進行resize擴容

如果 key = null 這個key 防止entry 數組的 table[0]

如果key !=null 計算key的hash 值，然後根據hash值找到數據的下標

遍歷這個數組下的鏈表：

如果鏈表下有相同的key值，用這個新節點Node(K,V)的V 替代原來舊的value

如果鏈表下沒有相同的key,在鏈表中增加，如果size>threadhold 時候，進行擴容，此時需要根據hash重新計算數組下標，最後將節點加入到鏈表的表頭，方便查找

hashmap 如何 get？

根據 key 計算 hash 值。
找到相應的數組下標：hash & (length – 1)。
遍歷該數組位置處的鏈表，直到找到相等(==或equals)的 key。

根據key值得到value

public V get(Object key) {
    // 之前說過，key 爲 null 的話，會被放到 table[0]，所以只要遍歷下 table[0] 處的鏈表就可以了
    if (key == null)
        return getForNullKey();
    // 
    Entry<K,V> entry = getEntry(key);
 
    return null == entry ? null : entry.getValue();
}

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;
}

總結：JDK7中HashMap如何get?

如果key=null 返回的是tabe[0] 的鏈表，根據鏈表去找值就可以了

如果key!=null key做hash，找到數組下標，然後遍歷鏈表，根據key值比較，找到對應Node值，然後返回.

JDK1.8 中HashMap的數據結構

JDK8中對HashMap的結構做了一定的修改。JDK8中引入了紅黑樹，數據結構爲 數組+紅黑樹+鏈表

JDK8中HashMap如何put？

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
 
// 第三個參數 onlyIfAbsent 如果是 true，那麼只有在不存在該 key 時纔會進行 put 操作
// 第四個參數 evict 我們這裏不關心
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 第一次 put 值的時候，會觸發下面的 resize()，類似 java7 的第一次 put 也要初始化數組長度
    // 第一次 resize 和後續的擴容有些不一樣，因爲這次是數組從 null 初始化到默認的 16 或自定義的初始容量
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 找到具體的數組下標，如果此位置沒有值，那麼直接初始化一下 Node 並放置在這個位置就可以了
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
 
    else {// 數組該位置有數據
        Node<K,V> e; K k;
        // 首先，判斷該位置的第一個數據和我們要插入的數據，key 是不是"相等"，如果是，取出這個節點
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果該節點是代表紅黑樹的節點，調用紅黑樹的插值方法，本文不展開說紅黑樹
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 到這裏，說明數組該位置上是一個鏈表
            for (int binCount = 0; ; ++binCount) {
                // 插入到鏈表的最後面(Java7 是插入到鏈表的最前面)
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // TREEIFY_THRESHOLD 爲 8，所以，如果新插入的值是鏈表中的第 9 個
                    // 會觸發下面的 treeifyBin，也就是將鏈表轉換爲紅黑樹
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果在該鏈表中找到了"相等"的 key(== 或 equals)
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 此時 break，那麼 e 爲鏈表中[與要插入的新值的 key "相等"]的 node
                    break;
                p = e;
            }
        }
        // e!=null 說明存在舊值的key與要插入的key"相等"
        // 對於我們分析的put操作，下面這個 if 其實就是進行 "值覆蓋"，然後返回舊值
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 如果 HashMap 由於新插入這個值導致 size 已經超過了閾值，需要進行擴容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

JDK7和JDK8中不一樣的地方有JDK7是先擴容然後再放新值，JDK8是先放值後擴容，當然這個不是重點

總結下JDK8中put的思路

hashmap第一次put的時候，會進行擴容,用來初始化數組長度。
找到數組下標，判斷該數組下標對應的元素是否爲null,如果是null,直接將新值放進去即可
如果數組下標對應的元素不是null, 如果這個鏈表的第一個數據和要插入的值相等，說明了要覆蓋，後續處理；判斷節點類型是不是紅黑樹，然後使用紅黑樹的插值方法；如果是鏈表，有元素和要插入的值相等的，說明需要覆蓋，後續處理。不同的，插到鏈表最後面，然後判斷是否要轉成紅黑樹。
插入值之後，判斷是否需要擴容，需要擴容，走擴容流程。

HashMap擴容 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;
        }
        // 將數組大小擴大一倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 將閾值擴大一倍
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // 對應使用 new HashMap(int initialCapacity) 初始化後，第一次 put 的時候
        newCap = oldThr;
    else {// 對應使用 new HashMap() 初始化後，第一次 put 的時候
        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;
 
    // 用新的數組大小初始化新的數組
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab; // 如果是初始化數組，到這裏就結束了，返回 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 { 
                    // 這塊是處理鏈表的情況，
                    // 需要將此鏈表拆成兩個鏈表，放到新的數組中，並且保留原來的先後順序
                    // loHead、loTail 對應一條鏈表，hiHead、hiTail 對應另一條鏈表，代碼還是比較簡單的
                    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;
                        }
                        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;
                        // 第二條鏈表的新的位置是 j + oldCap，這個很好理解
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

JDK8 HashMap擴容和JDK7的有一定區別，JDK7中採用循環遍歷鏈表節點的方式擴容，在併發的情況下可能會成環，JDK8中，採用了高低鏈表的方式，有效的避免了這個問題。

JDK8中HashMap如何get

計算 key 的 hash 值，根據 hash 值找到對應數組下標: hash & (length-1)
判斷數組該位置處的元素是否剛好就是我們要找的，如果不是，走第3步
判斷該元素類型是否是 TreeNode，如果是，用紅黑樹的方法取數據，如果不是，走第4步
遍歷鏈表，直到找到相等(==或equals)的 key.

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

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;
}

http://www.javastack.cn/article/2018/hashmap-concurrenthashmap-details/

https://mp.weixin.qq.com/s/Q5F604CUM_0x2co9mvADxw

HashMap源碼解讀 JDK7/8

HashMap 原理

數據結構

.NET有哪些好用的定時任務調度框架

Python 將PDF轉爲PDF/A、PDF/X，以及PDF/A轉回PDF

elk3

Kafka存儲機制

aws語音呼叫調用，告警電話

深度學習框架火焰圖pprof和CUDA Nsys配置指南

爬蟲兩種繞過5s盾的方法

【轉】[C#] WebAPI 防止併發調用二（冥等性）

【轉】[SQL Server]關掉 SSMS 的 IntelliSense

號稱能打敗MLP的KAN到底行不行？數學核心原理全面解析

SQL 中的聚集函數？

Java 中 Hashtable 、HashMap 、TreeMap 有什麼不同？

【深入理解數據庫原理】數據庫索引原理

接口和抽象有什麼區別？

Java 常見的垃圾回收器

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結