JDK源码之-HashMap

JAVA集合框架主要有两组接口，一个是java.util.Collection，另一个是java.util.Map。Map是我们经常使用的一个集合接口，它是一种<K,V>键值对型的结构。常用的实现有HashMap，TreeMap。本文基于JDK1.7来分析一下HashMap 的实现。

Map接口的主要方法

int size();

boolean containsKey(Object key);

V get(Object key);

V put(K key, V value);

V remove(Object key);

Set<K> keySet();

Set<Map.Entry<K, V>> entrySet();

HashMap的具体实现

HashMap有几个构造函数，HashMap(), HashMap(int initialCapacity), HashMap(int initialCapacity, float loadFactor)，HashMap(Map<? extends K, ? extends V> m)。不同的构造函数决定了HashMap的初始容量和装填因子。HashMap是一种数组+链表的结构，它声明了一个Entry<K,V>[] table数组，Entry<K,V>本身是一个链表结构。如不自定义，HashMap默认的初始容量为16，初始装填因子为0.75。我们接下来分别从HashMap常用的操作来看看它是如何实现的。
V put(K key, V value) //向HashMap中添加一个元素

    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, key, value, i);
        return null;
    }

1.HashMap允许key为null,找到table[0]处的Entry<K,V>，也就是说key为null的Entry永远只会被放在数组的第一位的链表上。获取到table[0]处的Entry并对它进行遍历，如果找到已经存在了key为null的Entry，则用新的value替换掉旧的Entry的value。如果没有找到则在表头添加一个新的Entry，注意，在任何添加新元素的时候都需要注意HashMap的size()是否到达了阈值，该阈值=HashMap容量*装填因子。例如不自定义HashMap容量和装填因子时，该阈值为16*0.75=12即当HashMap中有12个Entry的时候，HashMap会自动进行一次扩容，具体的扩容机制我们后面会提到。

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

2.根据key的hash值找到数组中映射的位置，JDK中的做法是h & (length-1)，key的hash值和数组table的长度减一作与操作。HashMap中table数组的长度永远是2的幂次方，即使你想创造一个奇数个数的HashMap。之所以这样做是的原因是capacity为偶数，(capacity-1)为奇数，在与key的hash值做&操作时，会大大减少冲突的产生。

while (capacity < initialCapacity)
   capacity <<= 1;

3.在数组映射的位置上替换或添加新的Entry。同样遍历Entry，试图找寻链表中已有的Entry，如果找到了key相同或者满足key.equals(k)方法的Entry，则用新的Value替换掉旧的Entry的Value；如果没找到则以在表头添加Entry的形式加入到已有的链表中。

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

V get(Object key);//获取HashMap中指定Key的值

    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

1.如果key为null，拿到table[0]位置的Entry，对其进行遍历，若找到key为null的Entry，则返回；若未找到，则直接返回null。
2.同样的，对于key不为null的情况，先计算其hash值，然后再找到该key在table中的位置，获取到该位置处的Entry进行遍历。

    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        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 != null && key.equals(k))))
                return e;
        }
        return null;
    }

V remove(Object key);//移除HashMap中指定Key的值

    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

如果key为null，则获取table[0]位置的Entry，否则计算该key的hash值找到该key在table中的位置处的Entry。对其进行遍历，直至找到key相同或者满足key.equals(k)条件的Entry，对其进行一次单链表节点的删除操作。

接下来我们来分析一下HashMap的自动扩容机制，当HashMap中Entry数目达到了阈值时，就需要对它进行扩容，容量为两倍于当前table的长度，并将现有table中所有的Entry进行rehash添加到新的newTable中去。

    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];
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;
        transfer(newTable, rehash);
        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;
            }
        }
    }

依然是通过key的hash值与(newTable.length-1)做与操作取模确定好新的位置，以下代码相当于在表头添加Entry。

e.next = newTable[i];

newTable[i] = e;

我们分析完了HashMap基本常用的操作和扩容在JDK1.7中的实现，在后续的JDK源码解读中还会给大家带来JDK1.8版本与1.7版本的异同。