數據結構圖

image.png

名詞解釋

• initialCapacity初始容量,默認16,必須是2的指數次冪
• loadFactor加載因子,默認0.75f
• threshold擴容閾值,值為(initialCapacity*loadFactor),用來判斷數組長度是否超過,若超過就要擴容【擴容的條件其實一個是達到閾值，另外一個就是插入的key-value在數組上是沒有對應值的，因為沒有對應值才需要占用數組的一個位置】

源碼解析

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;
        //Node數組已經初始化，判斷是否進行擴容
        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) // initial capacity was placed in threshold
            newCap = oldThr;
        //進行數組的初始化
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY; //這個DEFAULT_INITIAL_CAPACITY就是默認的初始化數組的長度1>>>4 = 16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //設置擴容閾值 默認是等于0.75f * 16
        }
        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;
                            #JDK8進行數組遷移時不用像JDK7那樣重新計算Hash
                            #只需要看看原來的hash值新增的那個bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap”
                            #原索引
                            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;
    }

putVal方法-- 存放數據的方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        #判斷是否需要初始化，剛開始table是空，所以會調用resize進行初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        # p = tab[i = (n - 1) & hash] 計算這個key的下標index，如果這個下標沒被占用則就直接占用位置，否則進行鏈表
        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;
            #判斷這個類型是不是紅黑樹，如果是則采用紅黑樹的方式，JDK8當鏈表長度大于8時候會轉換成紅黑樹
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                #不是紅黑樹那就是鏈表，那就是調用p.next = newNode(hash, key, value, null)來設置指向
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // 如果鏈表長度大于TREEIFY_THRESHOLD，這個默認是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;
    }

hash方法

static final int hash(Object key) {
        int h;
        #主要兩個步驟 1.先拿到key的hashCode值 2.將hashCode的高16位參與運算進行位擾動，為了是減少碰撞，進一步降低hash沖突的幾率
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

get方法

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        #判斷table數組不為空，且長度大于0且key的hash(key) & length -1 能找到對應的插槽
        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;
}

查找紅黑樹的方法find

final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;
            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
                if ((ph = p.hash) > h) #傳入的hash值小于p節點的hash則往左遍歷
                    p = pl;
                else if (ph < h) #傳入的hash值大于p節點的hash則往右遍歷
                    p = pr;
                else if ((pk = p.key) == k || (k != null && k.equals(pk))) #傳入的hash值等于p就返回p
                    return p;
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
                #下面是如果key有實現了Comparable接口的處理過程，key和p節點的key會按照實現的接口比對得到結果dir，然后判斷dir的大小看是要左還是右遍歷
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
                else
                    p = pl;
            } while (p != null);
            return null;
}

注意點

• 為啥JDK8中當鏈表長度大于8就會轉成紅黑樹?
  鏈表結構對于新增刪除操作復雜度為O(1),但是查找遍歷鏈表的節點時需要逐一比對，復雜度為O(n),所以采用紅黑樹后查找的時間復雜度會降低很多。當鏈表長度大于8且數組長度大于64時才會轉紅黑樹
• 獲取到key的hash(key)后，判斷插入到鏈表的哪個位置是根據(hash(key) & table.length -1),這里為什么要-1?
  length-1為奇數，奇數的最后一位為1，這樣便保證了h&(length-1)的最后一位為0，也可能為1（這取決于h的值），即與后的結果可能為偶數也可能是奇數。這樣便可以保證散列的均勻性，而如果length為奇數的話，很明顯length-1為偶數，它的最后一位是0，這樣h&(length-1)的最后一位肯定為0，即只能為偶數，這樣任何hash值都只會被散列到數組的偶數下標位置上，這便浪費了近一半的空間。所以，length取2的整數次冪，是為了使不同hash值發生碰撞的概率較小，這樣就能使元素在哈希表中均勻地散列
  
  image.png
  
  
  image.png
• 為啥并發情況下不能用HashMap?
  并發的情況下會出指向循環的情況Infinite Loop
  
  image.png
• 發生hash碰撞時，JDK7會在鏈表頭部插入，而JDK8會在鏈表尾部插入頭插法是操作速度最快的，找到數組位置就直接找到插入位置了，但JDK8之前hashmap這種插入方法在并發場景下會出現死循環。JDK8開始hashmap鏈表在節點長度達到8之后會變成紅黑樹，這樣一來在數組后節點長度不斷增加時，遍歷一次的次數就會少很多（否則每次要遍歷所有），而且也可以避免之前的循環列表問題。同時如果變成紅黑樹，也不可能做頭插法了
• 為什么 HashMap中 String、Integer 這樣的包裝類適合作為 key鍵?
  final具有不可變性不容易出現hash計算錯誤，有效減少hash碰撞的幾率
• 什么時候進行擴容?
  當hashmap中的元素個數超過（數組大小乘于loadFactor）時，就會進行數組擴容，loadFactor的默認值為0.75，也就是說，默認情況下，數組大小為16，那么當hashmap中元素個數超過160.75=12的時候，就把數組的大小擴展為2*16=32，即擴大一倍，然后重新計算每個元素在數組中的位置，而這是一個非常消耗性能的操作，所以如果我們已經預知hashmap中元素的個數，那么預設元素的個數能夠有效的提高hashmap的性能

HashTable和HashMap區別

https://www.cnblogs.com/williamjie/p/9099141.html

參考資料

http://www.lxweimin.com/p/e1c020d37c6a
http://www.lxweimin.com/p/4aa3bb16f36c
https://www.cnblogs.com/little-fly/p/7344285.html
https://m.sohu.com/a/254899015_100012573
https://blog.csdn.net/qq_36520235/article/details/82417949
https://www.cnblogs.com/ysocean/p/8711071.html