HashMap概述
HashMap是基于哈希表的Map接口的非同步實(shí)現(xiàn)。此實(shí)現(xiàn)提供所有可選的映射操作哲身，（特性）并允許使用null值和null鍵。此類不保證映射的順序吏够，特別是它不保證該順序恒久不變疯暑。

HashMap的數(shù)據(jù)結(jié)構(gòu)
在Java編程語(yǔ)言中训柴，最基本的結(jié)構(gòu)就是兩種，一個(gè)是數(shù)組妇拯，另外一個(gè)是模擬指針（引用）幻馁，所有的數(shù)據(jù)結(jié)構(gòu)都可以用這兩個(gè)基本結(jié)構(gòu)來(lái)構(gòu)造的，HashMap也不例外越锈。HashMap實(shí)際上是一個(gè)“鏈表散列”的數(shù)據(jù)結(jié)構(gòu)仗嗦，即數(shù)組和鏈表的結(jié)合體。

從上圖中可以看出甘凭，HashMap底層就是一個(gè)數(shù)組結(jié)構(gòu)稀拐，數(shù)組中的每一項(xiàng)又是一個(gè)鏈表。當(dāng)新建一個(gè)HashMap的時(shí)候丹弱，就會(huì)初始化一個(gè)數(shù)組德撬。

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
     */
    transient Node<K,V>[] table;

/**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

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

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

可以看出，Entry就是數(shù)組中的元素躲胳，每個(gè) Map.Entry 其實(shí)就是一個(gè)key-value對(duì)蜓洪，它持有一個(gè)指向下一個(gè)元素的引用，這就構(gòu)成了鏈表泛鸟。

HashMap的存取實(shí)現(xiàn)

public V put(K key, V value) {
    // HashMap允許存放null鍵和null值蝠咆。
    // 當(dāng)key為null時(shí)踊东，調(diào)用putForNullKey方法北滥，將value放置在數(shù)組第一個(gè)位置。  
    if (key == null)
        return putForNullKey(value);
    // 根據(jù)key的keyCode重新計(jì)算hash值闸翅。
    int hash = hash(key.hashCode());
    // 搜索指定hash值在對(duì)應(yīng)table中的索引再芋。
    int i = indexFor(hash, table.length);
    // 如果 i 索引處的 Entry 不為 null，通過(guò)循環(huán)不斷遍歷 e 元素的下一個(gè)元素坚冀。
    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;
        }
    }
    // 如果i索引處的Entry為null济赎，表明此處還沒(méi)有Entry。
    modCount++;
    // 將key记某、value添加到i索引處司训。
    addEntry(hash, key, value, i);
    return null;
}

從上面的源代碼中可以看出：當(dāng)我們往HashMap中put元素的時(shí)候，先根據(jù)key的hashCode重新計(jì)算hash值液南，根據(jù)hash值得到這個(gè)元素在數(shù)組中的位置（即下標(biāo)）壳猜， 如果數(shù)組該位置上已經(jīng)存放有其他元素了，那么在這個(gè)位置上的元素將以鏈表的形式存放滑凉，新加入的放在鏈頭统扳，最先加入的放在鏈尾喘帚。如果數(shù)組該位置上沒(méi)有元素，就直接將該元素放到此數(shù)組中的該位置上咒钟。

addEntry(hash, key, value, i)方法根據(jù)計(jì)算出的hash值吹由，將key-value對(duì)放在數(shù)組table的i索引處。addEntry 是 HashMap 提供的一個(gè)包訪問(wèn)權(quán)限的方法朱嘴，代碼如下：

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 獲取指定 bucketIndex 索引處的 Entry  
    Entry<K,V> e = table[bucketIndex];
    // 將新創(chuàng)建的 Entry 放入 bucketIndex 索引處倾鲫，并讓新的 Entry 指向原來(lái)的 Entry  
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    // 如果 Map 中的 key-value 對(duì)的數(shù)量超過(guò)了極限
    if (size++ >= threshold)
    // 把 table 對(duì)象的長(zhǎng)度擴(kuò)充到原來(lái)的2倍。
        resize(2 * table.length);
}

當(dāng)系統(tǒng)決定存儲(chǔ)HashMap中的key-value對(duì)時(shí)腕够，完全沒(méi)有考慮Entry中的value级乍，僅僅只是根據(jù)key來(lái)計(jì)算并決定每個(gè)Entry的存儲(chǔ)位置。我們完全可以把 Map 集合中的 value 當(dāng)成 key 的附屬帚湘，當(dāng)系統(tǒng)決定了 key 的存儲(chǔ)位置之后玫荣，value 隨之保存在那里即可。

hash(int h)方法根據(jù)key的hashCode重新計(jì)算一次散列大诸。此算法加入了高位計(jì)算捅厂，防止低位不變，高位變化時(shí)资柔，造成的hash沖突焙贷。

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

我們可以看到在HashMap中要找到某個(gè)元素，需要根據(jù)key的hash值來(lái)求得對(duì)應(yīng)數(shù)組中的位置贿堰。如何計(jì)算這個(gè)位置就是hash算法辙芍。前面說(shuō)過(guò)HashMap的數(shù)據(jù)結(jié)構(gòu)是數(shù)組和鏈表的結(jié)合，所以我們當(dāng)然希望這個(gè)HashMap里面的 元素位置盡量的分布均勻些羹与，盡量使得每個(gè)位置上的元素?cái)?shù)量只有一個(gè)故硅，那么當(dāng)我們用hash算法求得這個(gè)位置的時(shí)候，馬上就可以知道對(duì)應(yīng)位置的元素就是我們要的纵搁，而不用再去遍歷鏈表吃衅，這樣就大大優(yōu)化了查詢的效率。

對(duì)于任意給定的對(duì)象腾誉，只要它的 hashCode() 返回值相同徘层，那么程序調(diào)用 hash(int h) 方法所計(jì)算得到的 hash 碼值總是相同的。我們首先想到的就是把hash值對(duì)數(shù)組長(zhǎng)度取模運(yùn)算利职，這樣一來(lái)趣效，元素的分布相對(duì)來(lái)說(shuō)是比較均勻的。但是猪贪，“孽尉矗”運(yùn)算的消耗還是比較大的，在HashMap中是這樣做的：調(diào)用 indexFor(int h, int length) 方法來(lái)計(jì)算該對(duì)象應(yīng)該保存在 table 數(shù)組的哪個(gè)索引處哮伟。indexFor(int h, int length) 方法的代碼如下：

static int indexFor(int h, int length) {  
    return h & (length-1);
}

這個(gè)方法非常巧妙干花，它通過(guò) h & (table.length -1) 來(lái)得到該對(duì)象的保存位妄帘，而HashMap底層數(shù)組的長(zhǎng)度總是 2 的 n 次方，這是HashMap在速度上的優(yōu)化池凄。在 HashMap 構(gòu)造器中有如下代碼：

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

這段代碼保證初始化時(shí)HashMap的容量總是2的n次方抡驼，即底層數(shù)組的長(zhǎng)度總是為2的n次方。

當(dāng)length總是 2 的n次方時(shí)肿仑，h& (length-1)運(yùn)算等價(jià)于對(duì)length取模致盟，也就是h%length，但是&比%具有更高的效率尤慰。

這看上去很簡(jiǎn)單馏锡，其實(shí)比較有玄機(jī)的，我們舉個(gè)例子來(lái)說(shuō)明：

假設(shè)數(shù)組長(zhǎng)度分別為15和16伟端，優(yōu)化后的hash碼分別為8和9杯道，那么&運(yùn)算后的結(jié)果如下：
h & (table.length-1) hash table.length-1
8 & (15-1)： 0100 & 1110 = 0100
9 & (15-1)： 0101 & 1110 = 0100
8 & (16-1)： 0100 & 1111 = 0100
9 & (16-1)： 0101 & 1111 = 0101

從上面的例子中可以看出：當(dāng)它們和15-1（1110）“與”的時(shí)候，產(chǎn)生了相同的結(jié)果责蝠，也就是說(shuō)它們會(huì)定位到數(shù)組中的同一個(gè)位置上去党巾，這就產(chǎn)生了碰撞，8和9會(huì)被放到數(shù)組中的同一個(gè)位置上形成鏈表霜医，那么查詢的時(shí)候就需要遍歷這個(gè)鏈 表齿拂，得到8或者9，這樣就降低了查詢的效率肴敛。同時(shí)署海，我們也可以發(fā)現(xiàn)，當(dāng)數(shù)組長(zhǎng)度為15的時(shí)候医男，hash值會(huì)與15-1（1110）進(jìn)行“與”砸狞，那么最后一位永遠(yuǎn)是0，而0001昨登，0011趾代，0101贯底，1001丰辣，1011，0111禽捆，1101這幾個(gè)位置永遠(yuǎn)都不能存放元素了笙什，空間浪費(fèi)相當(dāng)大，更糟的是這種情況中胚想，數(shù)組可以使用的位置比數(shù)組長(zhǎng)度小了很多琐凭，這意味著進(jìn)一步增加了碰撞的幾率，減慢了查詢的效率浊服！而當(dāng)數(shù)組長(zhǎng)度為16時(shí)统屈，即為2的n次方時(shí)胚吁，2n-1得到的二進(jìn)制數(shù)的每個(gè)位上的值都為1，這使得在低位上&時(shí)愁憔，得到的和原h(huán)ash的低位相同腕扶，加之hash(int h)方法對(duì)key的hashCode的進(jìn)一步優(yōu)化，加入了高位計(jì)算吨掌，就使得只有相同的hash值的兩個(gè)值才會(huì)被放到數(shù)組中的同一個(gè)位置上形成鏈表半抱。

所以說(shuō)，當(dāng)數(shù)組長(zhǎng)度為2的n次冪的時(shí)候膜宋，不同的key算得得index相同的幾率較小窿侈，那么數(shù)據(jù)在數(shù)組上分布就比較均勻，也就是說(shuō)碰撞的幾率小秋茫，相對(duì)的史简，查詢的時(shí)候就不用遍歷某個(gè)位置上的鏈表，這樣查詢效率也就較高了肛著。

根據(jù)上面 put 方法的源代碼可以看出乘瓤，當(dāng)程序試圖將一個(gè)key-value對(duì)放入HashMap中時(shí)，程序首先根據(jù)該 key 的 hashCode() 返回值決定該 Entry 的存儲(chǔ)位置：如果兩個(gè) Entry 的 key 的 hashCode() 返回值相同策泣，那它們的存儲(chǔ)位置相同衙傀。如果這兩個(gè) Entry 的 key 通過(guò) equals 比較返回 true呢蛤，新添加 Entry 的 value 將覆蓋集合中原有 Entry 的 value柑潦，但key不會(huì)覆蓋低淡。如果這兩個(gè) Entry 的 key 通過(guò) equals 比較返回 false允瞧，新添加的 Entry 將與集合中原有 Entry 形成 Entry 鏈凯肋，而且新添加的 Entry 位于 Entry 鏈的頭部——具體說(shuō)明繼續(xù)看 addEntry() 方法的說(shuō)明习贫。

讀取

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    int hash = hash(key.hashCode());
    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;
}

有了上面存儲(chǔ)時(shí)的hash算法作為基礎(chǔ)粟害，理解起來(lái)這段代碼就很容易了甚疟。從上面的源代碼中可以看出：從HashMap中g(shù)et元素時(shí)茫陆，首先計(jì)算key的hashCode金麸，找到數(shù)組中對(duì)應(yīng)位置的某一元素，然后通過(guò)key的equals方法在對(duì)應(yīng)位置的鏈表中找到需要的元素簿盅。

歸納
簡(jiǎn)單地說(shuō)挥下，HashMap 在底層將 key-value 當(dāng)成一個(gè)整體進(jìn)行處理，這個(gè)整體就是一個(gè) Entry 對(duì)象桨醋。HashMap 底層采用一個(gè) Entry[] 數(shù)組來(lái)保存所有的 key-value 對(duì)棚瘟，當(dāng)需要存儲(chǔ)一個(gè) Entry 對(duì)象時(shí)，會(huì)根據(jù)hash算法來(lái)決定其在數(shù)組中的存儲(chǔ)位置喜最，在根據(jù)equals方法決定其在該數(shù)組位置上的鏈表中的存儲(chǔ)位置偎蘸；當(dāng)需要取出一個(gè)Entry時(shí)，
也會(huì)根據(jù)hash算法找到其在數(shù)組中的存儲(chǔ)位置，再根據(jù)equals方法從該位置上的鏈表中取出該Entry迷雪。

HashMap的resize（rehash）
當(dāng)HashMap中的元素越來(lái)越多的時(shí)候限书，hash沖突的幾率也就越來(lái)越高，因?yàn)閿?shù)組的長(zhǎng)度是固定的章咧。所以為了提高查詢的效率蔗包，就要對(duì)HashMap的數(shù)組進(jìn)行擴(kuò)容，數(shù)組擴(kuò)容這個(gè)操作也會(huì)出現(xiàn)在ArrayList中慧邮，這是一個(gè)常用的操作调限，而在HashMap數(shù)組擴(kuò)容之后，最消耗性能的點(diǎn)就出現(xiàn)了：原數(shù)組中的數(shù)據(jù)必須重新計(jì)算其在新數(shù)組中的位置误澳，并放進(jìn)去耻矮，這就是resize。

那么HashMap什么時(shí)候進(jìn)行擴(kuò)容呢忆谓？當(dāng)HashMap中的元素個(gè)數(shù)超過(guò)數(shù)組大小loadFactor時(shí)裆装，就會(huì)進(jìn)行數(shù)組擴(kuò)容，loadFactor的默認(rèn)值為0.75倡缠，這是一個(gè)折中的取值哨免。也就是說(shuō)，默認(rèn)情況下昙沦，數(shù)組大小為16琢唾，那么當(dāng)HashMap中元素個(gè)數(shù)超過(guò)160.75=12的時(shí)候，就把數(shù)組的大小擴(kuò)展為 2*16=32盾饮，即擴(kuò)大一倍采桃，然后重新計(jì)算每個(gè)元素在數(shù)組中的位置，而這是一個(gè)非常消耗性能的操作丘损，所以如果我們已經(jīng)預(yù)知HashMap中元素的個(gè)數(shù)普办，那么預(yù)設(shè)元素的個(gè)數(shù)能夠有效的提高HashMap的性能。

HashMap的性能參數(shù)
HashMap 包含如下幾個(gè)構(gòu)造器：

HashMap()：構(gòu)建一個(gè)初始容量為 16徘钥，負(fù)載因子為 0.75 的 HashMap衔蹲。
ashMap(int initialCapacity)：構(gòu)建一個(gè)初始容量為 initialCapacity，負(fù)載因子為 0.75 的 HashMap呈础。
HashMap(int initialCapacity, float loadFactor)：以指定初始容量舆驶、指定的負(fù)載因子創(chuàng)建一個(gè) HashMap。

HashMap的基礎(chǔ)構(gòu)造器HashMap(int initialCapacity, float loadFactor)帶有兩個(gè)參數(shù)猪落，它們是初始容量initialCapacity和負(fù)載因子loadFactor贞远。

負(fù)載因子loadFactor衡量的是一個(gè)散列表的空間的使用程度畴博，負(fù)載因子越大表示散列表的裝填程度越高笨忌，反之愈小。對(duì)于使用鏈表法的散列表來(lái)說(shuō)俱病，查找一個(gè)元素的平均時(shí)間是O(1+a)官疲，因此如果負(fù)載因子越大袱结，對(duì)空間的利用更充分，然而后果是查找效率的降低途凫；如果負(fù)載因子太小垢夹，那么散列表的數(shù)據(jù)將過(guò)于稀疏，對(duì)空間造成嚴(yán)重浪費(fèi)维费。

HashMap的實(shí)現(xiàn)中果元，通過(guò)threshold字段來(lái)判斷HashMap的最大容量：

threshold = (int)(capacity * loadFactor);

結(jié)合負(fù)載因子的定義公式可知，threshold就是在此loadFactor和capacity對(duì)應(yīng)下允許的最大元素?cái)?shù)目犀盟，超過(guò)這個(gè)數(shù)目就重新resize而晒，以降低實(shí)際的負(fù)載因子。默認(rèn)的的負(fù)載因子0.75是對(duì)空間和時(shí)間效率的一個(gè)平衡選擇阅畴。當(dāng)容量超出此最大容量時(shí)倡怎， resize后的HashMap容量是容量的兩倍：

Fail-Fast機(jī)制
我們知道java.util.HashMap不是線程安全的，因此如果在使用迭代器的過(guò)程中有其他線程修改了map贱枣，那么將拋出ConcurrentModificationException监署，這就是所謂fail-fast策略。

這一策略在源碼中的實(shí)現(xiàn)是通過(guò)modCount域纽哥，modCount顧名思義就是修改次數(shù)钠乏，對(duì)HashMap內(nèi)容的修改都將增加這個(gè)值，那么在迭代器初始化過(guò)程中會(huì)將這個(gè)值賦給迭代器的expectedModCount春塌。

HashIterator() {
    expectedModCount = modCount;
    if (size > 0) { // advance to first entry
    Entry[] t = table;
    while (index < t.length && (next = t[index++]) == null)  
        ;
    }
}

在迭代過(guò)程中缓熟，判斷modCount跟expectedModCount是否相等，如果不相等就表示已經(jīng)有其他線程修改了Map：
注意到modCount聲明為volatile摔笤，保證線程之間修改的可見(jiàn)性

final Entry<K,V> nextEntry() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();

在HashMap的API中指出：

由所有HashMap類的“collection 視圖方法”所返回的迭代器都是快速失敗的：在迭代器創(chuàng)建之后够滑，如果從結(jié)構(gòu)上對(duì)映射進(jìn)行修改，除非通過(guò)迭代器本身的 remove 方法吕世，其他任何時(shí)間任何方式的修改彰触，迭代器都將拋出 ConcurrentModificationException。因此命辖，面對(duì)并發(fā)的修改况毅，迭代器很快就會(huì)完全失敗，而不冒在將來(lái)不確定的時(shí)間發(fā)生任意不確定行為的風(fēng)險(xiǎn)尔艇。

注意尔许，迭代器的快速失敗行為不能得到保證，一般來(lái)說(shuō)终娃，存在非同步的并發(fā)修改時(shí)味廊，不可能作出任何堅(jiān)決的保證。快速失敗迭代器盡最大努力拋出ConcurrentModificationException余佛。因此柠新，編寫依賴于此異常的程序的做法是錯(cuò)誤的，正確做法是：迭代器的快速失敗行為應(yīng)該僅用于檢測(cè)程序錯(cuò)誤辉巡。

HashMap的兩種遍歷方式
第一種

    Map map = new HashMap();
　　Iterator iter = map.entrySet().iterator();
　　while (iter.hasNext()) {
　　Map.Entry entry = (Map.Entry) iter.next();
　　Object key = entry.getKey();
　　Object val = entry.getValue();
　　}

效率高,以后一定要使用此種方式恨憎！

第二種

    Map map = new HashMap();
　　Iterator iter = map.keySet().iterator();
　　while (iter.hasNext()) {
　　Object key = iter.next();
　　Object val = map.get(key);
　　}

效率低,以后盡量少使用！

參考：http://www.importnew.com/16301.html