來源：Java集合，HashMap底層實現和原理（1.7數組+鏈表與1.8+的數組+鏈表+紅黑樹）

概述

文章的內容基于JDK1.7進行分析，之所以選用這個版本，是因為1.8的有些類做了改動，增加了閱讀的難度，雖然是1.7，但是對于1.8做了重大改動的內容，文章也會進行說明。

HashMap基于Map接口實現，元素以鍵值對的方式存儲，并且允許使用null 建和null　值，　因為key不允許重復，因此只能有一個鍵為null,另外HashMap不能保證放入元素的順序，它是無序的，和放入的順序并不能相同。HashMap是線程不安全的。

數據結構

繼承關系

public class HashMap<K,V>extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

實現接口

Serializable, Cloneable, Map<K,V> 

基本屬性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默認初始化大小 16 
static final float DEFAULT_LOAD_FACTOR = 0.75f;     //負載因子0.75
static final Entry<?,?>[] EMPTY_TABLE = {};         //初始化的默認數組
transient int size;     //HashMap中元素的數量
int threshold;          //判斷是否需要調整HashMap的容量

代碼有移位運算，不理解請點擊 Java二進制位運算、移位運算>>、<<、>>> 了解。

源碼解析

image

什么是鏈表

鏈表是由一系列非連續的節點組成的存儲結構，簡單分下類的話，鏈表又分為單向鏈表和雙向鏈表，而單向/雙向鏈表又可以分為循環鏈表和非循環鏈表，下面簡單就這四種鏈表進行圖解說明。

1.單向鏈表

單向鏈表就是通過每個結點的指針指向下一個結點從而鏈接起來的結構，最后一個節點的next指向null。

image

2.單向循環鏈表

單向循環鏈表和單向列表的不同是，最后一個節點的next不是指向null，而是指向head節點，形成一個“環”。

image

3.雙向鏈表

從名字就可以看出，雙向鏈表是包含兩個指針的，pre指向前一個節點，next指向后一個節點，但是第一個節點head的pre指向null，最后一個節點的tail指向null。

image

4.雙向循環鏈表

雙向循環鏈表和雙向鏈表的不同在于，第一個節點的pre指向最后一個節點，最后一個節點的next指向第一個節點，也形成一個“環”。而LinkedList就是基于雙向循環鏈表設計的。

image

在進行源碼解析之前，先從總體上對HashMap的數據存儲結構進行一個大體上的說明。

存儲結構如上圖所示。

HashMap采用Entry數組來存儲key-value對，每一個鍵值對組成了一個Entry實體，Entry類實際上是一個單向的鏈表結構，它具有Next指針，可以連接下一個Entry實體，依次來解決Hash沖突的問題，因為HashMap是按照Key的hash值來計算Entry在HashMap中存儲的位置的，如果hash值相同，而key內容不相等，那么就用鏈表來解決這種hash沖突。

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

    //默認初始化的容量
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    //最大的容量
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //負載因子，當容量達到75%時就進行擴容操作
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //當數組還沒有進行擴容操作的時候，共享的一個空表對象
    static final Entry<?,?>[] EMPTY_TABLE = {};

    //table,進行擴容操作，長度必須2的n次方
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

    //Map中包含的元素數量
    transient int size;

    //閾值，用于判斷是否需要擴容（threshold = 容量*負載因子）
    int threshold;

    //加載因子實際的大小
    final float loadFactor;

    //HashMap改變的次數
    transient int modCount;

    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;

    //內部類，通過vm來修改threshold的值
    private static class Holder {

        /**
         * Table capacity above which to switch to use alternative hashing.
         */
        static final int ALTERNATIVE_HASHING_THRESHOLD;

        static {
            String altThreshold = java.security.AccessController.doPrivileged(
                new sun.security.action.GetPropertyAction(
                    "jdk.map.althashing.threshold")); //讀取值

            int threshold;
            try {
                threshold = (null != altThreshold)   //修改值
                        ? Integer.parseInt(altThreshold)
                        : ALTERNATIVE_HASHING_THRESHOLD_DEFAULT;

                // disable alternative hashing if -1
                if (threshold == -1) {
                    threshold = Integer.MAX_VALUE; //設置為Integer能表示的最大值
                }

                if (threshold < 0) {
                    throw new IllegalArgumentException("value must be positive integer.");
                }
            } catch(IllegalArgumentException failed) {
                throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
            }

            ALTERNATIVE_HASHING_THRESHOLD = threshold;  //返回
        }
    }

    //HashCode的初始值為 0 
    transient int hashSeed = 0;

    //構造方法，指定初始容量和負載因子
    public HashMap(int initialCapacity, float loadFactor) {
        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; //設置負載因子
        threshold = initialCapacity; //初始容量
        init(); //不做任何操作
    }

    //構造方法，指定了初始容量
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    //無參構造方法，使用默認的容量大小和負載因子，并調用其他的構造方法
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    //構造函數，參數為指定的Map集合
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
    }
    //選擇合適的容量值，最好是number的2的冪數
    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;
    }

    //擴充表，HashMap初始化時是一個空數組，此方法執行重新復制操作，創建一個新的Entry[]
    private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        int capacity = roundUpToPowerOf2(toSize); //capacity為2的冪數，大于等于toSize

        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];  //新建數組，并重新賦值
        initHashSeedAsNeeded(capacity);  //修改hashSeed 
    }

    // internal utilities

    //初始化
    void init() {
    }

    //與虛擬機設置有關，改變hashSeed的值
    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;
    }

    //計算k 的 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,和表的長度，返回存放的索引
    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);
    }

    //返回Map中鍵值對的數量
    public int size() {
        return size;
    }

    //判斷集合是否為空
    public boolean isEmpty() {
        return size == 0;
    }

    //返回key ，對應的值
    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

    //返回null鍵的值
    private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

    //是否包含鍵為key的元素
    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    //返回鍵為key 的entry實體，不存在返回null
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : hash(key);  //計算key的 hash值
        //定位到Entry[] 數組中的存儲位置，開始遍歷該位置是否有鏈表存在
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //判斷是否有鍵位key 的entry實體。有就返回。
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

      //向map中添加key-value 鍵值對，如果可以包含了key的映射，則舊的value將被替換
    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {  //table如果為空，進行初始化操作
            inflateTable(threshold);
        }
        if (key == null)  //key 為null ,放入數組的0號索引位置
            return putForNullKey(value);
        int hash = hash(key);   //計算key的hash值
        int i = indexFor(hash, table.length);  //計算key在entry數組中存儲的位置
        //判斷該位置是否已經有元素存在
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //判斷key是否已經在map中存在，若存在用新的value替換掉舊的value,并返回舊的value
            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 
        addEntry(hash, key, value, i); //將key-value轉化為Entry實體，添加到Map中
        return null;
    }

    //key = null, 對應的操作，keyweinull ,存放在entry[]中的0號位置。并用新值替換舊值
    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;
    }

    //私有方法，添加元素
    private void putForCreate(K key, V value) {
        int hash = null == key ? 0 : hash(key); //計算hash值
        int i = indexFor(hash, table.length); //計算在HashMap中的存儲位置

        //遍歷i號存儲位置的鏈表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
        //創建Entry實體，存放到i號位置中
        createEntry(hash, key, value, i);
    }
    //將m中的元素添加到HashMap中
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            putForCreate(e.getKey(), e.getValue());
    }

    //擴容操作
    void resize(int newCapacity) {
        Entry[] oldTable = table;     //將table賦值給新的引用
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //創建一個長度為newCapacity的數組
        Entry[] newTable = new Entry[newCapacity];  
        //將table中的元素復制到newTable中
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        //更改閾值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

    //將table中的數據復制到newTable中
    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) { //是否需要重新計算Hash值
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity); //計算存儲的位置
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

    //將m中的元素全部添加到HashMap中
    public void putAll(Map<? extends K, ? extends V> m) {
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0) //為空返回
            return;

        if (table == EMPTY_TABLE) { //是否需要執行初始化操作
            inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold));
        }

        //判斷是否需要擴容
        if (numKeysToBeAdded > threshold) {
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);
        }
        //執行添加操作
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

    //刪除key ,并返回key對應的value值
    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    //返回key對應的實體
    final Entry<K,V> removeEntryForKey(Object key) {
        if (size == 0) {
            return null;
        }
        int hash = (key == null) ? 0 : hash(key); //計算key的hash值
        int i = indexFor(hash, table.length);  //計算存儲位置
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next; //鏈表刪除
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    //刪除一個指定的實體
    final Entry<K,V> removeMapping(Object o) {
        if (size == 0 || !(o instanceof Map.Entry))
            return null;

        Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
        Object key = entry.getKey();
        int hash = (key == null) ? 0 : hash(key);
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            if (e.hash == hash && e.equals(entry)) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    //刪除map
    public void clear() {
        modCount++;
        Arrays.fill(table, null);
        size = 0;
    }

    //判斷是否包含指定value的實體
    public boolean containsValue(Object value) {
        if (value == null)
            return containsNullValue();

        Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (value.equals(e.value))
                    return true;
        return false;
    }

    //是否包含value== null 
    private boolean containsNullValue() {
        Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (e.value == null)
                    return true;
        return false;
    }

    //重寫克隆方法
    public Object clone() {
        HashMap<K,V> result = null;
        try {
            result = (HashMap<K,V>)super.clone();
        } catch (CloneNotSupportedException e) {
            // assert false;
        }
        if (result.table != EMPTY_TABLE) {
            result.inflateTable(Math.min(
                (int) Math.min(
                    size * Math.min(1 / loadFactor, 4.0f),
                    // we have limits...
                    HashMap.MAXIMUM_CAPACITY),
               table.length));
        }
        result.entrySet = null;
        result.modCount = 0;
        result.size = 0;
        result.init();
        result.putAllForCreate(this);

        return result;
    }
    //靜態內部類 ，Entry用來存儲鍵值對，HashMap中的Entry[]用來存儲entry
    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;   //鍵
        V value;        //值
        Entry<K,V> next;  //采用鏈表存儲HashCode相同的鍵值對，next指向下一個entry
        int hash;   //entry的hash值

        //構造方法， 負責初始化entry
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public final int hashCode() {
            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        //當使用相同的key的value被覆蓋時調用
        void recordAccess(HashMap<K,V> m) {
        }

        //每移除一個entry就被調用一次
        void recordRemoval(HashMap<K,V> m) {
        }
    }

    //添加實體
    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);
        }

        createEntry(hash, key, value, bucketIndex);
    }

    //創建實體
    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++;
    }
    //內部類實現Iterator接口，進行遍歷操作
    private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;        // next entry to return
        int expectedModCount;   // For fast-fail
        int index;              // current slot
        Entry<K,V> current;     // current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }
        //是否有下一個元素
        public final boolean hasNext() {
            return next != null;
        }
        //返回下一個元素
        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }
        //刪除
        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

    private final class ValueIterator extends HashIterator<V> {
        public V next() {
            return nextEntry().value;
        }
    }

    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }

    private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() {
            return nextEntry();
        }
    }

    // Subclass overrides these to alter behavior of views' iterator() method
    Iterator<K> newKeyIterator()   {
        return new KeyIterator();
    }
    Iterator<V> newValueIterator()   {
        return new ValueIterator();
    }
    Iterator<Map.Entry<K,V>> newEntryIterator()   {
        return new EntryIterator();
    }

    // Views

    private transient Set<Map.Entry<K,V>> entrySet = null;

    //返回key組成的Set集合
    public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

    private final class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return newKeyIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsKey(o);
        }
        public boolean remove(Object o) {
            return HashMap.this.removeEntryForKey(o) != null;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    //返回Value組成的集合
    public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    private final class Values extends AbstractCollection<V> {
        public Iterator<V> iterator() {
            return newValueIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsValue(o);
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    public Set<Map.Entry<K,V>> entrySet() {
        return entrySet0();
    }

    private Set<Map.Entry<K,V>> entrySet0() {
        Set<Map.Entry<K,V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return newEntryIterator();
        }
        public boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<K,V> e = (Map.Entry<K,V>) o;
            Entry<K,V> candidate = getEntry(e.getKey());
            return candidate != null && candidate.equals(e);
        }
        public boolean remove(Object o) {
            return removeMapping(o) != null;
        }
        public int size() {
            return size;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    //將對象寫入到輸出流中
    private void writeObject(java.io.ObjectOutputStream s)
        throws IOException
    {
        // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();

        // Write out number of buckets
        if (table==EMPTY_TABLE) {
            s.writeInt(roundUpToPowerOf2(threshold));
        } else {
           s.writeInt(table.length);
        }

        // Write out size (number of Mappings)
        s.writeInt(size);

        // Write out keys and values (alternating)
        if (size > 0) {
            for(Map.Entry<K,V> e : entrySet0()) {
                s.writeObject(e.getKey());
                s.writeObject(e.getValue());
            }
        }
    }

    private static final long serialVersionUID = 362498820763181265L;
    //從輸入流中讀取對象
    private void readObject(java.io.ObjectInputStream s)
         throws IOException, ClassNotFoundException
    {
        // Read in the threshold (ignored), loadfactor, and any hidden stuff
        s.defaultReadObject();
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
            throw new InvalidObjectException("Illegal load factor: " +
                                               loadFactor);
        }

        // set other fields that need values
        table = (Entry<K,V>[]) EMPTY_TABLE;

        // Read in number of buckets
        s.readInt(); // ignored.

        // Read number of mappings
        int mappings = s.readInt();
        if (mappings < 0)
            throw new InvalidObjectException("Illegal mappings count: " +
                                               mappings);

        // capacity chosen by number of mappings and desired load (if >= 0.25)
        int capacity = (int) Math.min(
                    mappings * Math.min(1 / loadFactor, 4.0f),
                    // we have limits...
                    HashMap.MAXIMUM_CAPACITY);

        // allocate the bucket array;
        if (mappings > 0) {
            inflateTable(capacity);
        } else {
            threshold = capacity;
        }

        init();  // Give subclass a chance to do its thing.

        // Read the keys and values, and put the mappings in the HashMap
        for (int i = 0; i < mappings; i++) {
            K key = (K) s.readObject();
            V value = (V) s.readObject();
            putForCreate(key, value);
        }
    }

    // These methods are used when serializing HashSets
    int   capacity()     { return table.length; }
    float loadFactor()   { return loadFactor;   }
}

重要方法深度解析

構造方法

HashMap()    //無參構造方法
HashMap(int initialCapacity)  //指定初始容量的構造方法 
HashMap(int initialCapacity, float loadFactor) //指定初始容量和負載因子
HashMap(Map<? extends K,? extends V> m)  //指定集合，轉化為HashMap

HashMap提供了四個構造方法，構造方法中 ，依靠第三個方法來執行的，但是前三個方法都沒有進行數組的初始化操作，即使調用了構造方法，此時存放HaspMap中數組元素的table表長度依舊為0 。在第四個構造方法中調用了inflateTable()方法完成了table的初始化操作，并將m中的元素添加到HashMap中。

添加方法

public V put(K key, V value) {
        if (table == EMPTY_TABLE) { //是否初始化
            inflateTable(threshold);
        }
        if (key == null) //放置在0號位置
            return putForNullKey(value);
        int hash = hash(key); //計算hash值
        int i = indexFor(hash, table.length);  //計算在Entry[]中的存儲位置
        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++;
        addEntry(hash, key, value, i); //添加到Map中
        return null;
}

在該方法中，添加鍵值對時，首先進行table是否初始化的判斷，如果沒有進行初始化（分配空間，Entry[]數組的長度）。然后進行key是否為null的判斷，如果key==null ,放置在Entry[]的0號位置。計算在Entry[]數組的存儲位置，判斷該位置上是否已有元素，如果已經有元素存在，則遍歷該Entry[]數組位置上的單鏈表。判斷key是否存在，如果key已經存在，則用新的value值，替換點舊的value值，并將舊的value值返回。如果key不存在于HashMap中，程序繼續向下執行。將key-vlaue, 生成Entry實體，添加到HashMap中的Entry[]數組中。

addEntry()

/*
 * hash hash值
 * key 鍵值
 * value value值
 * bucketIndex Entry[]數組中的存儲索引
 * / 
void addEntry(int hash, K key, V value, int bucketIndex) {
     if ((size >= threshold) && (null != table[bucketIndex])) {
         resize(2 * table.length); //擴容操作，將數據元素重新計算位置后放入newTable中，鏈表的順序與之前的順序相反
         hash = (null != key) ? hash(key) : 0;
         bucketIndex = indexFor(hash, table.length);
     }

    createEntry(hash, key, value, bucketIndex);
}
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++;
}

添加方法的具體操作，在添加之前先進行容量的判斷，如果當前容量達到了閾值，并且需要存儲到Entry[]數組中，先進行擴容操作，擴充的容量為table長度的2倍。重新計算hash值，和數組存儲的位置，擴容后的鏈表順序與擴容前的鏈表順序相反。然后將新添加的Entry實體存放到當前Entry[]位置鏈表的頭部。
在1.8之前，新插入的元素都是放在了鏈表的頭部位置，但是這種操作在高并發的環境下容易導致死鎖，所以1.8之后，新插入的元素都放在了鏈表的尾部。

獲取方法

public V get(Object key) {
     if (key == null)
         //返回table[0] 的value值
         return getForNullKey();
     Entry<K,V> entry = getEntry(key);

     return null == entry ? null : entry.getValue();
}
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;
}

在get方法中，首先計算hash值，然后調用indexFor()方法得到該key在table中的存儲位置，得到該位置的單鏈表，遍歷列表找到key和指定key內容相等的Entry，返回entry.value值。

刪除方法

public V remove(Object key) {
     Entry<K,V> e = removeEntryForKey(key);
     return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
     if (size == 0) {
         return null;
     }
     int hash = (key == null) ? 0 : hash(key);
     int i = indexFor(hash, table.length);
     Entry<K,V> prev = table[i];
     Entry<K,V> e = prev;

     while (e != null) {
         Entry<K,V> next = e.next;
         Object k;
         if (e.hash == hash &&
             ((k = e.key) == key || (key != null && key.equals(k)))) {
             modCount++;
             size--;
             if (prev == e)
                 table[i] = next;
             else
                 prev.next = next;
             e.recordRemoval(this);
             return e;
         }
         prev = e;
         e = next;
    }

    return e;
}

刪除操作，先計算指定key的hash值，然后計算出table中的存儲位置，判斷當前位置是否Entry實體存在，如果沒有直接返回，若當前位置有Entry實體存在，則開始遍歷列表。定義了三個Entry引用，分別為pre, e ,next。 在循環遍歷的過程中，首先判斷pre 和 e 是否相等，若相等表明，table的當前位置只有一個元素，直接將table[i] = next = null 。若形成了pre -> e -> next 的連接關系，判斷e的key是否和指定的key 相等，若相等則讓pre -> next ,e 失去引用。

總結：

1、實現原理

• HashMap是基于hashing的原理，我們使用put(key, value)存儲對象到HashMap中，使用get(key)從HashMap中獲取對象。
• 當我們給put(key, value)方法傳遞鍵和值時，它先調用key.hashCode()方法，返回的hashCode值，用于找到bucket位置，來儲存Entry對象。
• Map提供了一些常用方法，如keySet()、entrySet()等方法。
  keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一個Set集合，此集合的類型為Map.Entry。
• “如果兩個key的hashcode相同，你如何獲取值對象？”答案：當我們調用get(key)方法，HashMap會使用key的hashcode值，找到bucket位置，然后獲取值對象。
• “如果有兩個值對象，儲存在同一個bucket ？”答案：將會遍歷鏈表直到找到值對象。
• “這時會問因為你并沒有值對象去比較，你是如何確定確定找到值對象的？”答案：找到bucket位置之后，會調用keys.equals()方法，去找到鏈表中正確的節點，最終找到要找的值對象。

完美的回答：

• HashMap基于hashing原理，我們通過put(key,value)和get(key)方法儲存和獲取對象。
• 當儲存對象時，我們將鍵值對傳遞給put(key,value)方法時，它調用鍵對象key的hashCode()方法來計算hashcode，然后找到bucket位置，來儲存值對象value。
• 當獲取對象時，通過key的equals()方法找到正確的鍵值對key-value，然后返回值對象value。
• HashMap使用鏈表來解決碰撞問題，當發生碰撞了，對象將會儲存在鏈表的下一個節點中。
• HashMap在每個鏈表節點中，儲存 鍵值對key-value 對象。
• 當兩個不同的鍵對象key的hashcode相同時，會發生什么？它們會儲存在同一個bucket位置的鏈表中，并通過鍵對象key的equals()方法用來找到鍵值對key-value。

因為HashMap的好處非常多，我曾經在我的應用中使用HashMap作為緩存。因為金融領域非常多的運用Java，也出于性能的考慮，我們會經常用到HashMap和ConcurrentHashMap。

2、底層的數據結構

HashMap的底層主要是基于數組和鏈表來實現的，它之所以有相當快的查詢速度主要是因為它是通過計算散列碼來決定存儲的位置。

• HashMap中主要是通過key的hashCode來計算hash值的，只要hashCode相同，計算出來的hash值就一樣。
• 如果存儲的對象對多了，就有可能不同的對象所算出來的hash值是相同的，這就出現了所謂的hash沖突。
• 學過數據結構的同學都知道，解決hash沖突的方法有很多，HashMap底層是通過鏈表來解決hash沖突的。

補充知識：

• HashMap是基于哈希表的 Map 接口的實現。
• 此實現提供所有可選的映射操作，并允許使用 null 值和 null 鍵。（除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）
• 此類不保證映射的順序，特別是它不保證該順序恒久不變。
• 值得注意的是HashMap不是線程安全的，如果想要線程安全的HashMap，可以通過Collections類的靜態方法synchronizedMap獲得線程安全的HashMap。

Map map = Collections.synchronizedMap(new HashMap());

• HashMap結合了ArrayList與LinkedList兩個實現的優點，雖然HashMap并不會向List的兩種實現那樣，在某項操作上性能較高，但是在基本操作（get 和 put）上具有穩定的性能。

JDK 1.8的 改變

在Jdk1.8中HashMap的實現方式做了一些改變，但是基本思想還是沒有變得，只是在一些地方做了優化，下面來看一下這些改變的地方,數據結構的存儲由數組+鏈表的方式，變化為數組+鏈表+紅黑樹的存儲方式，在性能上進一步得到提升。

數據存儲方式

image

put方法簡單解析

public V put(K key, V value) {
    //調用putVal()方法完成
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //判斷table是否初始化，否則初始化操作
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //計算存儲的索引位置，如果沒有元素，直接賦值
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        //節點若已經存在，執行賦值操作
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //判斷鏈表是否是紅黑樹
        else if (p instanceof TreeNode)
            //紅黑樹對象操作
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //為鏈表，
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //鏈表長度8，將鏈表轉化為紅黑樹存儲
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //key存在，直接覆蓋
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //記錄修改次數
    ++modCount;
    //判斷是否需要擴容
    if (++size > threshold)
        resize();
    //空操作
    afterNodeInsertion(evict);
    return null;
}

總結

• HashMap采用hash算法來決定Map中key的存儲，并通過hash算法來增加集合的大小。
• hash表里可以存儲元素的位置稱為桶（bucket），如果通過key計算hash值發生沖突時，那么將采用鏈表的形式，來存儲元素。
• HashMap的擴容操作是一項很耗時的任務，所以如果能估算Map的容量，最好給它一個默認初始值，避免進行多次擴容。
• HashMap的線程是不安全的，多線程環境中推薦是ConcurrentHashMap。

1、實現原理

• HashMap是基于hashing的原理，我們使用put(key, value)存儲對象到HashMap中，使用get(key)從HashMap中獲取對象。
• 當我們給put(key, value)方法傳遞鍵和值時，它先調用key.hashCode()方法，返回的hashCode值，用于找到bucket位置，來儲存Entry對象。
• Map提供了一些常用方法，如keySet()、entrySet()等方法。
  keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一個Set集合，此集合的類型為Map.Entry。
• “如果兩個key的hashcode相同，你如何獲取值對象？”答案：當我們調用get(key)方法，HashMap會使用key的hashcode值，找到bucket位置，然后獲取值對象。
• “如果有兩個值對象，儲存在同一個bucket ？”答案：將會遍歷鏈表直到找到值對象。
• “這時會問因為你并沒有值對象去比較，你是如何確定確定找到值對象的？”答案：找到bucket位置之后，會調用keys.equals()方法，去找到鏈表中正確的節點，最終找到要找的值對象。

完美的回答：

• HashMap基于hashing原理，我們通過put(key,value)和get(key)方法儲存和獲取對象。
• 當儲存對象時，我們將鍵值對傳遞給put(key,value)方法時，它調用鍵對象key的hashCode()方法來計算hashcode，然后找到bucket位置，來儲存值對象value。
• 當獲取對象時，通過key的equals()方法找到正確的鍵值對key-value，然后返回值對象value。
• HashMap使用鏈表來解決碰撞問題，當發生碰撞了，對象將會儲存在鏈表的下一個節點中。
• HashMap在每個鏈表節點中，儲存 鍵值對key-value 對象。
• 當兩個不同的鍵對象key的hashcode相同時，會發生什么？它們會儲存在同一個bucket位置的鏈表中，并通過鍵對象key的equals()方法用來找到鍵值對key-value。

因為HashMap的好處非常多，我曾經在我的應用中使用HashMap作為緩存。因為金融領域非常多的運用Java，也出于性能的考慮，我們會經常用到HashMap和ConcurrentHashMap。

2、底層的數據結構

HashMap的底層主要是基于數組和鏈表來實現的，它之所以有相當快的查詢速度主要是因為它是通過計算散列碼來決定存儲的位置。

• HashMap中主要是通過key的hashCode來計算hash值的，只要hashCode相同，計算出來的hash值就一樣。
• 如果存儲的對象對多了，就有可能不同的對象所算出來的hash值是相同的，這就出現了所謂的hash沖突。
• 學過數據結構的同學都知道，解決hash沖突的方法有很多，HashMap底層是通過鏈表來解決hash沖突的。

補充知識：

• HashMap是基于哈希表的 Map 接口的實現。
• 此實現提供所有可選的映射操作，并允許使用 null 值和 null 鍵。（除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）
• 此類不保證映射的順序，特別是它不保證該順序恒久不變。
• 值得注意的是HashMap不是線程安全的，如果想要線程安全的HashMap，可以通過Collections類的靜態方法synchronizedMap獲得線程安全的HashMap。

Map map = Collections.synchronizedMap(new HashMap());

• HashMap結合了ArrayList與LinkedList兩個實現的優點，雖然HashMap并不會向List的兩種實現那樣，在某項操作上性能較高，但是在基本操作（get 和 put）上具有穩定的性能。