HashMap源碼解析（JDK8）

前言

這段時間有空，專門填補了下基礎，把常用的ArrayList、LinkedList、HashMap、LinkedHashMap、LruCache源碼看了一遍，List相對比較簡單就不單獨介紹了，Map準備用兩篇的篇幅，分別介紹HashMap和（LruCache+LinkedHashMap），因爲LruCache是用LinkedHashMap實現的所以就和Lru一起介紹了。

概述

HashMap是一個用來存儲鍵值對的容器，並且key唯一value可以重複，線程不安全，遍歷時無序。
底層是通過數組實現稱之爲哈希桶，數組裏面裝的是單項鍊表。
哈希桶的容量是2的次方，這樣做的目的是爲了計算插入位置的時候可以直接用位運算與替代取餘操作提高效率。
默認擴容方式爲容量 * 2、閾值 * 2，添加元素時當鏈表長度>=8時會轉換爲紅黑樹提高查找效率，擴容時當紅黑樹中元素<=6時會轉回鏈表。擴容後元素的下標是根據hash與上舊的容量算出，如果==0則代表在低位下標不變，如果 != 0則代表在高位則爲原下標+原容量。
從迭代器可以看出迭代順序是無序的，按桶的下標從小到大，鏈表從前往後迭代。
key的哈希值並不是僅僅通過hashCode()方法返回，還加上了擾動函數使hashcode的高位也能參與插入桶下標的計算減少哈希衝突，因爲hashCode()方法返回的是Int型的值而Int取值範圍是2的32次方與上（我們桶數-1）計算插入下標的方式，默認情況只有低位參與了運算，那麼即使hashCode()方法返回的值是唯一的但是由於只有低位參與運算大大的增大了碰撞的可能性，所以需要擾動函數處理下讓高位也參與進下標的計算來減少哈希碰撞的可能性。

正文

接下來將按構造方法、增、刪、改、查、迭代的順序一一講解，看源碼相對會比較枯燥，不過沒事我會加上大量的註釋幫助理解。接下來開始吧。

構造方法

	static final int MAXIMUM_CAPACITY = 1 << 30;//容量最大值
	transient Node<K,V>[] table;//哈希桶
	final float loadFactor;//加載因子 threshold = 哈希桶.length * loadFactor
    int threshold;//閾值 當哈希桶中元素數量超過閾值的時候會觸發resize()擴容
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//默認加載因子
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默認容量16

	public HashMap(int initialCapacity, float loadFactor) {
        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);//返回通過tableSizeFor方法處理的容量，這裏稍微有點歧義他把容量賦值給了threshold閾值，不過後面他會把這個閾值賦給容量然後重新計算閾值。
    }
	
	//獲取新的容量，返回的值爲最近接並且>=cap的2的n次方，方便後面用與運算代替取餘
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);//調用第一個構造方法默認加載因子0.75
    }

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    public HashMap(Map<? extends K, ? extends V> m) {//傳入一個map存到我們新創建的map中
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

可以發現上面的構造函數主要功能就是初始化加載因子loadFactor和容量，一般情況下加載因子我們使用默認的0.75，接下來看第四個構造方法中的putMapEntries()方法

    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();//拿到要添加的map的size
        if (s > 0) {//範圍判斷
            if (table == null) { // 哈希桶未初始化
                float ft = ((float)s / loadFactor) + 1.0F;//計算容量
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?//容量邊界判斷
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);//獲取最接近的並且>=t的2的n的值作爲容量
            }
            else if (s > threshold)//如果size大於threshold擴容
                resize();//擴容
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {//for循環將值一一插入
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);//put鍵值對到map
            }
        }
    }

這個方法中又出現了2個新的方法resize()擴容和putVal()增加，putVal()後面會講，這裏我們先看非常重要的擴容方法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;//閾值改爲Integer.MAX_VALUE,容量不變
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)//新的容量爲舊容量*2
                newThr = oldThr << 1; // 新的閾值爲舊閾值*2
        }
        else if (oldThr > 0) //哈希表未初始化，但是有閾值
            newCap = oldThr;// 這個就是我們前面說過的他在構造方法的時候把容量賦給閾值的情況，這裏他把前面計算得到的容量通過oldThr賦值給了新的newCap容量，後面他會重新計算閾值。
        else {//哈希桶未初始化 容量也未初始化
            newCap = DEFAULT_INITIAL_CAPACITY;//默認容量16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//默認閾值12
        }
        if (newThr == 0) {//如果前面判斷走的else if即newThr爲0重新計算閾值
            float ft = (float)newCap * loadFactor;//計算閾值
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);//邊界判斷
        }
        /**
        * 上面這一大段其實就是計算新的容量和閾值，容量的默認值爲16閾值默認值爲12，默認擴容方式是*2。
        * 下面的話則是新建一個桶然後把原來的數據裝到新桶中
        */
        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) {//如果桶中元素不爲null賦值給e
                    oldTab[j] = null;//去除舊的桶中的引用
                    if (e.next == null)//如果鏈表中節點沒有下一個元素則沒發生碰撞
                        newTab[e.hash & (newCap - 1)] = e;//直接把節點的hash與上新的容量-1得出下標裝入新桶中
                    else if (e instanceof TreeNode)//如果是樹節點則代表此處是紅黑樹 由於紅黑樹不是本篇重點這裏就略過了
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);//將紅黑樹中的節點添加到新的桶中
                    else { //該節點是個鏈表
                        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) {//hash與上舊的容量如果==0則在低位，否則在高位
                                if (loTail == null)//如果尾部爲null
                                    loHead = e;//添加到頭部
                                else
                                    loTail.next = e;//尾部下一個爲e
                                loTail = e;//尾部爲e
                            }
                            else {//位置在高位 完成鏈表的組裝
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);//如果下一個元素不爲null
                        if (loTail != null) {//低位鏈表不爲空
                            loTail.next = null;
                            newTab[j] = loHead;//添加到原始下標j
                        }
                        if (hiTail != null) {//高位鏈表不爲空
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;//添加到原始下標j+舊的容量
                        }
                    }
                }
            }
        }
        return newTab;
    }

構造方法和擴容方法resize()就說完了，簡單總結下。

構造方法就是對加載因子loadFactor和容量做了初始化，雖然構造方法中容量一開始是threshold變量存儲的有點奇怪不過後面，他會把threshold賦值給newCap並重新計算閾值所以沒有問題。
擴容方法resize()實現分爲兩步
1. 計算新的容量和閾值，默認容量16閾值12，然後擴容的方式是*2
2. 創建新的桶，將原有的元素放到新的桶中，需要注意的是插入新桶的下標是根據哈希值與上舊容量得出，低位的話下標不變，高位的話下標爲原下標+原容量得出。

增、改

增和改都是同一個方法put這裏就一起講了

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

先看下獲取哈希值的hash()方法

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

可以看到它是key的哈希值異或了高位的值，這部分^ (h >>> 16)就是我們前面提到的擾動函數讓高位也參與下標的運算減少哈希衝突的機率。

	static final int TREEIFY_THRESHOLD = 8;//鏈表轉爲紅黑樹的界限
	final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i//聲明表變量tab，要插入的位置上的原始元素p，容量n，插入下標i
        if ((tab = table) == null || (n = tab.length) == 0)//如果表爲空或者容量爲0
            n = (tab = resize()).length;//初始化表
        if ((p = tab[i = (n - 1) & hash]) == null)//要插入位置上沒有元素即沒發生碰撞
            tab[i] = newNode(hash, key, value, null);//直接插入該位置
        else {//發生了碰撞
            Node<K,V> e; K k;//聲明節點變量e代表找到了與要插入元素key一樣節點
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))//如果要插入元素key的hash值與該位置上元素相同，並且key相等。
                e = p;//將要插入位置上的原始元素p賦值給e
            else if (p instanceof TreeNode)//如果要插入位置上的原始元素是樹節點
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//找到了key的hash值相同，key也相等的元素賦值給e
            else {//要插入位置上是一個鏈表
                for (int binCount = 0; ; ++binCount) {//遍歷鏈表
                    if ((e = p.next) == null) {//如果下個元素爲null
                        p.next = newNode(hash, key, value, null);//直接插入鏈表尾部
                        if (binCount >= TREEIFY_THRESHOLD - 1) //如果鏈表長度大於等於8
                            treeifyBin(tab, hash);//鏈表轉爲紅黑樹
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))//找到了key哈希值相同並且相等的元素就停止遍歷
                        break;
                    p = e;
                }
            }
            if (e != null) { //存在key相同的
                V oldValue = e.value;//拿到舊的值
                if (!onlyIfAbsent || oldValue == null)//判斷是否允許覆蓋已有的鍵值對，默認可以覆蓋
                    e.value = value;//替換value的值
                afterNodeAccess(e);
                return oldValue;//返回舊的值
            }
        }
        ++modCount;//修改數++
        if (++size > threshold)//判斷size是否超過閾值
            resize();//擴容
        afterNodeInsertion(evict);
        return null;
    }

簡單總結下

key的哈希值除了通過hashCode()方法獲取，^ (h >>> 16)還異或了高位減少哈希衝突。
put元素的時候先判斷該位置是否有元素，沒有直接插入，有的話即哈希衝突了，那麼比較key的哈希值是否相同並且key是否相等，如果相同默認情況會替換value，如果不相同插入鏈表尾部或者紅黑樹，如果鏈表長度大於等於8的話會轉爲紅黑樹，添加完成後再判斷size是否大於threshold閾值，如果大於則擴容。

刪

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;//聲明變量tab爲哈希表，p爲要刪除下標的元素，n爲桶的長度，index爲要插入的下標
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {//如果表不爲空，要刪除下標位置元素不爲空
            Node<K,V> node = null, e; K k; V v;//node爲要刪除元素
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))//如果哈希相同值也相同
                node = p;
            else if ((e = p.next) != null) {//下一個元素不爲空
                if (p instanceof TreeNode)//如果爲紅黑樹
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);//找到紅黑樹中key哈希相同值相同的元素
                else {//爲鏈表
                    do {//遍歷鏈表
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {//找到鏈表中key哈希相同值相同的元素
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {//如果要刪除節點不爲空默認情況下不需要匹配值
                if (node instanceof TreeNode)//如果是紅黑樹
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);//移除該節點
                else if (node == p)//如果第一個元素就是要刪除的元素
                    tab[index] = node.next;//移除該元素
                else//如果是鏈表
                    p.next = node.next;//切斷指針
                ++modCount;//修改修改數
                --size;//減少size
                afterNodeRemoval(node);
                return node;//返回刪除的值
            }
        }
        return null;
    }

刪相對比較簡單就是找到key對應下標的元素，如果存在並且key的哈希值相同key值也相等則移除，返回刪除的value。

查

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

遍歷

遍歷是通過entrySet()方法獲取了鍵值對的set集合來遍歷

    public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

然後我們直接看到他的迭代器

    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        ...
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }
        ...
    }

    final class EntryIterator extends HashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }//可以看到next方法就是調用迭代器的nextNode()方法
    }
    
    abstract class HashIterator {//迭代器對象
        Node<K,V> next;        // next entry to return
        Node<K,V> current;     // current entry
        int expectedModCount;  // for fast-fail
        int index;             // current slot

        HashIterator() {
            expectedModCount = modCount;
            Node<K,V>[] t = table;
            current = next = null;
            index = 0;
            if (t != null && size > 0) { //如果桶不爲空
                do {} while (index < t.length && (next = t[index++]) == null);//按順序從小到大查找出桶中第一個不爲null的元素賦值給next
            }
        }

        public final boolean hasNext() {//如果next不爲空則繼續迭代
            return next != null;
        }

        final Node<K,V> nextNode() {
            Node<K,V>[] t;
            Node<K,V> e = next;
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            if ((next = (current = e).next) == null && (t = table) != null) {//如果表不爲空並且next爲空，則接着找到下一個不爲null的節點
                do {} while (index < t.length && (next = t[index++]) == null);//按順序從小到大查找出桶中不爲null的元素賦值給next
            }
            return e;
        }

        public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;
        }
    }

可以發現迭代是從小到大遍歷桶中元素，如果節點是個鏈表則按照從前往後迭代，並且遍歷是無序的。

總結

HashMap是一個用來存儲鍵值對的容器，並且key唯一value可以重複，線程不安全，遍歷時無序。
底層是通過數組實現稱之爲哈希桶，數組裏面裝的是單項鍊表。
哈希桶的容量是2的次方，這樣做的目的是爲了計算插入位置的時候可以直接用位運算與替代取餘操作提高效率。
默認擴容方式爲容量 * 2、閾值 * 2，添加元素時當鏈表長度>=8時會轉換爲紅黑樹提高查找效率，擴容時當紅黑樹中元素<=6時會轉回鏈表。擴容後元素的下標是根據hash與上舊的容量算出，如果==0則代表在低位下標不變，如果 != 0則代表在高位則爲原下標+原容量。
從迭代器可以看出迭代順序是無序的，按桶的下標從小到大，鏈表從前往後迭代。
key的哈希值並不是僅僅通過hashCode()方法返回，還加上了擾動函數使hashcode的高位也能參與插入桶下標的計算減少哈希衝突，因爲hashCode()方法返回的是Int型的值而Int取值範圍是2的32次方與上（我們桶數-1）計算插入下標的方式，默認情況只有低位參與了運算，那麼即使hashCode()方法返回的值是唯一的但是由於只有低位參與運算大大的增大了碰撞的可能性，所以需要擾動函數處理下讓高位也參與進下標的計算來減少哈希碰撞的可能性。

細心的同學可能會發現這總結就是前面概述的copy，沒錯我就這麼大膽的承認了，不過看過源碼後再來看這個總結相信會有更多體會。

HashMap源碼解析（JDK8）

前言

概述

正文

構造方法

增、改

刪

查

遍歷

總結

容器中nginx無法使用同一個網絡下的容器域名

Python: SunMoonTimeCalculator

「Pygors跨平臺GUI」1：Pygors跨平臺GUI應用研究

NETCore中實現一個輕量無負擔的極簡任務調度ScheduleTask

docker使用特定的網絡

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

「Pygors跨平臺GUI」2：安裝MinGW-w64、MSYS2還是WSL2

nodejs學習07——API

避免DbContext同時在多個線程調用

GPT-4o 引領人機交互新風向，向量數據庫賽道沸騰了

OkHttp-RetryAndFollowUpInterceptor源碼解析

OkHttp-BridgeInterceptor源碼解析

OkHttp-CallServerInterceptor源碼解析

OkHttp-ConnectInterceptor源碼解析

View繪製源碼淺析(一）佈局的加載

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

linux以太網驅動總結