JDK1.8源碼閱讀一一HashMap

Hashtable、HashMap、TreeMap都是常見的map實現，是以鍵值對的形式存儲的容器類型。Hashtable是早期Java類庫提供的一個同步的哈希表實現，不支持null鍵和值。HashMap是應用較爲廣泛的哈希表實現，功能上與Hashtable類似，主要區別在於HashMap不是同步的，支持null的鍵和值。TreeMap則是基於紅黑樹的一種提供順序訪問的Map，具體順序可以由指定的Comparator來決定，或者根據鍵的默認順序。

一、HashMap

1.1 內部結構

HashMap的內部結構可以看成是數組(Node<K,V>[])和鏈表組成的結構，數組被分爲一個個bucket，通過哈希值決定了鍵值對在數組中的位置；哈希值相同的鍵值對則以鏈表形式存儲，如下圖：

如上圖，左側是一個table即Entry數組，對應的每一節點則是Entry，在Jdk1.8中如果鏈表的大小超過了閥值則會被改造爲樹形結構，所以可以看到圖中HashMap的表現爲數組+鏈表+紅黑樹的形式。樹的引入也是爲了避免hash衝突元素過多時，鏈表結構造成的效率問題。

1.2 源碼理解

1.2.1 重要屬性

	//默認容量
	static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
	//最大容量
	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;
	//桶中結構轉化爲紅黑樹對應的table的最小大小
	static final int MIN_TREEIFY_CAPACITY = 64;
	//存放元素的數組，是2的冪次
	transient Node<K,V>[] table;
	//存放元素具體的值
	transient Set<Map.Entry<K,V>> entrySet;
	//元素數量
	transient int size;
	//臨界值 當實際大小(容量*填充因子)超過臨界值時，會進行擴容
    int threshold;
	//更改map結構的計數器
	transient int modCount;
	//負載因子
	final float loadFactor;

1.2.2 構造器

public HashMap(int initialCapacity, float loadFactor)

	//initialCapacity:初始化容量；loadFactor:負載因子
	public HashMap(int initialCapacity, float loadFactor) {
		//初始容量小於0則會報錯
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //初始容量大於MAXIMUM_CAPACITY最大容量則默認爲MAXIMUM_CAPACITY
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //如果loadFactor小於等於o 或者 loadFactor不是一個number則會報錯
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        //參數校驗完成後賦值，
        this.loadFactor = loadFactor;
        //初始化threshold大小
        this.threshold = tableSizeFor(initialCapacity);
    }
    
    //返回大於輸入參數且最近的2的整數次冪的數
    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)

	public HashMap(int initialCapacity) {
	    // 調用HashMap(int, float)型構造函數
	    this(initialCapacity, DEFAULT_LOAD_FACTOR);
	}

public HashMap()

 	public HashMap() {
 		//初始化負載因子
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
    }

public HashMap(Map<? extends K, ? extends V> m)

	public HashMap(Map<? extends K, ? extends V> m) {
	    // 初始化填充因子
	    this.loadFactor = DEFAULT_LOAD_FACTOR;
	    // 將m中的所有元素添加至HashMap中
	    putMapEntries(m, false);
	}
	
	final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
        	//判斷table是否已經初始化
            if (table == null) {
            	//計算初始化的閾值t
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                //計算得到的t大於閾值，則初始化閾值
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            //如果table已經初始化，並且元素個數大於閾值則進行擴容
            else if (s > threshold)
                resize();
            //將m中所有元素全部添加到HashMap中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

1.2.3 put() / putVal()

	//HashMap對外提供的放入元素的方法是put()方法，put()方法實際是調用putVal()來實現放入元素的操作
	public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
	
	 /**
     * @param hash key的hash值
     * @param key 鍵
     * @param value 鍵對應的值
     * @param onlyIfAbsent 如果是true將不改變已存在的value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //步驟1:如果table還未被初始化，或者table的長度==0則調用resize()方法
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //步驟2:(n - 1) & hash確定元素在哪個桶中，桶如果爲空，新生成Node結點放入桶中
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //如果桶中已經存在該元素
        else {
            Node<K,V> e; K k;
            //步驟3：如果key存在則直接覆蓋value
            //比較桶中第一個元素(數組中的結點)的hash值相等，key相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //步驟4：如果該鏈是紅黑樹，將節點放入樹中
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //步驟5：如果該鏈表是鏈表結構
            else {
                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
                            treeifyBin(tab, hash);
                        break;
                    }
                    //判斷鏈表中結點的key值與插入的元素的key值是否相等
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    //用於遍歷桶中的鏈表，與前面的e = p.next組合，可以遍歷鏈表
                    p = e;
                }
            }
            //找到key值、hash值與插入元素相等的結點
            if (e != null) {
            	//記錄value值
                V oldValue = e.value;
                //onlyIfAbsent爲false或者舊的value等於null，則用新值替換舊值
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //回調
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //結構性修改
        ++modCount;
        //步驟6：超過閥值則擴容
        if (++size > threshold)
            resize();
        //回調
        afterNodeInsertion(evict);
        return null;
    }

存儲流程：

根據key計算得到key.hash = (h = k.hashCode()) ^ (h >>> 16)；
根據key.hash計算得到桶數組的索引index = key.hash & (table.length - 1)
① 如果該位置沒有數據，用該數據新生成一個節點保存新數據，返回null
② 如果該位置有數據且是一個紅黑樹，那麼執行相應的插入 / 更新操作
③ 如果該位置有數據且是一個鏈表，分兩種情況一是該鏈表沒有這個節點，另一個是該鏈表上有這個節點
如果該鏈表沒有這個節點，那麼採用尾插法新增節點保存新數據，返回null；如果該鏈表已經有這個節點了，那麼找到該節點並更新新數據，返回老數據。

1.2.4 get()

	//get value by key
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
	
	 /**
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //table不等於null 並且 table數組長度大於0 並且 根據hash對應的桶的位置不能於null
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //與桶中第一項相等則直接返回第一個Node
            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;
    }

1.2.5 resize

resize方法是在hashmap中的鍵值對大於閥值時或者初始化時，就調用resize方法進行擴容
每次擴展的時候，都是擴展原大小2倍
擴展後Node對象的位置要麼在原位置，要麼移動到原偏移量兩倍的位置

	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) {//如果table不爲空
            if (oldCap >= MAXIMUM_CAPACITY) {//如果原數組容量大於MAXIMUM_CAPACITY，則賦值爲整數的最大閥值
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //如果原數組擴容兩倍小於MAXIMUM_CAPACITY 並且 原數組大於等於初始化容量
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; //雙倍擴容閥值
        }
        else if (oldThr > 0) //table爲空 初始化閥值不爲空
            newCap = oldThr;
        else { 
            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];//根據newCap新建table
        table = newTab;
        if (oldTab != null) { //原table不等於空，則將原元素移到新的table
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {//如果原table j位置節點不爲空
                    oldTab[j] = null;
                    if (e.next == null)//如果e的後面沒有Node節點，則直接對e的hash值對新的數組長度求模獲得存儲位置
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)//如果e節點是紅黑樹的類型，那麼添加到紅黑樹中
                        ((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) {//如果結點e的hash值與原hash桶數組的長度作與運算爲0
	                            if (loTail == null)//如果loTail爲null
	                                loHead = e;//將e結點賦值給loHead
	                            else
	                                loTail.next = e;//否則將e賦值給loTail.next
	                            loTail = e;//然後將e複製給loTail
	                        } else {
	                            if (hiTail == null)//如果hiTail爲null
	                                hiHead = e;//將e賦值給hiHead
	                            else
	                                hiTail.next = e;//如果hiTail不爲空，將e複製給hiTail.next
	                            hiTail = e;//將e複製個hiTail
	                        }
                    	} while ((e = next) != null);//直到e爲空
                    if (loTail != null) {//如果loTail不爲空
                        loTail.next = null;//將loTail.next設置爲空
                        newTab[j] = loHead;//將loHead賦值給新的hash桶數組[j]處
                    }
                    if (hiTail != null) {//如果hiTail不爲空
                        hiTail.next = null;//將hiTail.next賦值爲空
                        newTab[j + oldCap] = hiHead;//將hiHead賦值給新的hash桶數組[j+舊hash桶數組長度]
                    }
                }
            }
        }
        return newTab;
    }

二、總結

HashMap的數據結構
數組+鏈表+紅黑樹結構，數組是一個定長的Entry數組，put時會通過Hash算法進行計算元素的數組下標，在同一個位置有多個元素即Hash衝突時，會將元素加在鏈表的尾部，當鏈表大於8時，會將鏈表轉爲紅黑樹以提升效率。
你知道hash的實現嗎？爲什麼要這樣實現？
在Java 1.8的實現中，是通過hashCode()的高16位異或低16位實現的：(h = k.hashCode()) ^ (h >>> 16)，主要是從速度、功效、質量來考慮的，這麼做可以在bucket的n比較小的時候，也能保證考慮到高低bit都參與到hash的計算中，同時不會有太大的開銷。
如果HashMap的大小超過了負載因子(load factor)定義的容量，怎麼辦？
如果超過了負載因子(默認0.75)，則會重新resize一個原來長度兩倍的HashMap，並且重新調用hash方法。

JDK1.8源碼閱讀一一HashMap

一、HashMap

1.1 內部結構

1.2 源碼理解

1.2.1 重要屬性

1.2.2 構造器

1.2.3 put() / putVal()

1.2.4 get()

1.2.5 resize

二、總結

工作中用到的腳本合集

24-5-18 X

JDK1.8源碼閱讀---ArrayList

JDK1.8源碼閱讀一一HashMap

菜鳥Coder的“初聊”

認識Java裏面的Thread一一線程的中斷機制

Docker搭建Mysql環境

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

linux以太網驅動總結