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

如果不存在。就调用

addEntry(hash, key, value, i);

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

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

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，我们看对应的构造方法：

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

这个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<K,V> e = src[j];
if (e != null) {
src[j] = null;
do {
Entry<K,V> 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<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对应的目录位置，然后目录位置处对应的链表中，查询key是否存在。

做一下总结：

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

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

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

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

尾语：

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