JDK1.7 HashMap 源碼分析，jdk1.7hashmap

JDK1.7 HashMap 源碼分析，jdk1.7hashmap
概述

HashMap是Java裡基本的儲存Key、Value的一個資料類型，瞭解它的內部實現，可以幫我們編寫出更高效的Java代碼。

本文主要分析JDK1.7中HashMap實現，JDK1.8中的HashMap已經和這個不一樣了，後面會再總結。

本文HashMap概述

HashMap根據鍵的hashCode值擷取儲存位置，大多數情況下可以直接定位到它的值，因而具有很快的訪問速度，但遍曆順序卻是不確定的。 HashMap最多隻允許一條記錄的鍵為null，允許多條記錄的值為null。HashMap非安全執行緒，即任一時刻可以有多個線程同時寫HashMap，可能會導致資料的不一致。如果需要滿足安全執行緒，可以用 Collections的synchronizedMap方法使HashMap具有安全執行緒的能力，或者使用ConcurrentHashMap。

HashMap的儲存結構如所示：

public V put(K key, V value) { //判斷如果table為空白，則初始化table if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) return putForNullKey(value); //計算key的hash值 int hash = hash(key); //根據key的hash值和table.length計算KEY的位置 int i = indexFor(hash, table.length); //判斷是否有重複的值，若有，則用新值替換舊值，並返回舊值 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; } } //修改的次數加一，用於迭代HashMap時，判斷HashMap元素有沒有修改 modCount++; //添加key addEntry(hash, key, value, i); return null; }inflateTable — 初始化HashMap內部數組

private void inflateTable(int toSize) {    //根據toSize計算容量，即大於toSize的最小的2的n次方    int capacity = roundUpToPowerOf2(toSize);    ………}private static int roundUpToPowerOf2(int number) {    // assert number >= 0 : "number must be non-negative";    return number >= MAXIMUM_CAPACITY            ? MAXIMUM_CAPACITY            : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;}public static int highestOneBit(int i) {    // HD, Figure 3-1    i |= (i >>  1);    i |= (i >>  2);    i |= (i >>  4);    i |= (i >>  8);    i |= (i >> 16);    return i - (i >>> 1);}

關鍵方法Integer.highestOneBit((number - 1) << 1)，這個方法的結果就是求出大於給定數值的，最小的2的N次方。

解釋之前先說明幾個概念：

<< : 按二進位形式把所有的數字向左移動對應的位元，高位移出(捨棄)，低位的空位補零。在數字沒有溢出的前提下，對於正數和負數，左移一位都相當於乘以2的1次方，左移n位就相當於乘以2的n次方；

>>: 按二進位形式把所有的數字向右移動對應位移位元，低位移出(捨棄)，高位的空位補符號位，即正數補零，負數補1。右移一位相當於除2，右移n位相當於除以2的n次方。

>>>: 無符號右移，忽略符號位，空位都以0補齊

 

我們拿數字10做樣本，經過(number - 1) << 1 = 18,二進位表示為：10010

i |= (i >>  1) 即：10010 | 01001 = 11011

i |= (i >>  2) 即：11011 | 00110 = 11111

i |= (i >>  4) 即：11111 | 00001 = 11111

……

其實這幾步就是把i的最高位1之後的所有位都變成1

然後 i – (i >>> 1) 即：11111-01111=10000(16)

這步是把最高位，之後的都變成0，這樣就求出了最接近10的2的N次方（16）

至於為什麼要把數組的Size設定為2的N次方，我們後面說。

hash — 計算Key的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);}

根據上面的注釋，我們可以看出，HashMap中使用的hash值，不是Key直接的hashCode，而是經過一系列計算的。

計算hash值的作用就是避免hash碰撞，盡量減少單向鏈表的產生，因為鏈表中尋找一個元素時間複雜度為O(n)。

indexFor — 計算Key所對應的數組位置

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嗎？其實這裡用了一個非常巧妙的方法來取這個餘數。

在電腦中CPU做除法運算、取餘運算耗費的CPU周期都比較長，一般幾十個CPU周期，而位移運算、位元運算只用一個CPU周期。
這樣對於效能要求高的地方，就可以用位元運算代替普通的除法、取餘等運算，JDK源碼中有很多這樣的例子。

為了能夠使用位元運算求出這個餘數，length必須是2的N次方，這也是我們上面初始化數組大小時要求的，然後使用 h & (length-1)，就可以求出餘數。具體的演算法推導，請自行搜尋。

我們用個例子來說明下，如一個Key經過運算的hash為21，length為16：

直接取餘運算：21 % 16 = 5

位元運算：10101(21) & 01111(16-1) = 00101(5)

哇，這就是電腦運算的魅力，這就是演算法的作用。

addEntry — 添加資料

void addEntry(int hash, K key, V value, int bucketIndex) {    //如果size大於等於threshold，且數組的這個位置不為null，則擴容數組    if ((size >= threshold) && (null != table[bucketIndex])) {        resize(2 * table.length);        hash = (null != key) ? hash(key) : 0;        bucketIndex = indexFor(hash, table.length);    }    createEntry(hash, key, value, bucketIndex);}

threshold：HashMap實際可以儲存的Key的個數，如果size大於threshold，說明HashMap已經太飽和了，非常容易發生hash碰撞，導致單向鏈表的產生。

在inflateTable方法中，我們可以看到

threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);

所以這個值是由HashMap的capacity 和負載因子（loadFactor預設：0.75）計算出來的。

loadFactor越小，相同的capacity就更頻繁地擴容，這樣的好處是HashMap會很大，產生hash碰撞的幾率就更小，但需要的記憶體也更多，這就是所謂的空間換時間。

在這裡也注意，擴容時會直接將原來容量乘以2，滿足了length為2的N次方的條件。

createEntry就不多說了，就是將key、value儲存到數組相應的位置。

GET

final Entry<K,V> getEntry(Object key) {    if (size == 0) {        return null;    }     //用和添加時相同的演算法求出hash值    int hash = (key == null) ? 0 : hash(key);     //直接從數組的響應位置拿到資料，判斷hash相同、key相同，則返回    for (Entry<K,V> e = table[indexFor(hash, table.length)];         e != null;         e = e.next) {        Object k;        if (e.hash == hash &&            ((k = e.key) == key || (key != null && key.equals(k))))            return e;    }    return null;}

擷取時非常簡單，也非常迅速，添加時做的所有工作都是為快速擷取做的工作。

總結

HashMap是一個非常高效的Key、Value資料結構，GET的時間複雜度為：O(1) ~ O(n)，我們在使用HashMap時需要注意以下幾點：

1. 聲明HashMap時最好使用帶initialCapacity的建構函式，傳入資料的最大size，可以避免內部數組resize；
2. 效能要求高的地方，可以將loadFactor設定的小於預設值0.75，使hash值更分散，用空間換取時間；