深刻理解HashMap(三): 關鍵源碼逐行分析之構造函數

前言

系列文章目錄

上一篇咱們說明了HashMap的hash算法, 說到HashMap在構造時會自動將table設爲2的整數次冪.

本篇咱們就來聊聊HashMap的構造函數.

本文的源碼基於 jdk8 版本.

構造函數

HashMap 共有四個構造函數

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

    // 默認初始大小 16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    // 默認負載因子 0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
     
    final float loadFactor;
    
    /**
     * The next size value at which to resize (capacity * load factor).
     *
     * @serial
     */
    // (The javadoc description is true upon serialization.
    // Additionally, if the table array has not been allocated, this
    // field holds the initial array capacity, or zero signifying
    // DEFAULT_INITIAL_CAPACITY.)
    int threshold;
    
    transient Node<K,V>[] table;
     
    // 沒有指定時, 使用默認值
    // 即默認初始大小16, 默認負載因子 0.75
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    
    // 指定初始大小, 但使用默認負載因子
    // 注意這裏實際上是調用了另外一個構造函數
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    
    // 指定初始大小和負載因子
    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);
    }
    
    // 利用已經存在的map建立HashMap
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
        
}

不知道你們發現了沒有, 即便咱們在構造函數中指定了initialCapacity, 這個值也只被用來計算 threshold

this.threshold = tableSizeFor(initialCapacity);

而 threshold 這個值在初始化table時, 就表明了數組的初始大小, 這個咱們到後面用到的時候講.

咱們先來看看tableSizeFor函數幹了什麼事:

/**
 * Returns a power of two size for the given target capacity.
 */
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;
}

tableSizeFor這個方法用於找到大於等於initialCapacity的最小的2的冪, 這個算法仍是很精妙的, 這裏我稍微解釋一下:
咱們知道, 當一個32位整數不爲0時, 32bit中至少有一個位置爲1, 上面5個移位操做的目的在於, 將 從最高位的1開始, 一直到最低位的全部bit 所有設爲1, 最後再加1(注意, 一開始是先cap-1的), 則獲得的數就是大於等於initialCapacity的最小的2的冪. 讀者本身找一個數算一下就明白了, 也能夠參照這一篇博客.

最後咱們來看最後一個構造函數, 它調用了 putMapEntries 方法:

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        if (table == null) { // pre-size
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        else if (s > threshold)
            resize();
        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);
        }
    }
}

咱們知道, 當使用構造函數HashMap(Map<? extends K, ? extends V> m) 時, 咱們並無爲 table 賦值, 因此, table值必定爲null, 咱們先根據傳入Map的大小計算 threshold 值, 而後判斷需不須要擴容, 最後調用 putVal方法將傳入的Map插入table中.

resize 和 putVal 方法咱們之後再細講.

總結

經過上面對四個構造函數的分析咱們發現, 除了最後一個構造函數, 其餘三個函數:

HashMap()
HashMap(int initialCapacity)
HashMap(int initialCapacity, float loadFactor)

的調用中, 最多隻牽涉到HashMap的兩個Field loadFactor, threshold, 而並不牽涉到 table 變量.

這說明HashMap中, table的初始化或者使用不是在構造函數中進行的, 而是在實際用到的時候, 事實上, 它是在HashMap擴容的時候實現的, 即resize函數, 咱們在下一篇文章中討論.

(完)

下一篇: 深刻理解HashMap(四): 關鍵源碼逐行分析之resize

查看更多系列文章：系列文章目錄