HashMap(jdk7)原理分析總結

之所以標明“jdk7”，是因爲jdk8和jdk7中的HashMap實現原理不一樣。jdk7中使用“數組+鏈表”形式來實現哈希表，這與數據結構課上所學的一致。而jdk8在它的基礎上，引入了紅黑樹。本博客先從最原始的“數組+鏈表”形式開始總結梳理。

首先在開始之前要有一個基本認識：HashMap是一個對象，對象中包含了一個Entry<K,V>[]數組，即哈希表數組，其中每一項代表一個bucket。鍵值對會按照一定索引順序存儲進bucket中。

哈希與索引的計算

哈希計算的目的在於，當程序獲得一個key時，需要通過計算key的哈希值來得到key的索引值，即在Entry數組中的下標。然後進行增刪改查等操作。

通過如下兩行代碼獲取索引值

int hash = hash(key);
int i = indexFor(hash, table.length);

其中，hash()方法：

final int hash(Object k) {
    int h = hashSeed;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

• 一次哈希：hashCode()是獲取首次散列的哈希值的方法，由k所屬的包裝類實現；
• 二次哈希：上面代碼中有大量的無符號右移以及異或操作。這些操作的目的是，在進行下面indexFor方法時，不至於破壞 h 的特異性。

indexFor方法：

static int indexFor(int h, int length) {
    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
    return h & (length-1);//僅保留h的後半部分，保證不越界
}

首先要說明，length必須是2的次方數。這樣的話，length-1的後n位一定全是1，跟hash值進行與運算之後，相當於只保留hash的右邊n位。

對於一個哈希表來說，往往希望插入的節點在數組中儘量地分散，減少鏈表出現的情況，這樣可以減少衝突。通過以上這些手段，便可最大化鍵與鍵之間哈希值的差異，增強了散列性。

擴容機制

addEntry方法

在put等操作時，若在哈希表中沒有找到對應 key ，需要新建一個新的節點時，會調用此方法。

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);//滿足一定條件時執行擴容操作
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

//將鍵值對放入table中
    createEntry(hash, key, value, bucketIndex);
}

擴容的條件

1. size >= threshold

threshold 是一個決定是否擴容的閾值。根據capacity * loadFactor來決定。如下代碼：

private void inflateTable(int toSize) {
    // Find a power of 2 >= toSize
    int capacity = roundUpToPowerOf2(toSize);

    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

該方法用於初始化哈希數組，並設置threshold。

loadFactor是負載因子，默認值爲0.75

2. null != table[bucketIndex]

當需要插入的位置爲null時，就算超過閾值，也可以無需擴容。在JDK8中沒有這個條件。

resize方法

當滿足條件時，將數組長度擴容至兩倍，執行以下resize方法

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }

    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

transfer方法

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    //遍歷所有節點，轉移到新table上去
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

put操作

瞭解上面所有內容，再來看一個put方法就很簡單了

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    //根據hash值計算索引值
    int i = indexFor(hash, table.length);
    //在該索引值位置順序遍歷鏈表，如果找到目標key就修改，返回
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;//結構發生修改的次數+1
    //進行到這一步說明需要新增一個key-value對
    addEntry(hash, key, value, i);
    return null;
}

addEntry方法中會調用createEntry方法，通過頭插法新建一個結點

void createEntry(int hash, K key, V value, int bucketIndex) {
    //頭插法新建一個結點
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

結點置換的操作十分精妙，本科C語言指針基礎紮實的話很容易理解。
其它的刪除、查詢等操作都大同小異。

其它問題

多線程環境下的問題

當兩個線程同時操作transfer時。若線程A先於線程B完成，B操作中的e和next指針會調頭，因爲是頭插法，導致線程B的transfer循環中兩個節點形成循環鏈表，陷入死循環。

當然，可以在初始化的時候設置容量和負載因子，防止擴容，可避免這個問題

參數設置

兩個影響性能的參數：初始容量、負載因子

不設置默認是16和0.75

• 負載因子過小，或者初始容量過大時，雖然索引效率高，但會造成空間的浪費；影響Collection視圖迭代效率。
• 負載因子過高，可減少空間上的開銷，但是引發哈希衝突概率更高，產生的鏈表可能更長，會增加索引的成本；

因此需要尋求一種“空間效率”與“衝突概率”之間的平衡與折衷。典型的時空矛盾問題。