一、HashMap概述:HashMap是java程序員使用頻率最高的用于映射(鍵值對(duì))處理的數(shù)據(jù)類型。隨著JDK（Java Developmet Kit）版本的更新，JDK1.8對(duì)HashMap底層的實(shí)現(xiàn)進(jìn)行了優(yōu)化，采用數(shù)組+鏈表+紅黑樹(shù)實(shí)現(xiàn)，當(dāng)鏈表長(zhǎng)度超過(guò)閾值（8）時(shí)，將鏈表轉(zhuǎn)換為紅黑樹(shù)，這樣大大減少了查找時(shí)間。

二、HashMap數(shù)據(jù)結(jié)構(gòu):

說(shuō)明：上圖很形象的展示了HashMap的數(shù)據(jù)結(jié)構(gòu)（數(shù)組+鏈表+紅黑樹(shù)），桶中的結(jié)構(gòu)可能是鏈表，也可能是紅黑樹(shù)，紅黑樹(shù)的引入是為了提高效率。

三、HashMap源碼分析：

3.1類的繼承關(guān)系

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
　可以看到HashMap繼承自父類（AbstractMap），實(shí)現(xiàn)了Map、Cloneable、Serializable接口。其中，Map接口定義了一組通用的操作；Cloneable接口則表示可以進(jìn)行拷貝，在HashMap中，實(shí)現(xiàn)的是淺層次拷貝，即對(duì)拷貝對(duì)象的改變會(huì)影響被拷貝的對(duì)象；Serializable接口表示HashMap實(shí)現(xiàn)了序列化，即可以將HashMap對(duì)象保存至本地，之后可以恢復(fù)狀態(tài)。
3.2 類的屬性
// 默認(rèn)的初始容量是16static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   // 最大容量static final int MAXIMUM_CAPACITY = 1 << 30; // 默認(rèn)的填充因子static final float DEFAULT_LOAD_FACTOR = 0.75f;// 當(dāng)桶(bucket)上的結(jié)點(diǎn)數(shù)大于這個(gè)值時(shí)會(huì)轉(zhuǎn)成紅黑樹(shù)static final int TREEIFY_THRESHOLD = 8; // 當(dāng)桶(bucket)上的結(jié)點(diǎn)數(shù)小于這個(gè)值時(shí)樹(shù)轉(zhuǎn)鏈表static final int UNTREEIFY_THRESHOLD = 6;// 桶中結(jié)構(gòu)轉(zhuǎn)化為紅黑樹(shù)對(duì)應(yīng)的table的最小大小static final int MIN_TREEIFY_CAPACITY = 64;// 存儲(chǔ)元素的數(shù)組，總是2的冪次倍transient Node<k,v>[] table; // 存放具體元素的集,用于迭代元素transient Set<map.entry<k,v>> entrySet;// 存放元素的個(gè)數(shù)，注意這個(gè)不等于數(shù)組的長(zhǎng)度。transient int size;// 每次擴(kuò)容和更改map結(jié)構(gòu)的計(jì)數(shù)器transient int modCount;   // 臨界值 當(dāng)實(shí)際大小(容量*填充因子)超過(guò)臨界值時(shí)，會(huì)進(jìn)行擴(kuò)容int threshold;// 填充因子final float loadFactor;
3.3 Node鏈表的實(shí)現(xiàn)
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;    }}
　可以看到，node中包含一個(gè)next變量，這個(gè)就是鏈表的關(guān)鍵點(diǎn)，hash結(jié)果相同的元素就是通過(guò)這個(gè)next進(jìn)行關(guān)聯(lián)的。
3.4 TreeNode紅黑樹(shù)的實(shí)現(xiàn)
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {    TreeNode<K,V> parent;  // red-black tree links    TreeNode<K,V> left;    TreeNode<K,V> right;    TreeNode<K,V> PRev;    // needed to unlink next upon deletion    boolean red;    TreeNode(int hash, K key, V val, Node<K,V> next) {        super(hash, key, val, next);    }......  }
紅黑樹(shù)比鏈表多了四個(gè)變量，parent父節(jié)點(diǎn)、left左節(jié)點(diǎn)、right右節(jié)點(diǎn)、prev上一個(gè)同級(jí)節(jié)點(diǎn)，紅黑樹(shù)內(nèi)容較多，有興趣的可以自行百度，不在贅述。
3.5 構(gòu)造函數(shù)
(1) HashMap(int, float)型構(gòu)造函數(shù)
public HashMap(int initialCapacity, float loadFactor) {    // 初始容量不能小于0，否則報(bào)錯(cuò)    if (initialCapacity < 0)        throw new IllegalArgumentException("Illegal initial capacity: " +                                            initialCapacity);    // 初始容量不能大于最大值，否則為最大值    if (initialCapacity > MAXIMUM_CAPACITY)        initialCapacity = MAXIMUM_CAPACITY;    // 填充因子不能小于或等于0，不能為非數(shù)字    if (loadFactor <= 0 || Float.isNaN(loadFactor))        throw new IllegalArgumentException("Illegal load factor: " +                                            loadFactor);    // 初始化填充因子                                            this.loadFactor = loadFactor;    // 初始化threshold大小    this.threshold = tableSizeFor(initialCapacity);    }
說(shuō)明：tableSizeFor(initialCapacity)返回大于initialCapacity的最小的二次冪數(shù)值。
static final int tableSizeFor(int cap) {    int n = cap - 1;    n |= n >>> 1;    n |= n >>> 2;    n |= n >>> 4;    n |= n >>> 8;    n |= n >>> 16;    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;}
這里又涉及到一個(gè)算法，通過(guò)給定的大小cap，計(jì)算大于等于cap的最小的2的冪數(shù)。連續(xù)5次右移運(yùn)算乍一看沒(méi)有什么意思，但仔細(xì)一想2進(jìn)制都是0和1啊，這就有問(wèn)題了，第一次右移一位，就表示但凡是1的位置右邊的一位都變成了1，第二次右移兩位，上次已經(jīng)把有1的位置都變成連續(xù)兩個(gè)1了，是不是感覺(jué)很神奇，如此下來(lái)5次運(yùn)算正好將int的32位都轉(zhuǎn)了個(gè)遍，以最高的一個(gè)1的位置為基準(zhǔn)將后面所有位數(shù)都變?yōu)?，然后在進(jìn)行n+1，不就變成了2的冪數(shù)。這里還有一點(diǎn)要注意的是第一行的cap-1，這是因?yàn)槿绻鹀ap本身就是2的冪數(shù)，會(huì)出現(xiàn)結(jié)果是cap的2倍的情況，會(huì)浪費(fèi)空間。
（2） HashMap(int)型構(gòu)造函數(shù)
   public HashMap(int initialCapacity) {    // 調(diào)用HashMap(int, float)型構(gòu)造函數(shù)    this(initialCapacity, DEFAULT_LOAD_FACTOR);  }
（3）HashMap()型構(gòu)造函數(shù)。
public HashMap() {    // 初始化填充因子    this.loadFactor = DEFAULT_LOAD_FACTOR; }
（4）HashMap(Map<? extends K>)型構(gòu)造函數(shù)。
public HashMap(Map<? extends K, ? extends V> m) {    // 初始化填充因子    this.loadFactor = DEFAULT_LOAD_FACTOR;    // 將m中的所有元素添加至HashMap中    putMapEntries(m, false);}
說(shuō)明：putMapEntries(Map<? extends K, ? extends V> m, boolean evict)函數(shù)將m的所有元素存入本HashMap實(shí)例中。
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {    int s = m.size();    if (s > 0) {        // 判斷table是否已經(jīng)初始化        if (table == null) { // pre-size            // 未初始化，s為m的實(shí)際元素個(gè)數(shù)            float ft = ((float)s / loadFactor) + 1.0F;            int t = ((ft < (float)MAXIMUM_CAPACITY) ?                    (int)ft : MAXIMUM_CAPACITY);            // 計(jì)算得到的t大于閾值，則初始化閾值            if (t > threshold)                threshold = tableSizeFor(t);        }        // 已初始化，并且m元素個(gè)數(shù)大于閾值，進(jìn)行擴(kuò)容處理        else if (s > threshold)            resize();        // 將m中的所有元素添加至HashMap中        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {            K key = e.getKey();            V value = e.getValue();            putVal(hash(key), key, value, false, evict);        }    }}
3.6 put實(shí)現(xiàn)
public V put(K key, V value) {    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未初始化或者長(zhǎng)度為0，進(jìn)行擴(kuò)容    if ((tab = table) == null || (n = tab.length) == 0)        n = (tab = resize()).length;    // (n - 1) & hash 確定元素存放在哪個(gè)桶中，桶為空，新生成結(jié)點(diǎn)放入桶中(此時(shí)，這個(gè)結(jié)點(diǎn)是放在數(shù)組中)    if ((p = tab[i = (n - 1) & hash]) == null)        tab[i] = newNode(hash, key, value, null);    // 桶中已經(jīng)存在元素    else {        Node<K,V> e; K k;        // 比較桶中第一個(gè)元素(數(shù)組中的結(jié)點(diǎn))的hash值相等，key相等        if (p.hash == hash &&            ((k = p.key) == key || (key != null && key.equals(k))))                // 將第一個(gè)元素賦值給e，用e來(lái)記錄                e = p;        // hash值不相等，即key不相等；為紅黑樹(shù)結(jié)點(diǎn)        else if (p instanceof TreeNode)            // 放入樹(shù)中            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);        // 為鏈表結(jié)點(diǎn)        else {            // 在鏈表最末插入結(jié)點(diǎn)            for (int binCount = 0; ; ++binCount) {                // 到達(dá)鏈表的尾部                if ((e = p.next) == null) {                    // 在尾部插入新結(jié)點(diǎn)                    p.next = newNode(hash, key, value, null);                    // 結(jié)點(diǎn)數(shù)量達(dá)到閾值，轉(zhuǎn)化為紅黑樹(shù)                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                        treeifyBin(tab, hash);                    // 跳出循環(huán)                    break;                }                // 判斷鏈表中結(jié)點(diǎn)的key值與插入的元素的key值是否相等                if (e.hash == hash &&                    ((k = e.key) == key || (key != null && key.equals(k))))                    // 相等，跳出循環(huán)                    break;                // 用于遍歷桶中的鏈表，與前面的e = p.next組合，可以遍歷鏈表                p = e;            }        }        // 表示在桶中找到key值、hash值與插入元素相等的結(jié)點(diǎn)        if (e != null) {             // 記錄e的value            V oldValue = e.value;            // onlyIfAbsent為false或者舊值為null            if (!onlyIfAbsent || oldValue == null)                //用新值替換舊值                e.value = value;            // 訪問(wèn)后回調(diào)            afterNodeaccess(e);            // 返回舊值            return oldValue;        }    }    // 結(jié)構(gòu)性修改    ++modCount;    // 實(shí)際大小大于閾值則擴(kuò)容    if (++size > threshold)        resize();    // 插入后回調(diào)    afterNodeInsertion(evict);    return null;}final void treeifyBin(Node<K,V>[] tab, int hash) {    //將鏈表轉(zhuǎn)換為紅黑樹(shù)    int n, index; Node<K,V> e;    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)    //如果map的容量小于64（默認(rèn)值），會(huì)調(diào)用resize擴(kuò)容，不會(huì)轉(zhuǎn)換為紅黑樹(shù)        resize();    else if ((e = tab[index = (n - 1) & hash]) != null) {        TreeNode<K,V> hd = null, tl = null;        do {            TreeNode<K,V> p = replacementTreeNode(e, null);    //Node轉(zhuǎn)換為TreeNode            if (tl == null)                hd = p;            else {                p.prev = tl;                tl.next = p;            }            tl = p;        } while ((e = e.next) != null);        if ((tab[index] = hd) != null)                hd.treeify(tab);        //調(diào)用TreeNode的樹(shù)排序方法    }}
這里重點(diǎn)說(shuō)兩點(diǎn)：
索引的計(jì)算：在計(jì)算索引時(shí)，這個(gè)值必須在[0,length]這個(gè)左閉右開(kāi)的區(qū)間中，基于這個(gè)條件，比如默認(rèn)的table長(zhǎng)度為16，代入公式 (n 1) & hash，結(jié)果必然是存在于[0,length]區(qū)間范圍內(nèi)。這里還有個(gè)小技巧，在容量一定是2^n的情況下，h & (length 1) == h % length，這里之所以使用位運(yùn)算，我想也是因?yàn)槲贿\(yùn)算直接由計(jì)算機(jī)處理，效率要高過(guò)%運(yùn)算。
轉(zhuǎn)化紅黑樹(shù)：在put方法中，邏輯是鏈表長(zhǎng)度大于（TREEIFY_THRESHOLD -1）時(shí)，就轉(zhuǎn)化為紅黑樹(shù)， 實(shí)際情況這只是初步判斷，在轉(zhuǎn)化的方法treeifyBin()方法中會(huì)進(jìn)行二次校驗(yàn)，當(dāng)tab.length
3.7 HashMap中使用的hash算法
static final int hash(Object key) {    int h;    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}
這個(gè)hash先將key右移了16位，然后與key進(jìn)行異或。由于 int 只有 32 位，無(wú)符號(hào)右移 16 位相當(dāng)于把高位的一半移到低位：
舉個(gè)栗子：
這樣可以避免只靠低位數(shù)據(jù)來(lái)計(jì)算哈希時(shí)導(dǎo)致的沖突，計(jì)算結(jié)果由高低位結(jié)合決定，可以避免哈希值分布不均勻。而且，采用位運(yùn)算效率更高。
這里還涉及到put方法中的另一次&操作，
tab[i = (n - 1) & hash]
tab既是table，n是map集合的容量大小，hash是上面方法的返回值。因?yàn)橥ǔＢ暶鱩ap集合時(shí)不會(huì)指定大小，或者初始化的時(shí)候就創(chuàng)建一個(gè)容量很大的map對(duì)象，所以這個(gè)通過(guò)容量大小與key值進(jìn)行hash的算法在開(kāi)始的時(shí)候只會(huì)對(duì)低位進(jìn)行計(jì)算，雖然容量的2進(jìn)制高位一開(kāi)始都是0，但是key的2進(jìn)制高位通常是有值的，因此先在hash方法中將key的hashCode右移16位在與自身異或，使得高位也可以參與hash，更大程度上減少了碰撞率。
3.8 resize實(shí)現(xiàn)
final Node<K,V>[] resize() {    Node<K,V>[] oldTab = table;    int oldCap = (oldTab == null) ? 0 : oldTab.length;  // 獲取原HashMap數(shù)組的長(zhǎng)度。    int oldThr = threshold;  // 擴(kuò)容臨界值    int newCap, newThr = 0;      if (oldCap > 0) {         // 超過(guò)最大值就不再擴(kuò)充了        if (oldCap >= MAXIMUM_CAPACITY) {               threshold = Integer.MAX_VALUE;            return oldTab;        }        // 沒(méi)超過(guò)最大值，就擴(kuò)充為原來(lái)的2倍        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)            newThr = oldThr << 1; // double threshold    }    else if (oldThr > 0) // initial capacity was placed in threshold        newCap = oldThr;    else {               // zero initial threshold signifies using defaults        newCap = DEFAULT_INITIAL_CAPACITY;        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);    }    // 計(jì)算新的resize上限    if (newThr == 0) {        float ft = (float)newCap * loadFactor;        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                (int)ft : Integer.MAX_VALUE);    }    threshold = newThr;    @SuppressWarnings({"rawtypes","unchecked"})    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];    table = newTab;    // 遍歷桶，然后對(duì)桶中的每個(gè)元素進(jìn)行重新hash    if (oldTab != null) {        for (int j = 0; j < oldCap; ++j) {            Node<K,V> e;            if ((e = oldTab[j]) != null) {                oldTab[j] = null;  // 原table地址釋放               // 單節(jié)點(diǎn)處理                if (e.next == null)                     newTab[e.hash & (newCap - 1)] = e;  // 重新hash放入新table中                // 紅黑樹(shù)處理                else if (e instanceof TreeNode)                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                else { // preserve order                    // 長(zhǎng)鏈表處理                    Node<K,V> loHead = null, loTail = null;                    Node<K,V> hiHead = null, hiTail = null;                    Node<K,V> next;                    do {                        next = e.next;                        // 新表是舊表的兩倍容量，以下把單鏈表拆分為高位鏈表、低位鏈表                        if ((e.hash & oldCap) == 0) {  // 低位鏈表，注意與的對(duì)象是oldCap，而不是 oldCap-1                            if (loTail == null)                                loHead = e;                            else                                loTail.next = e;                            loTail = e;                        }                        else {   // 高位鏈表                            if (hiTail == null)                                hiHead = e;                            else                                hiTail.next = e;                            hiTail = e;                        }                    } while ((e = next) != null);                    // 低位鏈表保持原索引放入新table中                    if (loTail != null) {                        loTail.next = null;                        newTab[j] = loHead;                    }                    // 高位鏈表放入新table中，索引=原索引+oldCap                    if (hiTail != null) {                        hiTail.next = null;                        newTab[j + oldCap] = hiHead;                    }                }            }        }    }    return newTab;}
從resize() 的實(shí)現(xiàn)中可以看出，在擴(kuò)容時(shí)，針對(duì)table，如果桶的位置是單節(jié)點(diǎn)鏈表，那么index =（hash & (newTab.length - 1)），直接放入新表。紅黑樹(shù)另外處理。若是多節(jié)點(diǎn)鏈表，會(huì)產(chǎn)生高低和低位鏈表，即：hash & length=0為低位鏈表、hash & length=length為高位鏈表。低位鏈表保持原索引放入新table中，高位鏈表index=oldTab.index + oldTab.length = hash & (newTab.length-1)。
為什么要分高低位鏈表?，試想若是全部都使用index =（hash & (newTab.length - 1)）計(jì)算，此時(shí)因?yàn)槭腔谙聵?biāo)存儲(chǔ)，從而導(dǎo)致在index沖突的情況下，多元素鏈表的追加出現(xiàn)額外的時(shí)間（尋址等）或空間（輔助參數(shù)、結(jié)構(gòu)等）上的開(kāi)銷。分高低位鏈表，相比先保存好數(shù)據(jù)再尋找追加效率更好，也是極好的優(yōu)化技巧。
3.9 get實(shí)現(xiàn)
public V get(Object key) {    Node<K,V> e;    return (e = getNode(hash(key), key)) == null ? null : e.value;}final Node<K,V> getNode(int hash, Object key) {    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;    if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {        // 直接命中        if (first.hash == hash && // always check first node                    ((k = first.key) == key || (key != null && key.equals(k))))            return first;        // 未命中        if ((e = first.next) != null) {            // 在樹(shù)中查找            if (first instanceof TreeNode)                return ((TreeNode<K,V>)first).getTreeNode(hash, key);            // 在鏈表中查找            do {                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))                    return e;            } while ((e = e.next) != null);        }    }    return null;}
4.0 remove實(shí)現(xiàn)
public V remove(Object key) {    Node<K,V> e;    return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;}final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) {    Node<K,V>[] tab; Node<K,V> p; int n, index;    if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {        Node<K,V> node = null, e; K k; V v;        // 直接命中        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))            node = p;        else if ((e = p.next) != null) {            // 紅黑樹(shù)中查找            if (p instanceof TreeNode)                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);            else {                // 鏈表中查找                do {                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {                        node = e;                        break;                    }                    p = e;                } while ((e = e.next) != null);            }        }        // 命中后刪除        if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {            if (node instanceof TreeNode)                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);            else if (node == p)                tab[index] = node.next;  // 鏈表首元素刪除            else                p.next = node.next;  //多元素鏈表節(jié)點(diǎn)刪除            ++modCount;            --size;            afterNodeRemoval(node);            return node;        }    }    return null;}
4.1 containsKey實(shí)現(xiàn)
public boolean containsKey(Object key) {    return getNode(hash(key), key) != null; }
4.2 containsValue實(shí)現(xiàn)
public boolean containsValue(Object value) {    Node<K,V>[] tab; V v;    if ((tab = table) != null && size > 0) {        // table遍歷        for (int i = 0; i < tab.length; ++i) {            // 多元素鏈表遍歷            for (Node<K,V> e = tab[i]; e != null; e = e.next) {                if ((v = e.value) == value || (value != null && value.equals(v)))                    return true;            }        }    }    return false;}
四、總結(jié)：
（1） 為什么需要負(fù)載因子？
加載因子存在的原因，還是因?yàn)橐獪p緩哈希沖突，例如：默認(rèn)初始桶為16，或等到滿16個(gè)元素才擴(kuò)容，某些桶里可能就會(huì)有多個(gè)元素了。所以加載因子默認(rèn)為0.75，也就是說(shuō)大小為16的HashMap，擴(kuò)容臨界值threshold=0.75*16=12,到了第13個(gè)元素，就會(huì)擴(kuò)容成32。
（2） 加載因子減小？
在構(gòu)造函數(shù)里，設(shè)定小一點(diǎn)的加載因子,比如0.5，甚至0.25。若是一個(gè)長(zhǎng)期存在的Map,并且key不固定，那可以適當(dāng)加大初始大小，同時(shí)減少加載因子，降低沖突的機(jī)率，也能減少尋址的時(shí)間。用空間來(lái)?yè)Q時(shí)間，這時(shí)也是值得的。
（3） 初始化時(shí)是否定義容量？
通過(guò)以上源碼分析，每次擴(kuò)容都需要重創(chuàng)建桶數(shù)組、鏈表、數(shù)據(jù)轉(zhuǎn)換等，所以擴(kuò)容成本還是挺高的，若初始化時(shí)能設(shè)置準(zhǔn)確或預(yù)估出需要的容量，即使大一點(diǎn)，用空間來(lái)?yè)Q時(shí)間，有時(shí)也是值得的。
（4） String型的Key設(shè)計(jì)優(yōu)化？
如果無(wú)法保證無(wú)沖突而且能用==來(lái)對(duì)比，那就盡量搞短點(diǎn)，試想一個(gè)個(gè)字符的equals都是需要花時(shí)間的。順序型的Key,如：k1、k2、k3...k50,這種key的hashCode是數(shù)字遞增，沖突的可能性實(shí)在太小。
for(int i=0;i<100;i++){    System.out.println(key+".hashCode="+key.hashCode());}結(jié)果：K0.hashCode = 2373K1.hashCode = 2374K2.hashCode = 2375K3.hashCode = 2376K4.hashCode = 2377... ...