基于JDK1.7的HashMap源码阅读分析

此版本是基于JDK1.7的HashMap。HashMap的数据结构是数组加单向链表。创建HashMap时，数组长度缺省值为16，最终调用的构造方法如下:    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);
        // Find a power of 2 >= initialCapacity        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;
        this.loadFactor = loadFactor;        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);        table = new Entry[capacity];        useAltHashing = sun.misc.VM.isBooted() &&                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);        init();    }数组的长度capacity为2的n次幂。也就是说，即便创建HashMap时，指定的长度为15，但是实际创建的结果也会是15的下一个2的整数次幂，也就是16；这里还有一个关键的属性threshold，该属性关系到HashMap何时扩容。threshold值由数组长度*加载因子（loadFactor缺省值为0.75）得来。
为什么说HashMap里每个数据的元素是个单向链表，是由于HashMap的内部类Entry的结构所致static class Entry<K,V> implements Map.Entry<K,V> {        final K key;        V value;        Entry<K,V> next;        int hash;
        /**         * Creates new entry.         */        Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }        .....
    }每个Enty包含一个他的下一个元素的指针，来构成单向链表结构。HashMap里存储的K，V，实际就是Entry的K,V
HashMap的put方法。    public V put(K key, V value) {        if (key == null)            return putForNullKey(value);        int hash = hash(key);        int i = indexFor(hash, table.length);        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
4000
, key, value, i);        return null;    }
putForNullKey（value）方法使的HashMap可以存储key为null的数据，并且会存在Entry[0]这列，且hash值为0；hash(key)方法计算key的hash值。
indexFor(hash, table.length)方法来计算该Entry在数组中的位置，    static int indexFor(int h, int length) {        return h & (length-1);    }假如HashMap的桶（Entry数组）长度为16（0001 0000），此时要存的Entry的key的hash值为31（0001 1111）那么就会得出，此Entry在桶中的位置为(0001 1111)&(0000 1111)=(0000 1111)即15。这个方法实际是用来快速取余数（只对被除数为2的整数次幂有效，这也是为什么HashMap中桶的长度为2的整数次幂）。
        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);        return null;剩下的代码，会在table[i]这个单向链表中寻找Entry所在的位置，如果有相同的Entry，则覆盖并返回原来的值；如果没有，则调用addEntry方法。
    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);    }
调用addEntry方法时，会涉及到扩容问题。这跟上面提到的threshold有关，threshold=桶的长度*加载因子（loadFactor缺省值为0.75），当我们默认创建一个桶的长度为16，加载因子为0.75的HashMap时，threshold为12。也就是说当此HashMap含有12个Entery以后，再加入Entry,并且该桶中已经存在其他Entry，就需要进行扩容（注：HashMap的size方法，返回的是Entry的个数）。为什么需要扩容，主要是为了提升获取元素的效率。如果HashMap中的每个元素能平均分布在每个桶中，那么获取元素的时间复杂度为O（1）。但如果发生哈希碰撞，即有的桶中存在多个Entry，那获取Entry还需要遍历该链表，会很耗时。