深度解析HashMap

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);
}
public final int hashCode() {
    return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}複製程式碼

/**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }
複製程式碼

 static int indexFor(int h, int length) {
        return h & (length-1);
    }複製程式碼

        int h=15,length=16;
        System.out.println(h & (length-1));
        System.out.println(Integer.parseInt("0001111", 2) & Integer.parseInt("0001111", 2));
        h=15+16;
        System.out.println(h & (length-1));
        System.out.println(Integer.parseInt("0011111", 2) & Integer.parseInt("0001111", 2));
        h=15+16+16;
        System.out.println(h & (length-1));
        System.out.println(Integer.parseInt("0111111", 2) & Integer.parseInt("0001111", 2));
        h=15+16+16+16;
        System.out.println(h & (length-1));
        System.out.println(Integer.parseInt("1111111", 2) & Integer.parseInt("0001111", 2));
複製程式碼

原始碼分析

HashMap初始化

預設情況下，大多數人都呼叫 HashMap hashMap = new HashMap();來初始化的，我們在這分析newHashMap（int initialCapacity, float loadFactor）的建構函式。

我們都知道在Java中每個物件都有一個hashcode()方法用來返回該物件的 hash值。HashMap先對hashCode進行hash操作，然後再通過hash值進一步計算下標。

程式碼如下：

public HashMap(int initialCapacity, float loadFactor) {
　// initialCapacity代表初始化HashMap的容量，它的最大容量是MAXIMUM_CAPACITY = 1 << 30。
　// loadFactor代表它的負載因子，預設是是DEFAULT_LOAD_FACTOR=0.75，用來計算threshold臨界值的。    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);
}

/**
 * Constructs an empty <tt>HashMap</tt> with the specified initial
 * capacity and the default load factor (0.75).
 *
 * @param  initialCapacity the initial capacity.
 * @throws IllegalArgumentException if the initial capacity is negative.
 */
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * Constructs an empty <tt>HashMap</tt> with the default initial capacity
 * (16) and the default load factor (0.75).
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}複製程式碼

（4）如果HashMap大小超過臨界值，就要重新設定大小，擴容，稍後講解。

附上一張流程圖，這個圖是從別的博主哪裡copy的，感覺畫的不錯。

get操作

我們通過hashMap.get(K key) 來獲取存入的值，key的取值很簡單了。我們通過陣列的index直接找到Entry，然後再遍歷Entry，當hashcode和key都一樣就是我們當初存入的值啦。

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }
複製程式碼

呼叫getEntry(key)拿到entry ,然後返回entry的value,來看getEntry(key)方法

final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : 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;
    }複製程式碼

相比put，get操作就沒這麼多套路，只需要根據key值計算hash值，和陣列長度取模，然後就可以找到在陣列中的位置(key為空同樣單獨操作)，接著就是Entry遍歷，hash相等的情況下，如果key相等就知道了我們想要的值。

再get方法中有null的判斷，null取hash值總是0,再getNullKey(K key)方法中，也是按照遍歷方法來查詢的。

modCount的作用

眾所周知，HashMap不是執行緒安全的，但在某些容錯能力較好的應用中，如果你不想僅僅因為1%的可能性而去承受hashTable的同步開銷，HashMap使用了Fail-Fast機制來處理這個問題，你會發現modCount在原始碼中是這樣宣告的。

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
        table = newTable;
        //步驟④修改閥值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }複製程式碼

    void transfer(Entry[] newTable, boolean rehash) {
        //獲取新陣列的長度
        int newCapacity = newTable.length;
        //遍歷舊陣列中的鍵值對
        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;
            }
        }
    }
複製程式碼