此文已經(jīng)同步至個人站點博客，點擊下方鏈接可以體驗更加閱讀模式：《java題庫》

HashMap是通過"拉鏈法"實現(xiàn)的哈希表。它包括幾個重要的成員變量：table, size, threshold, loadFactor, modCount厌均。

• table是一個Entry[]數(shù)組類型航夺，而Entry實際上就是一個單向鏈表莺匠。哈希表的"key-value鍵值對"都是存儲在Entry數(shù)組中的闻丑。
• size是HashMap的大小，它是HashMap保存的鍵值對的數(shù)量众羡。
• threshold是HashMap的閾值侨赡，用于判斷是否需要調(diào)整HashMap的容量。threshold的值="容量*加載因子"纱控，當HashMap中存儲數(shù)據(jù)的數(shù)量達到threshold時辆毡，就需要將HashMap的容量加倍。
• loadFactor就是加載因子甜害。
• modCount是用來實現(xiàn)fail-fast機制的舶掖。

1.Map 接口提供了哪些不同的集合視圖?

Map接口提供三個集合視圖：

• Set keyset()：返回map中包含的所有key的一個Set視圖。集合是受map支持的尔店，map的變化會在集合中反映出來眨攘，反之亦然。當一個迭代器正在遍歷一個集合時嚣州，若map被修改了（除迭代器自身的移除操作以外）鲫售，迭代器的結(jié)果會變?yōu)槲炊x。集合支持通過Iterator的Remove该肴、Set.remove情竹、removeAll、retainAll和clear操作進行元素移除匀哄，從map中移除對應(yīng)的映射秦效。它不支持add和addAll操作雏蛮。
• Collection values()：返回一個map中包含的所有value的一個Collection視圖。這個collection受map支持的阱州，map的變化會在collection中反映出來挑秉，反之亦然。當一個迭代器正在遍歷一個collection時苔货，若map被修改了（除迭代器自身的移除操作以外）犀概，迭代器的結(jié)果會變?yōu)槲炊x。集合支持通過Iterator的Remove夜惭、Set.remove姻灶、removeAll、retainAll和clear操作進行元素移除诈茧，從map中移除對應(yīng)的映射木蹬。它不支持add和addAll操作。
• Set<Map.Entry<K,V>> entrySet()：返回一個map鐘包含的所有映射的一個集合視圖若皱。這個集合受map支持的，map的變化會在collection中反映出來尘颓，反之亦然走触。當一個迭代器正在遍歷一個集合時，若map被修改了（除迭代器自身的移除操作疤苹，以及對迭代器返回的entry進行setValue外）互广，迭代器的結(jié)果會變?yōu)槲炊x。集合支持通過Iterator的Remove卧土、Set.remove惫皱、removeAll、retainAll和clear操作進行元素移除尤莺，從map中移除對應(yīng)的映射旅敷。它不支持add和addAll操作。

2.為什么 Map 接口不繼承 Collection 接口?

Collection是最基本的集合接口颤霎，一個Collection代表一組Object媳谁，即Collection的元素。一些Collection允許相同的元素而另一些不行友酱。一些能排序而另一些不行晴音。注意：Map沒有繼承Collection接口，Map提供key到value的映射缔杉。一個Map中不能包含相同key锤躁，每個key只能映射一個value。Map接口提供3種集合的視圖或详，Map的內(nèi)容可以被當做一組key集合系羞，一組value集合郭计，或者一組key-value映射。如果Map繼承Collection接口觉啊，那么元素去哪兒拣宏？Map包含key-value對，它提供抽取key或value列表集合的方法杠人，但是它不適合“一組對象”規(guī)范勋乾。

3.HashMap的工作原理是什么?內(nèi)部的數(shù)據(jù)結(jié)構(gòu)是什么?

HashMap基于hashing原理，我們通過put()和get()方法儲存和獲取對象嗡善。當我們將鍵值對傳遞給put()方法時辑莫，它調(diào)用鍵對象的hashCode()方法來計算hashcode，讓后找到bucket位置來儲存值對象各吨。當獲取對象時，通過鍵對象的equals()方法找到正確的鍵值對袁铐，然后返回值對象揭蜒。HashMap使用鏈表來解決碰撞問題，當發(fā)生碰撞了剔桨，對象將會儲存在鏈表的下一個節(jié)點中屉更。HashMap在每個鏈表節(jié)點中儲存鍵值對對象。
當兩個不同的鍵對象的hashcode相同時會發(fā)生什么洒缀？ 它們會儲存在同一個bucket位置的鏈表中瑰谜。鍵對象的equals()方法用來找到鍵值對。
HashMap采取數(shù)組加鏈表的存儲方式來實現(xiàn)树绩。亦即數(shù)組（散列桶）中的每一個元素都是鏈表萨脑，如下圖：

HashMap的數(shù)組+鏈表結(jié)構(gòu)

《Java 集合系列10之 HashMap詳細介紹(源碼解析)和使用示例》

3.HashMap 的 table的容量如何確定瘫俊？loadFactor 是什么蛛芥？ 該容量如何變化？這種變化會帶來什么問題军援？

HashMap實例中table的length是在初始化時就被指定的仅淑，無論采用默認值還是其他指定值，table數(shù)組的大小就已經(jīng)確定胸哥，隨著添加元素的增多在一定時機下下會對table數(shù)組進行擴容呢涯竟。文末附詳細源碼，此處摘選涉及源碼：

    // 默認的初始容量是16，必須是2的冪庐船。
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    // 最大容量（必須是2的冪且小于2的30次方银酬，傳入容量過大將被這個值替換）
    static final int MAXIMUM_CAPACITY = 1 << 30;

    // 默認加載因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    // 默認構(gòu)造函數(shù)。
    public HashMap() {
        // 設(shè)置“加載因子”
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        // 設(shè)置“HashMap閾值”筐钟，當HashMap中存儲數(shù)據(jù)的數(shù)量達到threshold時揩瞪，就需要將HashMap的容量加倍。
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        // 創(chuàng)建Entry數(shù)組篓冲，用來保存數(shù)據(jù)
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

     // 指定“容量大小”的構(gòu)造函數(shù)
     public HashMap(int initialCapacity) {
         this(initialCapacity, DEFAULT_LOAD_FACTOR);
     }

loadFactor就是加載因子李破。HashMap的實例有兩個參數(shù)影響其性能：“初始容量” 和 “加載因子”。容量是哈希表中桶的數(shù)量壹将，初始容量只是哈希表在創(chuàng)建時的容量嗤攻，加載因子是哈希表在其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數(shù)超出了加載因子與當前容量的乘積時诽俯，則要對該哈希表進行rehash操作（即重建內(nèi)部數(shù)據(jù)結(jié)構(gòu)）妇菱，從而哈希表將具有大約兩倍的桶數(shù)。

4.HashMap 實現(xiàn)的數(shù)據(jù)結(jié)構(gòu)是什么暴区？如何實現(xiàn)闯团？

HashMap是通過拉鏈法實現(xiàn)的散列表。表現(xiàn)在HashMap包括許多的Entry仙粱，而每一個Entry本質(zhì)上又是一個單向鏈表偷俭。

拉鏈法散列表

HashMap的數(shù)據(jù)結(jié)構(gòu)，在JDK8之前缰盏，是數(shù)組+鏈表。在JDK8后中淹遵，當長度大于8的時候口猜，會自動變成數(shù)組+紅黑樹。

5.HashMap 和 HashTable透揣、ConcurrentHashMap 的區(qū)別

我們知道Hashtable是synchronized的济炎，但是ConcurrentHashMap同步性能更好，因為它僅僅根據(jù)同步級別對map的一部分進行上鎖辐真。ConcurrentHashMap當然可以代替HashTable须尚，但是HashTable提供更強的線程安全性∈淘郏看看這篇博客查看Hashtable和ConcurrentHashMap的區(qū)別耐床。

6.HashMap的遍歷方式及效率

1.遍歷HashMap的鍵值對

• 根據(jù)entrySet()獲取HashMap的“鍵值對”的Set集合。
• 通過Iterator迭代器遍歷“第一步”得到的集合楔脯。

// 假設(shè)map是HashMap對象
// map中的key是String類型撩轰，value是Integer類型
Integer integ = null;
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
    Map.Entry entry = (Map.Entry)iter.next();
    // 獲取key
    key = (String)entry.getKey();
        // 獲取value
    integ = (Integer)entry.getValue();
}

2.遍歷HashMap的鍵

• 根據(jù)keySet()獲取HashMap的“鍵”的Set集合。
• 通過Iterator迭代器遍歷“第一步”得到的集合。

// 假設(shè)map是HashMap對象
// map中的key是String類型堪嫂，value是Integer類型
String key = null;
Integer integ = null;
Iterator iter = map.keySet().iterator();
while (iter.hasNext()) {
        // 獲取key
    key = (String)iter.next();
        // 根據(jù)key偎箫，獲取value
    integ = (Integer)map.get(key);
}

3. 遍歷HashMap的值

• 根據(jù)value()獲取HashMap的“值”的集合。
• 通過Iterator迭代器遍歷“第一步”得到的集合皆串。

// 假設(shè)map是HashMap對象
// map中的key是String類型淹办，value是Integer類型
Integer value = null;
Collection c = map.values();
Iterator iter= c.iterator();
while (iter.hasNext()) {
    value = (Integer)iter.next();
}

7.HashMap、LinkedMap恶复、TreeMap的區(qū)別

（1）HashMap是一個最常用的Map怜森，它根據(jù)鍵的hashCode值存儲數(shù)據(jù)，根據(jù)鍵可以直接獲取它的值寂玲，具有很快的訪問速度塔插。HashMap最多只允許一條記錄的鍵為null，不允許多條記錄的值為null拓哟。HashMap不支持線程的同步想许，即任一時刻可以有多個線程同時寫HashMap，可能會導致數(shù)據(jù)的不一致断序。如果需要同步流纹，可以用Collections.synchronizedMap(HashMap map)方法使HashMap具有同步的能力。
（2）Hashtable與HashMap類似违诗，不同的是：它不允許記錄的鍵或者值為空漱凝；它支持線程的同步，即任一時刻只有一個線程能寫Hashtable诸迟，然而茸炒，這也導致了Hashtable在寫入時會比較慢。
（3）LinkedHashMap保存了記錄的插入順序阵苇，在用Iteraor遍歷LinkedHashMap時壁公，先得到的記錄肯定是先插入的。在遍歷的時候會比HashMap慢绅项。有HashMap的全部特性紊册。
（4）TreeMap能夠把它保存的記錄根據(jù)鍵排序，默認是按升序排序快耿，也可以指定排序的比較器囊陡。當用Iteraor遍歷TreeMap時，得到的記錄是排過序的掀亥。TreeMap的鍵和值都不能為空撞反。

8.如何決定選用HashMap還是TreeMap

TreeMap取出來的是排序后的鍵值對。但如果您要按自然順序或自定義順序遍歷鍵搪花，那么TreeMap會更好痢畜。LinkedHashMap 是HashMap的一個子類垛膝，如果需要輸出的順序和輸入的相同，考慮此丁稀。

9.如果HashMap的大小超過了負載因子(load factor)定義的容量吼拥，怎么辦？

上文已經(jīng)說過了线衫，再次補充：HashMap 的實例有兩個參數(shù)影響其性能：“初始容量” 和 “加載因子”凿可。容量是哈希表中桶的數(shù)量，初始容量 只是哈希表在創(chuàng)建時的容量授账。加載因子 是哈希表在其容量自動增加之前可以達到多滿的一種尺度枯跑。當哈希表中的條目數(shù)超出了加載因子與當前容量的乘積時，則要對該哈希表進行 rehash 操作（即重建內(nèi)部數(shù)據(jù)結(jié)構(gòu)）白热，從而哈希表將具有大約兩倍的桶數(shù)敛助。
通常，默認加載因子是0.75, 這是在時間和空間成本上尋求一種折衷屋确。加載因子過高雖然減少了空間開銷纳击，但同時也增加了查詢成本（在大多數(shù) HashMap類的操作中，包括 get和put操作攻臀，都反映了這一點）焕数。在設(shè)置初始容量時應(yīng)該考慮到映射中所需的條目數(shù)及其加載因子，以便最大限度地減少 rehash操作次數(shù)刨啸。如果初始容量大于最大條目數(shù)除以加載因子堡赔，則不會發(fā)生 rehash操作。

10.HashMap 是線程安全的嗎设联？并發(fā)下使用的 Map 是什么善已，它們內(nèi)部原理分別是什么，比如存儲方式离例、 hashcode换团、擴容、 默認容量等

HashMap 的實現(xiàn)不是同步的粘招，這意味著它不是線程安全的。它的key偎球、value都可以為null洒扎。此外，HashMap中的映射不是有序的衰絮。

11.如果兩個鍵的hashcode相同袍冷，你如何獲取值對象？

當我們調(diào)用get()方法猫牡，HashMap會使用鍵對象的hashcode找到bucket位置胡诗，然后獲取值對象。面試官提醒他如果有兩個值對象儲存在同一個bucket，他給出答案:將會遍歷鏈表直到找到值對象煌恢。面試官會問因為你并沒有值對象去比較骇陈，你是如何確定確定找到值對象的？除非面試者直到HashMap在鏈表中存儲的是鍵值對瑰抵，否則他們不可能回答出這一題你雌。
其中一些記得這個重要知識點的面試者會說，找到bucket位置之后二汛，會調(diào)用keys.equals()方法去找到鏈表中正確的節(jié)點婿崭，最終找到要找的值對象。完美的答案肴颊！
許多情況下氓栈，面試者會在這個環(huán)節(jié)中出錯，因為他們混淆了hashCode()和equals()方法婿着。因為在此之前hashCode()屢屢出現(xiàn)授瘦，而equals()方法僅僅在獲取值對象的時候才出現(xiàn)。一些優(yōu)秀的開發(fā)者會指出使用不可變的祟身、聲明作final的對象奥务，并且采用合適的equals()和hashCode()方法的話，將會減少碰撞的發(fā)生袜硫，提高效率氯葬。不可變性使得能夠緩存不同鍵的hashcode，這將提高整個獲取對象的速度婉陷，使用String帚称，Interger這樣的wrapper類作為鍵是非常好的選擇。

HashMap源碼分析

package java.util;
import java.io.*;

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

    // 默認的初始容量是16，必須是2的冪限书。
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    // 最大容量（必須是2的冪且小于2的30次方剿干，傳入容量過大將被這個值替換）
    static final int MAXIMUM_CAPACITY = 1 << 30;

    // 默認加載因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    // 存儲數(shù)據(jù)的Entry數(shù)組，長度是2的冪楼吃。
    // HashMap是采用拉鏈法實現(xiàn)的，每一個Entry本質(zhì)上是一個單向鏈表
    transient Entry[] table;

    // HashMap的大小妄讯，它是HashMap保存的鍵值對的數(shù)量
    transient int size;

    // HashMap的閾值孩锡，用于判斷是否需要調(diào)整HashMap的容量（threshold = 容量*加載因子）
    int threshold;

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

    // HashMap被改變的次數(shù)
    transient volatile int modCount;

    // 指定“容量大小”和“加載因子”的構(gòu)造函數(shù)
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        // HashMap的最大容量只能是MAXIMUM_CAPACITY
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // 找出“大于initialCapacity”的最小的2的冪
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        // 設(shè)置“加載因子”
        this.loadFactor = loadFactor;
        // 設(shè)置“HashMap閾值”，當HashMap中存儲數(shù)據(jù)的數(shù)量達到threshold時亥贸，就需要將HashMap的容量加倍躬窜。
        threshold = (int)(capacity * loadFactor);
        // 創(chuàng)建Entry數(shù)組，用來保存數(shù)據(jù)
        table = new Entry[capacity];
        init();
    }


    // 指定“容量大小”的構(gòu)造函數(shù)
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    // 默認構(gòu)造函數(shù)炕置。
    public HashMap() {
        // 設(shè)置“加載因子”
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        // 設(shè)置“HashMap閾值”荣挨，當HashMap中存儲數(shù)據(jù)的數(shù)量達到threshold時男韧，就需要將HashMap的容量加倍。
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        // 創(chuàng)建Entry數(shù)組默垄，用來保存數(shù)據(jù)
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

    // 包含“子Map”的構(gòu)造函數(shù)
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        // 將m中的全部元素逐個添加到HashMap中
        putAllForCreate(m);
    }

    static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    // 返回索引值
    // h & (length-1)保證返回值的小于length
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    // 獲取key對應(yīng)的value
    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        // 獲取key的hash值
        int hash = hash(key.hashCode());
        // 在“該hash值對應(yīng)的鏈表”上查找“鍵值等于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.equals(k)))
                return e.value;
        }
        return null;
    }

    // 獲取“key為null”的元素的值
    // HashMap將“key為null”的元素存儲在table[0]位置此虑！
    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

    // HashMap是否包含key
    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    // 返回“鍵為key”的鍵值對
    final Entry<K,V> getEntry(Object key) {
        // 獲取哈希值
        // HashMap將“key為null”的元素存儲在table[0]位置，“key不為null”的則調(diào)用hash()計算哈希值
        int hash = (key == null) ? 0 : hash(key.hashCode());
        // 在“該hash值對應(yīng)的鏈表”上查找“鍵值等于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;
    }

    // 將“key-value”添加到HashMap中
    public V put(K key, V value) {
        // 若“key為null”厕倍，則將該鍵值對添加到table[0]中寡壮。
        if (key == null)
            return putForNullKey(value);
        // 若“key不為null”，則計算該key的哈希值讹弯，然后將其添加到該哈希值對應(yīng)的鏈表中况既。
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 若“該key”對應(yīng)的鍵值對已經(jīng)存在，則用新的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;
            }
        }

        // 若“該key”對應(yīng)的鍵值對不存在，則將“key-value”添加到table中
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

    // putForNullKey()的作用是將“key為null”鍵值對添加到table[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;
            }
        }
        // 這里的完全不會被執(zhí)行到!
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

    // 創(chuàng)建HashMap對應(yīng)的“添加方法”臭胜，
    // 它和put()不同莫其。putForCreate()是內(nèi)部方法，它被構(gòu)造函數(shù)等調(diào)用耸三，用來創(chuàng)建HashMap
    // 而put()是對外提供的往HashMap中添加元素的方法乱陡。
    private void putForCreate(K key, V value) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);

        // 若該HashMap表中存在“鍵值等于key”的元素，則替換該元素的value值
        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;
            }
        }

        // 若該HashMap表中不存在“鍵值等于key”的元素仪壮，則將該key-value添加到HashMap中
        createEntry(hash, key, value, i);
    }

    // 將“m”中的全部元素都添加到HashMap中憨颠。
    // 該方法被內(nèi)部的構(gòu)造HashMap的方法所調(diào)用。
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        // 利用迭代器將元素逐個添加到HashMap中
        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            putForCreate(e.getKey(), e.getValue());
        }
    }

    // 重新調(diào)整HashMap的大小积锅，newCapacity是調(diào)整后的單位
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        // 新建一個HashMap爽彤，將“舊HashMap”的全部元素添加到“新HashMap”中，
        // 然后缚陷，將“新HashMap”賦值給“舊HashMap”适篙。
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

    // 將HashMap中的全部元素都添加到newTable中
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    // 將"m"的全部元素都添加到HashMap中
    public void putAll(Map<? extends K, ? extends V> m) {
        // 有效性判斷
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;

        // 計算容量是否足夠，
        // 若“當前實際容量 < 需要的容量”箫爷，則將容量x2嚷节。
        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);
        }

        // 通過迭代器，將“m”中的元素逐個添加到HashMap中虎锚。
        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            put(e.getKey(), e.getValue());
        }
    }

    // 刪除“鍵為key”元素
    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) {
        // 獲取哈希值硫痰。若key為null，則哈希值為0翁都；否則調(diào)用hash()進行計算
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        // 刪除鏈表中“鍵為key”的元素
        // 本質(zhì)是“刪除單向鏈表中的節(jié)點”
        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 (!(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.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        // 刪除鏈表中的“鍵值對e”
        // 本質(zhì)是“刪除單向鏈表中的節(jié)點”
        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;
    }

    // 清空HashMap碍论，將所有的元素設(shè)為null
    public void clear() {
        modCount++;
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            tab[i] = null;
        size = 0;
    }

    // 是否包含“值為value”的元素
    public boolean containsValue(Object value) {
    // 若“value為null”谅猾，則調(diào)用containsNullValue()查找
    if (value == null)
            return containsNullValue();

    // 若“value不為null”柄慰，則查找HashMap中是否有值為value的節(jié)點鳍悠。
    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;
    }

    // 是否包含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;
    }

    // 克隆一個HashMap，并返回Object對象
    public Object clone() {
        HashMap<K,V> result = null;
        try {
            result = (HashMap<K,V>)super.clone();
        } catch (CloneNotSupportedException e) {
            // assert false;
        }
        result.table = new Entry[table.length];
        result.entrySet = null;
        result.modCount = 0;
        result.size = 0;
        result.init();
        // 調(diào)用putAllForCreate()將全部元素添加到HashMap中
        result.putAllForCreate(this);

        return result;
    }

    // Entry是單向鏈表坐搔。
    // 它是 “HashMap鏈式存儲法”對應(yīng)的鏈表藏研。
    // 它實現(xiàn)了Map.Entry 接口，即實現(xiàn)getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函數(shù)
    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        // 指向下一個節(jié)點
        Entry<K,V> next;
        final int hash;

        // 構(gòu)造函數(shù)概行。
        // 輸入?yún)?shù)包括"哈希值(h)", "鍵(k)", "值(v)", "下一節(jié)點(n)"
        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;
        }

        // 判斷兩個Entry是否相等
        // 若兩個Entry的“key”和“value”都相等蠢挡，則返回true。
        // 否則凳忙，返回false
        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;
        }

        // 實現(xiàn)hashCode()
        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }

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

        // 當向HashMap中添加元素時业踏，繪調(diào)用recordAccess()。
        // 這里不做任何處理
        void recordAccess(HashMap<K,V> m) {
        }

        // 當從HashMap中刪除元素時涧卵，繪調(diào)用recordRemoval()勤家。
        // 這里不做任何處理
        void recordRemoval(HashMap<K,V> m) {
        }
    }

    // 新增Entry。將“key-value”插入指定位置柳恐，bucketIndex是位置索引伐脖。
    void addEntry(int hash, K key, V value, int bucketIndex) {
        // 保存“bucketIndex”位置的值到“e”中
        Entry<K,V> e = table[bucketIndex];
        // 設(shè)置“bucketIndex”位置的元素為“新Entry”，
        // 設(shè)置“e”為“新Entry的下一個節(jié)點”
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        // 若HashMap的實際大小 不小于 “閾值”乐设，則調(diào)整HashMap的大小
        if (size++ >= threshold)
            resize(2 * table.length);
    }

    // 創(chuàng)建Entry讼庇。將“key-value”插入指定位置，bucketIndex是位置索引近尚。
    // 它和addEntry的區(qū)別是：
    // (01) addEntry()一般用在 新增Entry可能導致“HashMap的實際容量”超過“閾值”的情況下蠕啄。
    //   例如，我們新建一個HashMap肿男，然后不斷通過put()向HashMap中添加元素介汹；
    // put()是通過addEntry()新增Entry的。
    //   在這種情況下舶沛，我們不知道何時“HashMap的實際容量”會超過“閾值”嘹承；
    //   因此，需要調(diào)用addEntry()
    // (02) createEntry() 一般用在 新增Entry不會導致“HashMap的實際容量”超過“閾值”的情況下如庭。
    //   例如叹卷，我們調(diào)用HashMap“帶有Map”的構(gòu)造函數(shù)，它繪將Map的全部元素添加到HashMap中坪它；
    // 但在添加之前骤竹，我們已經(jīng)計算好“HashMap的容量和閾值”。也就是往毡，可以確定“即使將Map中
    // 的全部元素添加到HashMap中蒙揣，都不會超過HashMap的閾值”。
    //   此時开瞭，調(diào)用createEntry()即可懒震。
    void createEntry(int hash, K key, V value, int bucketIndex) {
        // 保存“bucketIndex”位置的值到“e”中
        Entry<K,V> e = table[bucketIndex];
        // 設(shè)置“bucketIndex”位置的元素為“新Entry”罩息，
        // 設(shè)置“e”為“新Entry的下一個節(jié)點”
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        size++;
    }

    // HashIterator是HashMap迭代器的抽象出來的父類，實現(xiàn)了公共了函數(shù)个扰。
    // 它包含“key迭代器(KeyIterator)”瓷炮、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3個子類。
    private abstract class HashIterator<E> implements Iterator<E> {
        // 下一個元素
        Entry<K,V> next;
        // expectedModCount用于實現(xiàn)fast-fail機制递宅。
        int expectedModCount;
        // 當前索引
        int index;
        // 當前元素
        Entry<K,V> current;

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                // 將next指向table中第一個不為null的元素娘香。
                // 這里利用了index的初始值為0，從0開始依次向后遍歷办龄，直到找到不為null的元素就退出循環(huán)烘绽。
                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();

            // 注意！＠睢诀姚！
            // 一個Entry就是一個單向鏈表
            // 若該Entry的下一個節(jié)點不為空，就將next指向下一個節(jié)點;
            // 否則玷禽，將next指向下一個鏈表(也是下一個Entry)的不為null的節(jié)點赫段。
            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;
        }

    }

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

    // key的迭代器
    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }

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

    // 返回一個“key迭代器”
    Iterator<K> newKeyIterator()   {
        return new KeyIterator();
    }
    // 返回一個“value迭代器”
    Iterator<V> newValueIterator()   {
        return new ValueIterator();
    }
    // 返回一個“entry迭代器”
    Iterator<Map.Entry<K,V>> newEntryIterator()   {
        return new EntryIterator();
    }

    // HashMap的Entry對應(yīng)的集合
    private transient Set<Map.Entry<K,V>> entrySet = null;

    // 返回“key的集合”，實際上返回一個“KeySet對象”
    public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

    // Key對應(yīng)的集合
    // KeySet繼承于AbstractSet矢赁，說明該集合中沒有重復的Key糯笙。
    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集合”，實際上返回的是一個Values對象
    public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    // “value集合”
    // Values繼承于AbstractCollection撩银，不同于“KeySet繼承于AbstractSet”给涕，
    // Values中的元素能夠重復。因為不同的key可以指向相同的value额获。
    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();
        }
    }

    // 返回“HashMap的Entry集合”
    public Set<Map.Entry<K,V>> entrySet() {
        return entrySet0();
    }

    // 返回“HashMap的Entry集合”够庙，它實際是返回一個EntrySet對象
    private Set<Map.Entry<K,V>> entrySet0() {
        Set<Map.Entry<K,V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    // EntrySet對應(yīng)的集合
    // EntrySet繼承于AbstractSet，說明該集合中沒有重復的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();
        }
    }

    // java.io.Serializable的寫入函數(shù)
    // 將HashMap的“總的容量耘眨，實際容量，所有的Entry”都寫入到輸出流中
    private void writeObject(java.io.ObjectOutputStream s)
        throws IOException
    {
        Iterator<Map.Entry<K,V>> i =
            (size > 0) ? entrySet0().iterator() : null;

        // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();

        // Write out number of buckets
        s.writeInt(table.length);

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

        // Write out keys and values (alternating)
        if (i != null) {
            while (i.hasNext()) {
            Map.Entry<K,V> e = i.next();
            s.writeObject(e.getKey());
            s.writeObject(e.getValue());
            }
        }
    }


    private static final long serialVersionUID = 362498820763181265L;

    // java.io.Serializable的讀取函數(shù)：根據(jù)寫入方式讀出
    // 將HashMap的“總的容量境肾，實際容量剔难，所有的Entry”依次讀出
    private void readObject(java.io.ObjectInputStream s)
         throws IOException, ClassNotFoundException
    {
        // Read in the threshold, loadfactor, and any hidden stuff
        s.defaultReadObject();

        // Read in number of buckets and allocate the bucket array;
        int numBuckets = s.readInt();
        table = new Entry[numBuckets];

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

        // Read in size (number of Mappings)
        int size = s.readInt();

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

    // 返回“HashMap總的容量”
    int   capacity()     { return table.length; }
    // 返回“HashMap的加載因子”
    float loadFactor()   { return loadFactor;   }
}