大家都知道 hashmap的數(shù)據(jù)結(jié)構(gòu) 鏈表(Node<Key,Value>)組成的數(shù)組(Node[] table)蝉衣，同一個鏈表中的數(shù)據(jù)粮坞，key的hashcode相同大刊，Capacity 為table數(shù)組的容量（并不是hashmap里面擁有元素的容量）鬼悠，size為所有元素的和债鸡。網(wǎng)上找的圖片

先看幾個成員變量 很簡單的英文

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * 在第一次用的時候初始化扩劝，長度是2的冪
     */
    transient Node<K,V>[] table;
    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;
    // size大于這個值的時候 resize (capacity * load factor).
    int threshold;
    // 加載因子 默認0.75 
    final float loadFactor;

構(gòu)造函數(shù) 初始化值

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    
    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;
        this.threshold = tableSizeFor(initialCapacity);
    }

通過方法tableSizeFor可知 初始化時 capacity(構(gòu)造函數(shù)傳參 容量) 不會存到HashMap的成員變量中庸论，threshold初始值為不小于capacity最小的2的n次冪 如1->1 2->2 3->4 4->4 5->8...8->8 9->16。僅僅初始化的時候 threshold為2的n次冪棒呛，第一次調(diào)用put前聂示，則為2的n次冪乘以loadFactor， 如 3 6 12 24 48

    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;
    }

put 方法 當(dāng)初始化完成后 第一次調(diào)用put方法簇秒，因為(table==null) 所以第一次put會resize()鱼喉，通過這次resize() threshold 即變?yōu)樵萾hreshold的loadFactor倍(默認0.75)

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        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 {
            ···
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

上面說過 capacity不作為一個成員變量存到HashMap中，但如何取到capacity的值呢趋观？通過 table.length, table為空 代表剛剛初始化扛禽，還有么put值，所以可以直接返回threshold皱坛，table不為空编曼，返回table.length

    final int capacity() {
        return (table != null) ? table.length :
            (threshold > 0) ? threshold :
            DEFAULT_INITIAL_CAPACITY;
    }

resize方法可以歸納為 table(capacity)大小（4 8 16 32 64）增大一倍剩辟，threshold（3 6 12 24 48）增大一倍

重點---- 上面已經(jīng)說過 HashMap容量為table的大小掐场，并不是擁有元素的上界，但resize的判定條件卻是以++size>threshold 來判斷的 所以有極端的情況贩猎，當(dāng)所有的key的hashcode為一樣時熊户，所有key-value數(shù)據(jù)都存到了table[]的一個鏈表中，其他 capacity-1個鏈表都為空吭服，但是嚷堡，當(dāng)size>threshold時，還是會把threshold與table擴容一倍艇棕，造成非常大的容量浪費 例子如下

public class DemoMain {
    public static void main(String[] args) {
        Map<Key, Object> map = new HashMap<>(5);
        for (int i = 1; i <= 10000; i++) {
            map.put(new Key("key-" + i), "value-" + i);
        }
        System.err.println(map);
    }

    static class Key {
        private String name;

        public Key(String name) {
            this.name = name;
        }

        @Override
        public int hashCode() {
            return 1; //代表所有的key-value數(shù)據(jù)都會放到hashmap的同一個鏈表中
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Key other = (Key) obj;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    }
}