JAVA源码解读---HashMap目录扩展的奥秘

JAVA源码解读---HashMap目录扩展的奥秘

摘要：为了探索JAVA1.7源码中HashMap类数据的组织方法与目录扩展方法，本文通过对JAVA1.7源码中HashMap类源码的阅读与分析，得出结论：hashmap中存储数据的数据结构采用的是链表数组，目录是个数组，数组的成员是链表。冲突解决方法：典型的链地址法，冲突后，在链表头部插入数据。目录扩展方法：已二倍的方式扩展，一直到目录的最大上限。目录扩展的触发条件：装载因子的方式触发。从java中hashmap的实现可以看出，桶数据的组织方式并不是一种非常高效的方式。对检索效率不利。同时，数据扩展简单的采用二倍的扩展方法，也只是使用了最为粗暴的扩展方式，扩展开销较大。

关键字：JAVA，HashMap，目录组织方式，目录扩展方法，目录触发条件

本文转自http://blog.csdn.net/daliaojie/article/details/26236979

散列是一种非常重要的数据结构，在JAVA与dotNet中都有相对应事先的类供调用。我们知道hashmap的容量是动态增长的，此篇博客分析了java中，hashmap中关于目录扩展的过程。

先看hashmap的成员变量：

 static final int DEFAULT_INITIAL_CAPACITY = 16;

    static final int MAXIMUM_CAPACITY = 1 << 30;

    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    transient Entry[] table;

    transient int size;

    int threshold;

    final float loadFactor;

    transient int modCount;

其中

    transient Entry[] table;

这便是，hashmap中的散列的目录，可以看出，他是一个数组，里面存储了类。其他成员有，默认的目录长度
 DEFAULT_INITIAL_CAPACITY。默认的目录最大长度：
 static final int MAXIMUM_CAPACITY = 1 << 30;
默认的填充因子：
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
当然这些变量可以由构造函数初始化。
对应的成员变量为：

    transient int size;

    int threshold;

    final float loadFactor;

填充因子的意义为，达到这个比例后，目录需要扩张。为了探索，hash目录扩张的秘密：
我们从put操作看起，其实就是insert操作。
对了， 我们们的目录结构还没看完：

    transient Entry[] table;
我们看Entry是如何定义的：

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

很明显， 目录中的桶采用的数据组织方法为链表。
也就是说。hash的冲突解决方法为链地址法。
关于散列中解决冲突的方法连地址法的详细介绍可以自己百度。

直接看insert过程吧。

    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 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进行散列并计算出目录中对应的位置。从而获取该位置处的链表。并对该链表进行遍历，遍历时，检查是否该key已经存在，如果存在就用将新的value替换掉旧的value。

如果不存在。就调用

 addEntry(hash, key, value, i);

进行插入。并且是在改目录位置处插入。

我们看插入操作做了些什么：

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

方法的刚开始，获取了链表。

并头早了一个新的Entry，我们看对应的构造方法：

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

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

这个Entry的构造函数很明白了。

table[bucketIndex] = new Entry<>(hash, key, value, e);

实现了在bucktIndex处的连标的头部插入key-value的链表节点。明显这个插入过程还是比较高效的。

我们继续往后看。

addEntry(int hash, K key, V value, int bucketIndex)

该方法，在链表的头部插入新的节点后判断了当前size++与目录扩展阀值的关系。当达到分裂阀值后，执行

 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];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

方法传入了扩展后的目录长度。我们知道，目录是以2倍的方式，进行扩展的。并且最大有个限制，这里默认是1 <<30

resize方法里，先对新的目录长度进行检测，以防止，超过目录的最大长度。

然后new了一个新长度的目录。

然后执行

transfer(newTable);

源码如下：

    /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

方法的英文解释其实很明白了。他们将源目录中的所有元素进行遍历，经过对新目录长度的散列后，放进去了新的目录中。

解读一下吧。

for（）是对原目录的遍历控制。

然后do while是对目录位置处的链表进行遍历时的控制。

目录扩展后，便将就目录更换为新的目录。并更新了目录扩展的阀值。

我们看一下map的查询操作:

 public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry 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对应的目录位置，然后目录位置处对应的链表中，查询key是否存在。

做一下总结：

hashmap中存储数据的数据结构：链表数组。目录是个数组，数组的成员是链表。

冲突解决方法：典型的链地址法，冲突后，在链表头部插入数据。

目录扩展方法：已二倍的方式扩展，一直到目录的最大上限。

目录扩展的触发条件：装载因子的方式触发。

尾语：

从java中hashmap的实现可以看出，桶数据的组织方式并不是一种非常高效的方式。对检索效率不利。同时，数据扩展简单的采用二倍的扩展方法，也只是使用了最为粗暴的扩展方式。扩展开销较大。