在Java編碼中可以說HashMap的使用是可以說是無處不在的，對於HashMap的實現原理沒有去過多深入學習，一直停留在使用階段。現在想來還是要一探HashMap的實現原理，不要一味的只是停留在使用階段。而且HashMap的原理在很多面試中都會問到哦，所以弄清楚還是很有必要滴。

先來看看HashMap的建構函式，一共提供了4中
HashMap(Map m)指定 Map 相同的新 HashMap
HashMap(int initialCapacity, float loadFactor)//指定初始容量，構造因子
HashMap(int initialCapacity)//指定初始容量，構造因子是預設的0.75
HashMap()//初始容量是16，構造因子預設是0.75

下面在分別來看裡面幾個最常用的方法put（k，v）

 public V put(K key, V value) {
        //如果table陣列為空，就建立table陣列
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        //hashmap是支援null值的
        if (key == null)
            return putForNullKey(value);
        //計算出key的hash值
        int
 
 hash = hash(key);
        得到在table陣列中的下標
        int i = indexFor(hash, table.length);
        //通過這塊可以看出HashMap的儲存結構是陣列+連結串列
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果元素hash值相同&&key值也相同，新put的value覆蓋oldvalue
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value
 
;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        //key值不等，通過addEntry新增
        addEntry(hash, key, value, i);
        return null;
    }

這上面就是put（k,v）儲存鍵值對的流程，這裡面的鍵值對，是通過Entry來存放，一個Entry對應一個鍵值對。
Entry有key，value，next，hash這幾個屬性

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next; //為了解決雜湊衝突
        int hash;
 }

現在我們可以大致的畫出HashMap中元素儲存的方式

就是table陣列+連結串列，後面的連結串列是為了解決hash衝突.

//計算出每一個鍵值對Entry在table陣列的下標值。
//這裡的註釋寫明陣列的長度必須是2的冪次方，這裡寫明為什麼是2的冪次方？
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);
    }

上面indexfor中length引數指明要2的冪次方，這裡說點我的理解。通過indexfor就算出的bucketid必須是要儘可能少的出現衝突，2^n-1用二進位制表示的話都是111111……11串，這樣去與hash值進行與運算的話，出現的衝突是最小的，因為如果去與含有0的二進位制串與，必定會出現陣列中有的下標肯定不會用到. 這裡肯定會想如果只是進行低位的運算，那hash值高位沒有參與運算。這個其實是在hash（）裡面得到處理了的。這裡獲取物件的hash值並不是直接獲取物件的hashcode，而是對物件進行二次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即使提供capacity讓我們指定引數，真正的hashmap在構造時都將陣列的長度設定為2的冪次方

    int capacity = 1;  
    while (capacity < initialCapacity)   
         capacity <<= 1;  

如果key值不相等，新增entry到陣列

 void addEntry(int hash, K key, V value, int bucketIndex) {
     //這裡的threshold是capacity*loadFactor就是hash表中儲存元素的極值。如果大於這個值，hash會擴容
        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);
    }

上面說到的是往集合裡面去put鍵值對，同樣有存入就會有獲取，再來看看get（Object key）如何獲取值

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        //通過key獲取Entry
        Entry<K,V> entry = getEntry(key);
        //通過Entry獲取value
        return null == entry ? null : entry.getValue();
    }

上面的get方法寫的簡單，主要是通過key獲取對應的鍵值對，再通過Entry獲取對應的值

 final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }
        //獲取key的hash值
        int hash = (key == null) ? 0 : hash(key);
        //通過hash值找到bucketId,開始遍歷table陣列中bucketId下標對應的元素的列表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //如果hash值相同，並且key值也相同，返回Entry
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

上面對HashMap的存值和取值有了個初步的認識。
我們知道HashMap是支援null值null鍵的，下面就來看看null值是怎樣儲存的^-^

 private V putForNullKey(V value) {
        //在呼叫這個方法之前，會判斷key是否為null，為null就執行這個方法了。
        //從這裡可以看出key為null的的entry是存放在table陣列的第0個下標中。
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            //如果再存放一個key為null的值，那麼把之前的value覆蓋掉
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

我們經常會說HashMap是執行緒不安全的，但是HashTable是執行緒安全的。那就從它們程式碼的實現方式看看HashMap為啥是執行緒不安全的
下面是HashTable實現存放元素的方法，注意這個方法是加了synchronized的，說明這個方法是執行緒安全的，而我們上面看的HashMap方法並沒有加Synchronized，如果在多執行緒情況下，同時對HashMap進行put元素時，如果兩個元素key值的Hash值相同，這時會有避免Hash衝突，會在table陣列的對應節點的連結串列進行元素插入，如果這個兩個元素取到的相同的節點，必定會有一個數據會丟失。

如果當多個執行緒都檢查到需要進行resize，那麼會各自生成一個新的陣列並rehash後賦給該map底層的陣列table，最後只有最後一個執行緒生成的新陣列被賦給table陣列，其他執行緒的均會丟失。如果當某些執行緒已經完成賦值而其他執行緒剛開始的時候，就會用已經被賦值的table作為原始陣列，從而也會導致問題

//HashTable 中put實現方式
public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }

        modCount++;
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            rehash();

            tab = table;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        Entry<K,V> e = tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
        return null;
    }