HashMap 工作原理源码分析

用了HashMap这么久，一直没有深入了解过，用了些时间认真看了一下，决定写下来，对需要的人是一种分享，更是对自己的记录吧，先看一段平时使用HashMap存取键值对的代码，应该都很熟悉，如下：

		Map<String, String> map = new HashMap<String, String>();
		map.put("name", "ib");
		map.put("age", "32");
		Log.i("TestActivity", "---" + map.get("name") + "---");
		Log.i("TestActivity", "---" + map.get("age") + "---");

最简单的示例，输出如下：

	08-03 12:44:34.061: I/TestActivity(16984): ---ib---
	08-03 12:44:34.061: I/TestActivity(16984): ---32---

那么下面我们就来从源码角度来看一下这个简单的例子的调用流程。

首先在第一行新建了一个HashMap对象，我们在java.util包中找到并打开HashMap.java文件（此文件在不同android版本下有所区别，本文使用的是4.0的源码），找到HashMap的构造函数，如下：

    public HashMap() {
        table = (HashMapEntry<K, V>[]) EMPTY_TABLE;
        threshold = -1; // Forces first put invocation to replace EMPTY_TABLE
    }

其中table和EMPTY_TABLE是HashMap的成员变量，分别为：

    transient HashMapEntry<K, V>[] table;

    private static final Entry[] EMPTY_TABLE
            = new HashMapEntry[MINIMUM_CAPACITY >>> 1];

这里的MINIMUM_CAPACITY也是HashMap的成员变量

    private static final int MINIMUM_CAPACITY = 4;

所以table最终为一个长度为2的HashMapEntry数组，HashMapEntry为HashMap的内部类，代码如下：

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

        HashMapEntry(K key, V value, int hash, HashMapEntry<K, V> next) {
            this.key = key;
            this.value = value;
            this.hash = hash;
            this.next = next;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V value) {
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

        @Override public final boolean equals(Object o) {
            if (!(o instanceof Entry)) {
                return false;
            }
            Entry<?, ?> e = (Entry<?, ?>) o;
            return Objects.equal(e.getKey(), key)
                    && Objects.equal(e.getValue(), value);
        }

        @Override public final int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                    (value == null ? 0 : value.hashCode());
        }

        @Override public final String toString() {
            return key + "=" + value;
        }
    }

HashMapEntry实现了Entry接口，Entry接口为Map.java的内部接口，可以看到新建HashMapEntry对象的时候，注意有一个HashMapEntry类型的next成员变量，可以看出HashMapEntry对象采用了链表的数据结构。

以上，新建了一个HashMap对象时，主要就是产生了table对象数组。

下面来看下例子中第二行，第三行put的操作，找到HashMap中put方法，如下：

     public V put(K key, V value) {
        if (key == null) {
            return putValueForNullKey(value);
        }

        int hash = secondaryHash(key.hashCode());
        HashMapEntry<K, V>[] tab = table;
        int index = hash & (tab.length - 1);
        for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
            if (e.hash == hash && key.equals(e.key)) {
                preModify(e);
                V oldValue = e.value;
                e.value = value;
                return oldValue;
            }
        }

        // No entry for (non-null) key is present; create one
        modCount++;
        if (size++ > threshold) {
            tab = doubleCapacity();
            index = hash & (tab.length - 1);
        }
        addNewEntry(key, value, hash, index);
        return null;
    }

首先会执行key的hashCode()方法，这里key为String类型，调用的String的hashCode()方法，然后调用secondaryHash(int h)方法，如下：

    private static int secondaryHash(int h) {
        // Doug Lea's supplemental hash function
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

可见secondaryHash(int h)方法进行了一系列的位运算，返回的int类型数值为hash值，然后根据此hash值与table长度做运算得到index，接着执行到for循环， 由于tab[index]为空，所以进不到for循环里面去，最后会执行到addNewEntry(key, value, hash, index)方法，看下这个方法代码：

    void addNewEntry(K key, V value, int hash, int index) {
        table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
    }

可见这里new了一个HashMapEntry对象，放在table数组中下标为index处。在文章开头例子中我们存入了两个键值，
存入第一个“name”的时候，在执行到for循环时，判断table[index]处的是否存在HashMapEntry对象，由于我们第一次传，所以肯定不存在，为空，那么所以进不到for循环里面去，直接执行了addNewEntry()方法，在table[index]处存入新建的HashMapEntry对象，然后在存入第二个“age”时，在执行for循环时，同样要判断table[index]处是否存在 HashMapEntry对象，那么此处如果index与存入“name”的时候相同，那么就会进入到for循环里面，由代码可见index相同的条件就是key的hasCode()方法返回值相同；然后会进入到for循环里面会执行key.equals()方法，如果这个方法返回true，那么就会执行替换操作，将新传入的value值替换掉原来的value值，之后就return，不会执行到下面的addNewEntry()方法；如果返回的是false，那么就跳出for循环，执行addNewEntry()方法，此方法中这句代码很重要，这句代码的意思是，将新new出来的HashMapEntry对象存入到table数组的index处，并让新的对象指向原来的对象，因为在new新对象的时候，原来的对象已经作为构造参数传入，这里就是上文中提到的HashMapEntry采用了链表的数据结构。

最后看一下HashMap 的get()方法，代码如下：

    public V get(Object key) {
        if (key == null) {
            HashMapEntry<K, V> e = entryForNullKey;
            return e == null ? null : e.value;
        }

        // Doug Lea's supplemental secondaryHash function (inlined)
        int hash = key.hashCode();
        hash ^= (hash >>> 20) ^ (hash >>> 12);
        hash ^= (hash >>> 7) ^ (hash >>> 4);

        HashMapEntry<K, V>[] tab = table;
        for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
                e != null; e = e.next) {
            K eKey = e.key;
            if (eKey == key || (e.hash == hash && key.equals(eKey))) {
                return e.value;
            }
        }
        return null;
    }

get方法也是根据传入的key计算了index的值，然后for循环查看index处是否存在HashMapEntry对象，如果不存在，返回null，如果存在则遍历index处已存入的链表，调用key.equals()方法来取出与传入的key 相等的那个节点的值 value，返回return。

以上就是文章开头的实例代码的执行过程分析，总结起来重点有三点：

1. table为一个存HashMapEntry对象的数组，也就是键值对，一个index处存一个HashMapEntry对象，index处“存入”多个键值对的情况，是以链表的形式来存储的，注意一个index处不是存多个键值对对象。

2. put(), get()方法中都用到了for循环遍历某一个index处的所有键值对，put时利用key的equals()方法来判断是否需要替换原来的value值，get方法利用key的equals()方法来判断是否输入的key是否存在value值，没有则返回null。

3. addNewEntry()方法中，将原来的table[index]作为参数来传入，从而来构建新的table[index]对象，这样才会使put()，get()方法中的for循环中e.next可以正常执行的前提，这是实现链表数据结构的关键一步。