Java HashMap源码简析

Java HashMap的核心是数组加链表结构，数组主要用于存储和快速寻址，链表主要用户解决冲突。当然这是概念上的，源码体现的更加详细和丰满，下面是一些源码关键点：

成员变量：

     **     * 默认初始容量必须是2的幂（性能问题，后面会涉及）     */    static final int DEFAULT_INITIAL_CAPACITY = 16;    /**     * 最大容量     */    static final int MAXIMUM_CAPACITY = 1 << 30;    /**     * 默认负载参数     */    static final float DEFAULT_LOAD_FACTOR = 0.75f;        //Entry类型数组    transient Entry[] table;

Entry类：

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

next是实现链表的关键，HashMap里的链表是个单链表，后插入的在链表头，先插入的在链表尾。

get方法：

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

注意到get方法是通过indexFor方法来寻找数组的索引号，indexFor的参数是数组长度和对key的hashCode再次hash的结果，找到数组索引号后遍历链表寻找元素。

hash方法：

static int hash(int h) {        // This function ensures that hashCodes that differ only by        // constant multiples at each bit position have a bounded        // number of collisions (approximately 8 at default load factor).        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }

indexFor方法：

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

根据key定位数组的索引号方法很多，比如我们都很熟悉的取模方法（数组长度模key的hashCode）。源码的做法是对key的hashCode再次进行哈希，然后与数组长度-1相与。

为什么要对key的hashCode再次哈希？源码里的javadoc的解释是避免过差的key的hashCode方法。我认为跟indexFor采用的跟数组长度-1相与来寻址有关，试想如果数组长度16（数组长度-1的二进制表示为：1111,1111），但是我的key为（1111,1111,1111），（1110,1111,1111），（1101,1111,1111），是不是三个key都映射到同一个数组索引号了？再次hash的原因大概如此，更详细原理可以参考：http://www.365doit.com/all/news/hashmapdeep.html。

那么为什么不用取模方法用相与呢？因为相与操作比取模性能更好。那么为什么是跟数组长度-1相与呢？因为在设置数组长度为2的幂的情况下，用数组长度-1相与可以减少冲突。更详细的可以参考：http://www.iteye.com/topic/539465

put方法：

public V put(K key, V value) {        if (key == null)            return putForNullKey(value);        int hash = hash(key.hashCode());        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, key, value, i);        return null;    }

put方法源码现实很清晰的说明了一个事情：插入的key value pair如果key重复了，新的value将覆盖老的value。如果key不重复，那么说明冲突了，方法addEntry把元素加入到hashMap，下面看看addEntry的源码：

void addEntry(int hash, K key, V value, int bucketIndex) {        Entry<K,V> e = table[bucketIndex];        table[bucketIndex] = new Entry<>(hash, key, value, e);        if (size++ >= threshold)            resize(2 * table.length);    }

取出原来数组里面已经有的Entry对象，作为参数构造一个新的Entry，放回数组。这个Entry的构造函数式怎么样的？

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

真相大白，它把原来的Entry作为新插入Entry的next引用。即在冲突的情况下，新元素在链表头，老元素在链表尾。