Java容器HashMap源代码解析

写在前面的话

本文针对的是Java1.6进行的源码分析，与其他版本可能存在差异。

哈希表

HashMap是基于哈希表来实现的，在介绍HashMap前，我们先了解一下哈希表。哈希表查找效率非常高，只需要O(1)的时间，相比之下，在一个大小为n的数组中查找数据，则需要O(n)时间。哈希表是基于数组来实现的，它的设计思路是把关键字key通过hash函数映射到数组的不同位置上。这样，当进行查找操作时，可以根据key直接得到数据在数组中的下标，只用常数时间就可以完成查找工作。

hash函数有多种实现方法：除法散列法、乘法散列法、全域散列法等。最常用的就是除法散列法，HashMap也是用改方法实现的hash函数。除法散列法就是通过取key除以数组大小m的余数，来将关键字k映射到m个槽的某一个中去。

在哈希表中，数组下标是通过hash函数计算出来的，这样不可避免的会发生多个关键字key映射到同一个数组下标的位置，这种情况我们称之为“碰撞”。主要有两种方法来解决碰撞，一种是链表法，一种是开放寻址法。开放寻址法是在发生碰撞后，根据一定的探查算法，继续探查，直到找到空槽为止。链表法是把散列到同一个槽中的所有元素都放在一个链表中。HashMap就是采用链表法来解决碰撞的。

HashMap源代码解析

1.HashMap的底层数据结构

上面说到HashMap是用哈希表来实现的，采用的是链表法来解决碰撞，所以哈希表的底层数据结构就是数组和链表。HashMap定义了一个Entry类型的数组table用来存放数据，我们就先从HashMap的内部类Entry看起。源代码如下：

    //实现了map.Entry接口    static class Entry<K,V> implements Map.Entry<K,V> {        final K key;        V value;        //存放链表的下一个值，用于解决碰撞        Entry<K,V> next;        final int hash;        /**         * Creates new entry.         */        Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }        public final K getKey() {            return key;        }        public final V getValue() {            return value;        }        public final V setValue(V newValue) {        V oldValue = value;            value = newValue;            return oldValue;        }        //实现equal方法，如果key和value都相等，则返回true        public final boolean equals(Object o) {            if (!(o instanceof Map.Entry))                return false;            Map.Entry e = (Map.Entry)o;            Object k1 = getKey();            Object k2 = e.getKey();            if (k1 == k2 || (k1 != null && k1.equals(k2))) {                Object v1 = getValue();                Object v2 = e.getValue();                if (v1 == v2 || (v1 != null && v1.equals(v2)))                    return true;            }            return false;        }        //实现hashCode方法        public final int hashCode() {            return (key==null   ? 0 : key.hashCode()) ^                   (value==null ? 0 : value.hashCode());        }        public final String toString() {            return getKey() + "=" + getValue();        }        //在添加元素时，会调用此方法，在这不进行任何操作        //在LinkedHashMap中会重写该方法        void recordAccess(HashMap<K,V> m) {        }        //在删除元素时，会调用此方法，在这不进行任何操作        //在LinkedHashMap中会重写该方法        void recordRemoval(HashMap<K,V> m) {        }    }

Entry实现了map.Entry接口，包含了键和值，next也是一个Entry对象，用于形成一个链表来解决碰撞。

2.HashMap属性

知道了HashMap的底层数据结构后，先来看HashMap中定义的一些重要属性：

    /**     * Entry类型数组，用于存放数据，可以根据需要扩容     */    transient Entry[] table;    /**     * HashMap的大小     */    transient int size;    /**     * 临界值，当HashMap大小大于临界值时，会进行扩容，threshold=capacity * load factor     */    int threshold;    /**     * 加载因子     */    final float loadFactor;    /**     * 修改次数，同其他容器一样     */    transient volatile int modCount;

这里，详细说一下加载因子。加载因子其实就是HashMap中存储数据的饱和度，当HashMap中存储存储数据的个数size大于它的容量和加载因子的乘积后，HashMap就会自动扩容。所以，如果加载因子取值过大，虽然容器利用率高了，但是也加大了碰撞的可能性，导致查询效率低下；如果加载因子取值过小，虽然减少了碰撞的概率，但是容器利用率会很低，可能容器中还没存储多少数据，就要扩容了，造成很大的浪费。加载因子的取值需要折中考虑，HashMap给定了加载因子的默认值0.75，我们一般用给定的默认值即可。顺便再看一下HashMap给定的几个默认值：

    /**     * 默认容量大小，容量大小必须是2的幂次方     */    static final int DEFAULT_INITIAL_CAPACITY = 16;    /**     * 最大容量     */    static final int MAXIMUM_CAPACITY = 1 << 30;    /**     * 默认加载因子     */    static final float DEFAULT_LOAD_FACTOR = 0.75f;

对于容量大小，注释特别提到必须是2的幂次方。那么，为什么会有这个要求呢？我们可以从HashMap的indexFor()方法找到答案。该方法代码如下：

    /**     *返回hashCode的索引值     */    static int indexFor(int h, int length) {        return h & (length-1);    }

这个方法的作用是计算出hashCode对应数组table中的索引值。上面已经说了HashMap是通过取余来进行散列，但是取余要用到除法，计算效率比较低。当length大小为2的幂次方时，h&(length-1)与h%length是等效的，但是运算速度提升很大。所以，HashMap要求容量必须是2的整次幂。

3.构造方法

HashMap提供了四种构造方法，如下：

    /**     * 给定容量和加载因子的构造方法     */    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);        //找到大于initialCapacity的最小的2的幂次方，保证容量一直都是2的幂次方        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;        this.loadFactor = loadFactor;        //计算临界值        threshold = (int)(capacity * loadFactor);        //初始化数组        table = new Entry[capacity];        //初始化方法，在HashMap中并没有做任何操作，在LinkedHashMap中会重写        init();    }    /**     * 只给了初始容量的构造方法，加载因子会直接用默认值     */    public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }    /**     * 默认构造函数，加载因子和容量都用默认值     */    public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR;        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);        table = new Entry[DEFAULT_INITIAL_CAPACITY];        init();    }    /**     * 带有map参数的构造函数     */    public HashMap(Map<? extends K, ? extends V> m) {        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);        //调用putAllForCreate方法        putAllForCreate(m);    }

前三个构造函数都比较好理解，我们可以看看最后一个构造函数的putAllForCreate方法是如何实现的。代码如下：

    private void putAllForCreate(Map<? extends K, ? extends V> m) {        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {            Map.Entry<? extends K, ? extends V> e = i.next();            //遍历Iterator，把每个键值对放到table中            putForCreate(e.getKey(), e.getValue());        }    }    private void putForCreate(K key, V value) {        //hashMap是允许键为null的，如果键为null，则hashCode值就为0        int hash = (key == null) ? 0 : hash(key.hashCode());        //计算hashCode在table数组中的索引，上面已经介绍过这个方法        int i = indexFor(hash, table.length);        //计算出位置i后，遍历table[i]的next链表，判断是否是重复的key，如果是重复的        //则直接替换原先的value值        for (Entry<K,V> e = table[i]; e != null; e = e.next) {            Object k;            if (e.hash == hash &&                ((k = e.key) == key || (key != null && key.equals(k)))) {                e.value = value;                return;            }        }        //如果不是重复的key，则调用createEntry方法，新建Entry        createEntry(hash, key, value, i);    }    //计算hash值    static int hash(int h) {        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }    //创建Entry，并存入到table中    void createEntry(int hash, K key, V value, int bucketIndex) {        Entry<K,V> e = table[bucketIndex];        //新建Entry，并把它放在链表的头部        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);        //大小加1        size++;    }

4.获取数据

    public V get(Object key) {        //HashMap允许key为null，如果key为null，单独处理        if (key == null)            return getForNullKey();        //计算hash值，并得到索引，然后遍历所引处的链表，查找value        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;    }    //单独处理key为null的方法    private V getForNullKey() {        //HashMap会把key为null的Entry直接放在table[0]位置上，直接在该位置遍历链表就可以了        for (Entry<K,V> e = table[0]; e != null; e = e.next) {            if (e.key == null)                return e.value;        }        return null;    }

HashMap的put和get方法基本上是最常用的了，get方法的实现是先判断key值是否为null，这是因为HashMap是允许key值为null的，如果是null，则调用getForNullKey()方法单独处理；如果不为null，则计算key的哈希值，然后计算出在table中的索引，遍历索引处的链表，判断是否有与key值相等的，如果有，则返回对应的value，没有就返回null。注意，在HashMap里如果查找的键不存在，会返回null；而如果在python的字典中查找不存在的键，则就会报异常。

5.存储数据

    public V put(K key, V value) {        //HashMap允许key为null，如果key为null，单独处理        if (key == null)            return putForNullKey(value);        //计算hash值，得到索引        int hash = hash(key.hashCode());        int i = indexFor(hash, table.length);        //遍历索引处链表，如果key值已经存在，则替换原先的value        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;                //此方法在HashMap中没有任何操作，在LinkedHashMap中会重写                e.recordAccess(this);                return oldValue;            }        }        //修改数加1        modCount++;        //如果key值不存在，在调用此方法添加Entry        addEntry(hash, key, value, i);        return null;    }    //单独处理key为null的方法    private V putForNullKey(V value) {        //key为null的entry存放在table[0]处，所以先在table[0]处查找是否有key为null        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++;        //如果不存在key为null的entry，则在table[0]处添加entry        addEntry(0, null, value, 0);        return null;    }    //添加entry方法    void addEntry(int hash, K key, V value, int bucketIndex) {        //添加entry        Entry<K,V> e = table[bucketIndex];        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);        //如果HashMap的大小已经到达了临界值，则需要对table扩容        //为了保证容量一直是2的幂次方，每次直接扩容到原先的2倍        if (size++ >= threshold)            resize(2 * table.length);    }    //扩容方法    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];        //把原来的数据都存放到新的table中        transfer(newTable);        table = newTable;        //重新计算临界值        threshold = (int)(newCapacity * loadFactor);    }    //转换方法    void transfer(Entry[] newTable) {        Entry[] src = table;        int newCapacity = newTable.length;        //遍历原先的table        for (int j = 0; j < src.length; j++) {            Entry<K,V> e = src[j];            if (e != null) {                src[j] = null;                //遍历链表                do {                    Entry<K,V> next = e.next;                    //计算在新table中的索引值                    int i = indexFor(e.hash, newCapacity);                    e.next = newTable[i];                    newTable[i] = e;                    e = next;                } while (e != null);            }        }    }

HashMap的put方法稍微复杂些，与get方法类似，它也会先判断key值是否为null，如果为null，则调用putForNullKey()方法处理；如果不为null，则找到索引值，遍历索引处的链表，判断key是否已存在，如果存在，则直接替换value，不存在的话，就调用addEntry()方法。我们再来看addEntry()这个方法，它与上文已经介绍过的createEntry()方法相似，不同之处在于多了扩容的步骤。这是因为createEntry()方法只在构造函数用到，这种情形下，table的容量已经提前计算出来，肯定够用，不必再考虑扩容的情形。而addEntry()是在table中新增数据，是有可能使得size达到临界值的，所以必须要考虑扩容。为了保证容量一直都是2的幂次方，所以每次扩容都是扩到原先的2倍。

下面我们再来看下HashMap是如何去扩容的。它会先判断是否已经达到最大容量了，如果已经达到最大容量了，则不再扩容。然后会通过调用transfer()方法，把原先的table中的所有值存入到新的table中，最后再重新计算临界值。

除了put方法，HashMap还提供了putAll()方法，如下：

    public void putAll(Map<? extends K, ? extends V> m) {        int numKeysToBeAdded = m.size();        //如果m没有要添加的key，不做任何除了        if (numKeysToBeAdded == 0)            return;        //如果要添加的key的数量已经超过了临界值，则计算新的容量并扩容        if (numKeysToBeAdded > threshold) {            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);            if (targetCapacity > MAXIMUM_CAPACITY)                targetCapacity = MAXIMUM_CAPACITY;            int newCapacity = table.length;            while (newCapacity < targetCapacity)                newCapacity <<= 1;            if (newCapacity > table.length)                resize(newCapacity);        }        //遍历m，把m的键值对依次put到table中        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {            Map.Entry<? extends K, ? extends V> e = i.next();            put(e.getKey(), e.getValue());        }    }

6.判断数据是否存在

HashMap提供了containsKey()和containsValue()方法，分别用来判断是否存在某个key和某个value值。先来看containsKey()方法：

    public boolean containsKey(Object key) {        return getEntry(key) != null;    }    final Entry<K,V> getEntry(Object key) {        //计算hash值，得到索引        int hash = (key == null) ? 0 : hash(key.hashCode());        //遍历索引处链表，如果Key存在，就返回相对应的entry，如果不存在，则返回null        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;    }

这段代码与get()方法中去查找value的代码类似，不再详述。下面再看containsValue()方法。

    public boolean containsValue(Object value) {        //HashMap允许value为null，null不能用equals方法直接比较，所以单独处理        if (value == null)            return containsNullValue();        Entry[] tab = table;        //查找value，无法得到索引，只能遍历table        for (int i = 0; i < tab.length ; i++)            for (Entry e = tab[i] ; e != null ; e = e.next)                if (value.equals(e.value))                    return true;        return false;    }    //单独处理value为null的情形    private boolean containsNullValue() {        Entry[] tab = table;        for (int i = 0; i < tab.length ; i++)            for (Entry e = tab[i] ; e != null ; e = e.next)                if (e.value == null)                    return true;        return false;    }

7.删除数据

    public V remove(Object key) {        Entry<K,V> e = removeEntryForKey(key);        //如果key存在，则返回对应的value；key不存在，则返回null        return (e == null ? null : e.value);    }    //删除entry方法    final Entry<K,V> removeEntryForKey(Object key) {         //计算hash值，得到索引        int hash = (key == null) ? 0 : hash(key.hashCode());        int i = indexFor(hash, table.length);        Entry<K,V> prev = table[i];        Entry<K,V> e = prev;        //遍历链表，找到对应的entry，如果是链表的头结点，则直接table[i] = next;        //如果是中间结点，则让entry的上一个结点的next指向entry的下一个结点        while (e != null) {            Entry<K,V> next = e.next;            Object k;            if (e.hash == hash &&                ((k = e.key) == key || (key != null && key.equals(k)))) {                modCount++;                size--;                //如果是链表头结点，直接将下一个结点赋值给table[i]                if (prev == e)                    table[i] = next;                else                    prev.next = next;                //此方法在HashMap中没有任何操作，在LinkedHashMap中会重写                e.recordRemoval(this);                return e;            }            prev = e;            e = next;        }        return e;    }

remove()方法的逻辑是先计算出索引值，然后遍历索引处的链表，找到与给定key相等的entry。如果entry是链表的头结点，则直接将entry的下一个结点赋值给table[i]；如果是链表的中间结点，则将entry的上一个结点的next指向entry的下一个结点。如果key存在，则删除后返回对应的entry，如果不存在，则返回null。所以，即使去删除HashMap中不存在的Key，也不会出现异常的。

8.其它方法

clear()方法：把数组的所有值置为null，size置为0，如下：

    public void clear() {        modCount++;        Entry[] tab = table;        //把table的所有值置为null        for (int i = 0; i < tab.length; i++)            tab[i] = null;        size = 0;    }

isEmpty()方法：判断是否为空

    public boolean isEmpty() {        return size == 0;    }

size()方法：返回大小

    public int size() {        return size;    }

9.遍历哈希表

关于哈希表的遍历用法和代码解析请参考Java HashMap遍历方法和源代码解析