HashMap源码分析

　　在上一篇博客中，大致介绍了散列以及Java Map的结构，这一篇主要分析HashMap的源代码，主要理解HashMap是如何保存数据、取数据、如何扩容、遍历的效率的对比。分析的源码版本为：java version “1.7.0_71”。

　　（1）构造函数

　　我个人最常用的构造函数是参数为空的，这个构造函数会调用另外一个带参数的构造函数， 并传入默认容量16和默认的loadFactor 0.75。这个构造函数比较简单，只进行校验参数和赋值的操作。

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

this.loadFactor = loadFactor;
threshold = initialCapacity;
init();
}

　　（2）接下来是重要的put方法，put方法用于将键值对保存到Map中，让我们来具体分析一下。

　　

public V put(K key, V value) {
//若table为空的table，首先进行一些初始化操作
//table初始长度为16
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
//若key为null,则将value放到table第0个位置
//若有值，将覆盖
return putForNullKey(value);
//对key进行一次hash，目的在于使得获得的hash值中的0、1均匀
int hash = hash(key);
//获得该key在table中的位置
int i = indexFor(hash, table.length);
//获得i这个位置的Entry对象，判断是否为空，若不为空则遍历i这个位置的链表，如果有相同的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;
e.recordAccess(this);
return oldValue;
}
}

modCount++;
//往一个位置i添加Entry
addEntry(hash, key, value, i);
return null;
}

　　然后看看addEntry的实现。

　　

void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
//两倍扩充容量
resize(2 * table.length);
//重新计算hash值
hash = (null != key) ? hash(key) : 0;
//计算在新table中的位置
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}

//扩容
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的过程其实也挺简单，只是根据initHashSeedAsNeeded(newCapacity)的结果决定是否需要rehash
//如果需要rehash就重新hash一次，找到新位置，否则就根据原来的hash值找到在新表中的位置
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

　　至此put方法已经分析完毕，总结一下：（1）如果key为null，将Entry放到第一个位置，如果存在则覆盖。（2）对key进行hash，找到位置，如果存在相同的key则覆盖。（3）判断一下是否需要扩容，如需要则将size变成2倍，根据hashSeed计算是否需要rehash，将已经存在的Entry赋值到新table。（4）将新的Entry放到合适的位置。

　　接下来分析一下get方法。

public V get(Object key) {
//key为null，去第0个位置找
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);

return null == entry ? null : entry.getValue();
}

final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
//计算hash值
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
//找到相应位置并开始遍历，找到key相等的Entry然后返回value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}

　　get方法总结如下：（1）判断key是否为null，如果是去第0个位置取值。（2）计算hash值，找到在table中的位置，遍历那个位置上的Entry链表，找到key相等的并返回value。

　　HashMap有两种典型的遍历方式。

Map<String, String> map = new HashMap<String, String>();
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key : " + entry.getKey() + ", value" + entry.getKey());
}
Set<String> set = map.keySet();
Iterator<String> it = set.iterator();
while (it.hasNext()) {
String key = it.next();
System.out.println("key : " + key + ", value" + map.get(key));
}

　这两种遍历方式调用的keySet和entrySet方法，本质上没有太大的区别，都调用了HashIterator的nextEntry方法，keySet调用的是nextEntry.getKey方法。但是从最终的遍历来看，entrySet的遍历效率应该是比keySet稍高的，推荐用这个方式。