摘要：为了探索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的实现可以看出，桶数据的组织方式并不是一种非常高效的方式。对检索效率不利。同时，数据扩展简单的采用二倍的扩展方法，也只是使用了最为粗暴的扩展方式。扩展开销较大。
JAVA源码解读---HashMap目录扩展的奥秘,布布扣,bubuko.com