HashMap - jdk1.7

1.底层存储是Entry<K,V>[] table,Entry对象里面还有个Entry<K,V> next指着下一个对象
    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
    }
2.对哈希冲突的对象采用头插入
    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    }
3.hashmap里面的元素个数，大于等于负载因子*数组长度时会扩容，扩容是新建一个数组，长度为之前的2倍，然后将原来的元素重新插入，顺序是从原链表开头元素遍历插入，由于头插法，先插入的会到链表后面。
4.若初始化定义元素个数为number，则数组长度为大于或等于number的2的幂次方的值中的最小值。例number=8，返回8；number=9，返回16。
5.数组长度为2的幂次方的原因是，根据哈希值获取数据下标时，不用哈希值/数组长度取模，可以用(数组长度-1) & 哈希值，这样效率快。
6.头插法在多线程put元素使链表同时扩容时，会新建2个数组，在对元素重新hash插入数组时，可能会造成环形链表。
7.头插法是因为，如果用尾插法需要遍历到链表的尾部，而1.8改用尾插法是因为它要判断链表长度是否等于8来转换红黑数，而这个计算长度本来就要遍历整个链表。
  而1.8的尾插法，还会避免1.7由于头插法多线程Put元素造成扩容时时可能造成的死循环。

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
{
    //HashMap默认存储元素个数为16，必须为2的幂次方
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    //HashMap最大存储元素个数为2的30次方
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //负载因子，比如默认存储元素个数为16，当实际个数为16*0.75=12时则扩容，新建一个长度为32的数组(原数组长度的2倍)，
    //把原来的元素按哈希值重新插入。
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //初始化一个空数组
    static final Entry<?,?>[] EMPTY_TABLE = {};

    //存储元素的数组，长度必须为2的幂次方
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

    //存储元素个数
    transient int size;

    //扩容临界值，当存储元素个数大于等于它时则扩容。等于初始化定义的元素个数*负载因子，即capacity*loadFactor
    int threshold;

    //负载因子
    final float loadFactor;

    //改为使用本地哈希算法(对key为String的元素)的阈值，默认为最大的整数。
    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;

    private static class Holder {

        //改为使用本地哈希算法的阈值。如果在系统属性配置了这个参数，则当初始化或扩容数组的长度大于等于这个值时，
        //会重新进行hash算法，这里主要是对String对象，
        //使用新的hash算法sun.misc.Hashing.stringHash32((String) k),因为String自带的容易产生哈希碰撞。
        static final int ALTERNATIVE_HASHING_THRESHOLD;

        static {
            //如果配置了系统jdk.map.althashing.threshold则赋值，否则为空
            String altThreshold = java.security.AccessController.doPrivileged(
                new sun.security.action.GetPropertyAction(
                    "jdk.map.althashing.threshold"));

            int threshold;
            try {
                threshold = (null != altThreshold)
                        ? Integer.parseInt(altThreshold)
                        : ALTERNATIVE_HASHING_THRESHOLD_DEFAULT;

                // disable alternative hashing if -1
                if (threshold == -1) {
                    threshold = Integer.MAX_VALUE;
                }

                if (threshold < 0) {
                    throw new IllegalArgumentException("value must be positive integer.");
                }
            } catch(IllegalArgumentException failed) {
                throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
            }

            ALTERNATIVE_HASHING_THRESHOLD = threshold;
        }
    }

    //获得大于或等于number的2的幂次方的值中的最小值。例number=8，返回8；number=9，返回16
    private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

    //初始化数组
    private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        int capacity = roundUpToPowerOf2(toSize);

        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

    //初始化哈希种子，并返回扩容时是否需要重新hash
    final boolean initHashSeedAsNeeded(int capacity) {
        //hashSeed初始值为0，switching=true时才可能会修改，所以这里一开始为false
        boolean currentAltHashing = hashSeed != 0;
        //sun.misc.VM.isBooted() jvm一般是启动的所以为true，
        //如果不设置系统属性jdk.map.althashing.threshold，ALTERNATIVE_HASHING_THRESHOLD默认为最大的整数，
        //所以为false。true && false = false
        boolean useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        //如果不设置系统属性jdk.map.althashing.threshold，则false ^ false = false
        boolean switching = currentAltHashing ^ useAltHashing;
        if (switching) {
            hashSeed = useAltHashing
                ? sun.misc.Hashing.randomHashSeed(this)
                : 0;
        }
        return switching;
    }

    //获取哈希值
    final int hash(Object k) {
        int h = hashSeed;
        //如果hashSeed不为0且对象是String则用另一个hash算法，因为String自带的hash算法容易产生哈希碰撞，
        //以防黑客精心构造哈希值相同的字符串造成链表过长。
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();

        //通过低位与高位的各种异或，使哈希值变得更随机，已减少哈希碰撞，jdk1.8去掉了这些复杂的异或，
        //因为用了红黑树就算哈希碰撞多也影响不大。
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    //通过哈希值计算该元素存在数组的哪个下标
    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        //比如数组长度是16，16-1是15，哈希值 & 0000 1111，则取值范围为0-15，这样子效率比取模运算%效率高很多。
        //这也是数组长度必须为2的幂次方的原因。
        return h & (length-1);
    }

    //添加元素
    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            //初始化数组
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        //遍历链表上所有的元素，如果有相等的key，则覆盖value，然后返回oldVale
        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++;
        //无相等key则添加元素
        addEntry(hash, key, value, i);
        return null;
    }

    //当key=null时，默认该元素放在数组下标为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;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

    //数组扩容
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

    //将旧数组上的元素迁移到新数组上，使用头插法重新插入，但是多线程同时执行此方法时，可能会出现环形链表。
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                //是否需要重新获取哈希值
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
    }
}