HashMap

JDK 1.7 和 JDK 1.8 的區別

概述

基於哈希表實現了 Map 接口, 提供了所有 map 的操作
無序, 且不能保證次序保持不變
提供時間複雜度爲常數的操作性能, 具體性能受初始容量和負載因子兩個參數影響
當哈希表中的元素數量超過了負載因子和哈希表容量的乘積時, 哈希表將會被rehash, 底層數組容量會被擴容, 每次擴容大小爲2倍
因爲底層數組的大小總是2的整數次冪, 所以使用除留餘數法計算數組下標時, 可以使用與運算進行優化.
默認的負載因子 0.75 在時間和空間成本之間提供了一個良好的平衡, 若值越高會節省更多空間但會提升查找開銷, 值約低則相反。
設置map初始容量時，應考慮Map中元素數量的期望值以及其負載因子，且傳入的初始容量會被自動轉爲大於原數的最小的2的次方
HashMap 的實現是非同步的，在併發的對一個HashMap對象進行改變結構(增加或刪除)的操作時, 必須由程序員在外部實現同步, 或者使用其他同步的map容器。
HashMap的迭代器是fail - fast 的，即在併發場景下使用迭代器迭代集合的過程中, 如果集合在結構上發生改變, 迭代器會盡最大努力拋出ConcurrentModificationException異常導致遍歷失敗。fail - fast 被用於檢測bug

1. 類

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
    {
    	......
    }

繼承關係

2. 屬性

靜態屬性


	private static final long serialVersionUID = 362498820763181265L;
    
     // 默認的容量  必須是2的次冪
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

	// 最大容量, 容器的容量必須是 2的次冪且 <= 1 << 30
	static final int MAXIMUM_CAPACITY = 1 << 30;

	// 構造器中沒有指定時使用的默認負載因子
	static final float DEFAULT_LOAD_FACTOR = 0.75f;

	// 鏈表轉紅黑樹的計數閾值
	static final int TREEIFY_THRESHOLD = 8;

	// 紅黑樹轉鏈表的計數閾值
 	static final int UNTREEIFY_THRESHOLD = 6;

	// 當數組長度小於該值時, 紅黑樹會被轉成鏈表
	static final int MIN_TREEIFY_CAPACITY = 64;

靜態內部類

Node結點

   static class Node<K,V> implements Map.Entry<K,V>
    {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        
        // 構造器 get set equals方法 
        .....
    }

TreeNode結點

    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
        
		// 操作樹的方法
		......
	}

成員屬性

	// 表, 第一次使用時初始化
	transient Node<K,V>[] table;

	// 保存緩存entrySet()
	transient Set<Map.Entry<K,V>> entrySet;
		
	// 包含的元素個數
	transient int size;

	// fail - fast 機制用到的元素修改次數
	transient int modCount;

	// 下一個要擴容的閾值(容量 * 負載因子)
	int threshold;

	// 哈希表的負載因子
    final float loadFactor;

3. 方法

構造方法

	// 無參構造, 使用默認容量16
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
	
	// 初始容量爲 initialCapacity 會被轉換爲最小的大於該值的2的次冪
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    // 負載因子爲  loadFactor 初始容量爲 initialCapacity, 大小同樣會被轉換2的次冪。
    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;
        // 將初始容量轉爲大於該值的最小的2的次冪
        this.threshold = tableSizeFor(initialCapacity);
    }
	
	// 將 cap 轉換爲 最小的大於cap的二的次冪
	static final int tableSizeFor(int cap) {
        int n = cap - 1;
        // 無符號右移 + 或運算
        // 示例  10010000  ->  11011000 -> 11111110 -> 11111111
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        // 最後判斷得出的 n 要大於0 小於最大容量才正確
        // 返回 n + 1 = 100000000  即爲 大於10010000的最小的2的次冪
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

put(key, value)方法

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

	// HashMap 允許null鍵和null值。 h >>> 16 在 與 h 異或, 將高位的影響向下傳播。 
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    
	// hash 鍵的哈希值
	// key  鍵
	// value 值
	// onlyIfAbsent 是true 則不替換已經存在的值
	// evict 用於子類 LinkedHashMap
	// 返回被替換的值, 新增則返回null
	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 表爲空 或 table 的長度爲0 則調用resize() 初始化表
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 因爲 table 長度 n 爲2的整數次冪, 則(n - 1) & hash 就等於hash對n取餘, 得到table中的位置 p
        // 如果 p 爲 null 則直接插入。
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            // 如果第一個節點的哈希和鍵就相等, 那麼直接替換
            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) {
                	// 到尾部直接插入
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 如果鏈表長度大於等於8 則將鏈表轉成紅黑樹(之前頭結點已經算過 這裏減一), 
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 如果到鏈表末尾前找到了相同哈希和鍵的節點, 則break跳出 到下一步替換值
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // e != null 說明之前找到了哈希值和鍵相同的節點, 現在用新的 value 替換舊value , 替換操作沒有改變表的結構, 所以直接返回。
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                // LinkedHashMap 的操作
                afterNodeAccess(e);
                return oldValue;
            }
        }
        // 上一個if沒有進入, 說明表的結構發生了改變， 需要modCount++記錄 以及 resize（）判斷
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

判斷 table 是否爲空, 空則初始化
對hash值進行與運算得到數組下標, 取出首元素p
如果首節點 p 爲 null 則可直接插入
首節點 p 不爲 null 則進行三個判斷
- 如果 p 的鍵和要插入的鍵相等, 則用 e 記錄
- 否則如果 p 是紅黑樹節點, 那麼調用紅黑樹查找到鍵key相等的節點, 用 e 記錄.。找不到則直接插入節點, 設置 e = null
- 否則說明 p 是鏈表節點, 使用鏈表查找到和鍵key相等的節點, 用 e 記錄。找不到則直接插入到鏈表爲, 設置 e = null, 並且判斷是否需要轉成紅黑樹。
判斷 e != null , 表明存在鍵key相等的節點, 直接替換value值, 返回被替換的舊值oldValue
沒有返回則表明 e == null, 不存在key相等的節點, 說明新增了節點來插入鏈表或者紅黑樹，表的結構發生了變化，需要modCount++記錄以及判斷是否需要resize（）擴容。最後返回null

resize()擴容

設 HashMap 的 table 長度爲 M，需要存儲的鍵值對數量爲 N，如果哈希函數滿足均勻性的要求，那麼每條鏈表的長度大約爲 N/M，因此平均查找次數的複雜度爲 O(N/M)。所以要想提升查找的效率，需要讓 M 即table儘可能的大，但太大又會浪費太多空間。
所以HashMap採用動態擴容來根據N的值調整M。使時間和空間維持一個良好的平衡。

與擴容有關的參數

參數	含義
capacity	table 的容量大小，默認爲 16。需要注意的是 capacity 必須保證爲 2 的 n 次方。
size	鍵值對數量。
threshold	size 的臨界值，當 size 大於等於 threshold 就必須進行擴容操作。threshold = newCapacity * loadFactor
loadFactor	負載因子，size 和 capacity的比例, 默認0.75。

		final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        // 如果哈希表還沒初始化, 則oldcap = 0
        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;
            }
            // oldCap << 1 擴容爲原來的二倍, 且小於最大容量大於默認的容量
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 擴容閾值也提升兩倍
                newThr = oldThr << 1; // double threshold
        }
        // 原來的容量不大於0 且 擴容閾值大於0 則新容量等於oldThr擴容閾值, (調用帶參構造器設置初始容量時, 會將調整好的初始化大小賦給threshold擴容閾值)
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // oldCap <= 0 也 oldThr <= 0 說明數組還未初始化 且沒有設置初始容量, 則賦值默認容量
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 如果newThr還爲0 則計算newThr
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        // 確定了 newThr, 進行賦值
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        // 新建Node數組, 開始賦值rehash
        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) {
                	// 釋放引用, 可以GC回收
                    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;
                            // 如果 hash 值的 oldCap的最高位的二進制爲0, 則接到lo鏈表裏
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            // 如果爲1 則接到hi鏈表裏
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                     	// 遍歷結束 lo鏈表接在新數組的原位置j
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // hi鏈表接在新數組的 j + oldCap位置
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

JDK1.7 在進行resize() 時, 會將舊數組中鏈表的每個節點的hash依次重新計算並使用頭插法插入新數組。
JDK1.8 使用與運算判斷, 能夠直接用尾插法創建好新數組對應節點上的2個鏈表，最後將鏈表在新數組中對應的位置插入。

get（key）方法

	// 判空處理 並計算hash值 hash()
    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;
        // table判空 以及取得數組對應位置的首節點first
        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) {
            	// 如果是紅黑樹, 進行紅黑樹的getTreeNode操作
                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;
    }

在 put(), get() 方法和 resize() 中的部分代碼中, 每當要遍歷一個數組位置上上的所有元素時, 一般分爲三步

判斷 table 是否合法, 判斷第一個節點是否符合條件。
第一個節點條件不符合, 在接着判斷該位置存儲的是是紅黑樹還是鏈表。
進行紅黑樹或鏈表的相關操作。

JDK 1.7 和 JDK 1.8 的區別

存儲：

JDK1.7 只使用單鏈表進行縱向存儲。
JDK1.8 單鏈表長度達到8時會轉成紅黑樹。

插入：

JDK1.7 採用頭插法，因爲只用單鏈表存儲，所以頭插法可以提升插入的效率，但在併發環境下put（）會形成環形鏈表，出現死循環問題，且resize（）擴容後鏈表會逆序。
JDK1.8 採用尾插法，且不會影響效率，因爲加入了紅黑樹避免了單鏈表過長的情況，尾插法同時也解決了死循環和逆序的問題。

擴容時索引的計算：

JDK1.7 在擴容時直接通過hash再次計算索引插入新數組。
JDK1.8 在擴容時通過判斷二進制位，可以直接計算出元素在新數組中的位置，並且可以一次性建立好鏈表，直接插入到新數組對應位置。

【Java】集合源碼 - HashMap

HashMap

概述

1. 類

2. 屬性

3. 方法

構造方法

put(key, value)方法

resize()擴容

get（key）方法

JDK 1.7 和 JDK 1.8 的區別

【Linux】幫助命令

【操作系統】線程的實現

【Redis】數據結構 - SDS

【Java】集合源碼 - HashMap

【計算機網絡】應用層 - DNS協議

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

linux以太網驅動總結