一、HashMap基本原理
HashMap採用Entry陣列來儲存key-value對，每一個鍵值對組成了一個Entry實體，Entry類實際上是一個單向的連結串列結構，它具有Next指標，可以連線下一個Entry實體，依次來解決Hash衝突的問題，因為HashMap是按照Key的hash值來計算Entry在HashMap中儲存的位置的，如果hash值相同，而key內容不相等，就用連結串列來解決這種hash衝突。

二、HashMap原始碼分析

本文以JDK7原始碼分析一下HashMap的關鍵程式碼。

 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;
    }

Integer.highestOneBit方法的作用是二進位制位除最左面為1的位之外全部置為0的值。
roundUpToPowerOf2方法的作用是取比給定值稍大的2的次冪。
至於這裡為什麼要取2的次冪，原因如下：
（1）浪費空間
（2）減低查詢效率
 舉例：    
 當陣列長度為15時，新增陣列時h & (length-1)計算成為hash&14（0x1110）,那麼最後一位永遠是0，從而造成table陣列中 1（0x0001），3（0x0011），5（0x0101），7（0x0111），9（0x1001），11（0x1011）等位置永遠不可以存放資料，從而造成空間浪費；更糟的是這種情況中，陣列可以使用的位置比陣列長度小了很多，這意味著進一步增加了碰撞的機率，單個桶裡儲存的資料多，從而減慢了查詢的效率。
 

 /**
     * Initialize the hashing mask value. We defer initialization until we
     * really need it.
     */
    final boolean initHashSeedAsNeeded(int capacity) {
        boolean currentAltHashing = hashSeed != 0;
        boolean useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean
 
 switching = currentAltHashing ^ useAltHashing;
        if (switching) {
            hashSeed = useAltHashing
                ? sun.misc.Hashing.randomHashSeed(this)
                : 0;
        }
        return switching;
    }

 用指定初始容量和指定載入因子構造一個新的空雜湊表。其中initHashSeedAsNeeded方法用於初始化hashSeed引數，其中hashSeed用於計算key的hash值，它與key的hashCode進行按位異或運算。這個hashSeed是一個與例項相關的隨機值，主要用於解決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);
    }

   因為length為2的指數倍，所以length-1所對應的二進位制位都為1，然後在與hashCode(key)做與運算，即可得到[0,length)內的索引，但是這裡有個問題，如果hashCode(key)的大於length的值，而且hashCode(key)的二進位制位的低位變化不大，那麼衝突就會很多。造成衝突的原因關鍵在於16限制了只能用低位來計算，高位直接捨棄了，所以我們需要額外的雜湊函式而不只是簡單的物件的hashCode方法了。具體來說，就是HashMap中hash函式乾的事了。

  /**
     * 返回hashcode=h的索引位置.
     */
    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);
    }

    /**
     * 根據key查詢entry，從程式碼可以看出key=null是合法的
     */
    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;
    }

    /**
     * 
     */
    public V put(K key, V value) {
        //判斷陣列table是否為空
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        //如果key為空呼叫putForNullKey方法新增鍵為null的entry
        if (key == null)
            return putForNullKey(value);
        //得到key的hash值
        int hash = hash(key);
        //根據上面得到的hash值得到應該放到table中的位置
        int i = indexFor(hash, table.length);
        //遍歷i位置的連結串列
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //判斷i位置是否存在相同的key的entry，存在則用新值替換老的值
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        //如果走到這裡，說明map中不存在鍵為key的entry
        addEntry(hash, key, value, i);
        return null;
    }

    void addEntry(int hash, K key, V value, int bucketIndex) {
        // 如果當前table的大小大於閾值且當前位置的桶有資料，則對map進行擴容到原來的2倍
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            //擴容後重新計算key的hash值和應放置的位置
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        //根據傳入的引數建立一個新的entry放置在位置bucketIndex處
        createEntry(hash, key, value, bucketIndex);
    }

    void createEntry(int hash, K key, V value, int bucketIndex) {
        //先取出位置bucketIndex處的entry，這裡是位置bucketIndex處連結串列的頭結點
        Entry<K,V> e = table[bucketIndex];
        //把新建的entry放置到位置bucketIndex處作為該處連結串列的頭結點，並把此處原來的entry設定為         
        //新entry的後繼節點，也就是說每插入一個新值，都會放到連結串列的最前端。
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

    /**
     * 插null值，從程式碼可以看出，null值全部被插到第一個桶裡面，而且只能插入一個key為null的資料
     * 後面key為null的資料不會被插入
     */
    private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }