Thinking in Java之HashMap源码分析
欢迎讨论、交流，转载请注明出处，3Q!
前言
在前面的文章中笔者就Map接口和Map接口的实现原理:内部哈希映射技术做了一个简单的
分析，并且对hashCode方法做了一些阐述。可能有些混乱，不过理解这些是弄懂HashMap
的前提，也能帮助我们更好的解析hashMap的源码。
HashMap类设计
HashMap是基于哈希表的Map接口的非同步实现，它提供所有可选的映射操作，并允许使
用null键和null值。此集合不保证映射的顺序，特别不保证其顺序永久不变。
首先我们先看下HashMap类的头部：
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable 对于它的分析就不多做解释了，AbstractMap类主要是帮助我们自定义自己的Map实现类。
1、底层实现
接下来我们看看HashMap的底层是如何实现的。在这之前我们先对数据结构略作分析。
在java语言中，最基本的结构分为两种：其一为数组，其二为模拟指针(引用)说白了就是
链表。所有的数据类型都可以使用上述的两种来构造。
数组的特点是：寻址容易，插入和删除困难；
链表的特点是：寻址困难，插入和删除容易；
思考下：我们能不能结合两者的优点，折中构造一种寻址容易，插入删除也较为容易的
数据结构呢？答案是肯定的了。我们可以构造一种“链表散列”的数据结构，可以理解为链表
的数组，HashMap就是基于其实现的。
从图中可以看出HashMap的底层就是一个数组结构，数组中的每一项又是一个链表。那么
究竟是不是这样呢？我们看源码吧。
/**
* The table, resized as necessary. Length MUST Always be a power of two.
*/
transient Entry<K,V>[] table;
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
...........
}
可以看出的是HashMap里面实现了一个静态内部类Entry(记录)，其重要的属性有key、value、next
而HashMap有一个属性是Entrr的数组table。Entry就是table数组中的元素，Map.Entry保存一个键值对
和这个键值对持有指向下一个键值对的引用，如此就构成了链表了。
2、构造方法
/**根据指定容量和负载因子构造HashMap*/
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);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
init();
}
/**根据指定的容量和默认的负载因子构造HashMap*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//默认的空的构造器
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
/**通过指定一个Map对象进行构造*/
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
putAllForCreate(m);
} 上述构造函数可以看出的是就是对table数组进行空间分配，至于那个负载因子到底是怎么回事
这里我们先不做解释。
3、存储元素
对于HashMap的存储元素的方法由多个，这里我们就put方法做下分析吧：public V put(K key, V value) {
// HashMap允许存放null键和null值。
// 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。
if (key == null)
return putForNullKey(value);
// 根据key的keyCode重新计算hash值。
int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的
// 搜索指定hash值在对应table中的索引。
int i = indexFor(hash, table.length);
// 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。
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;
}
}
// 如果i索引处的Entry为null，表明此处还没有Entry。
modCount++;
// 将key、value添加到i索引处。
addEntry(hash, key, value, i);
return null;
}
思考1：（未发生hash冲突情况下）
table是线性数组，是如何实现随机存储的呢？
这里是通过下面两行代码来实现的
int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的
// 搜索指定hash值在对应table中的索引。
int i = indexFor(hash, table.length); 通过hash方法的到key对象的哈希码，在通过indexFox()方法生成索引。具体如下：
/**产生哈希码*/
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
/*加入高位计算，防止低位不变，高位变化是引起hash冲突*/
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
/**产生索引，由于索引产生是不确定的，因此也就造成了HashMap顺序的不确定性。
需要注意的是不同的hash产生的索引完全有可能相同的
该方法的实现十分的巧妙，它通过h & (length-1)来的到对象保存的
索引，有可知道底层数组为2的n次方，这在速度上就有了明显的优化
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
通过上述代码我们可以很深刻的理解到，通过key值的hashCode方法返回的hash码，来产生
索引i。如果table[i]为null，则此处没有键值对，可以直接插入。如果table[i]！=null则此处有元素
则上面的for循环就是存储的新的元素：
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;
}
}
Tips:上述的key对象的hashCode我们应该主动的去重写，是的其和equals方法的逻辑一致性，
例如一个具体的对象作为一个key，我们通过内容判断是否相等(equals重写)，这时我们应该要
主动的去重写hashCode方法，让其和equals方法一样的逻辑结果。如若不然的话，我们认为相等
的key会覆盖，却因为没有重写hashCode实际上没有覆盖！
因为实际我们用String作为key的比较多，也就没有太过注意上述情况。
下面的就是一个错误例子
package com.kiritor;
public class Student {
String name;
public Student(String aa) {
// TODO Auto-generated constructor stub
name = aa;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return this.name.equals(((Student) obj).name);
}
public static void main(String[] args) throws InterruptedException {
HashMap<Student, Object> hashMap = new HashMap<>();
hashMap.put(new Student("AA"), "HEHE");
hashMap.put(new Student("AA"), "HEHE");
System.out.println(new Student("AA").name.equals(new Student("AA").name));
System.out.println(hashMap.size());
}
}
结果为：true 2 明显和我们的初衷背离了，因此这是我们序注意的地方。
思考2：hash冲突
一个有意思的情况出现：
这一问题呢？其实这里就是“链表数组”的IMBA之处了。详细的处理情况还是在for循环中。
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;
}
} 简单的分析下：假设table[0]！=null，其键为key1,当第二次插入的时候key2的哈希码虽然和key1不同，
但是获得的索引却是0，产生了hash冲突。进入for循环体，由于key1、key2的哈希不同，所以if判断为false
之后key1=key1.next(说法不准，这里直接就以key当做键值对元素吧)，再然后执行for之后的插入语句
// 如果i索引处的Entry为null，表明此处还没有Entry。
modCount++;
// 将key、value添加到i索引处。
addEntry(hash, key, value, i);
return null; key2被插入进key1的位置，同时key2.next指向的是key1，ok看明白了吗？这样hash冲突的问题就
通过链表数组的形式被解决了。简单的用图形展示
这里HashMap解决hash冲突的方法就是通过链地址法来的。
这里笔者也给出其他的冲突解决方式，有兴趣的朋友可以研究下：
1）开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）
2）再哈希法
3）链地址法
4）建立一 公共溢出区
4、读取元素
说完了元素的存储，我们来看看，HashMap是如何来读取元素的吧，这里我们简要的分析
下get(key)方法
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
} 对于key为空值的情况，我们就不在详述了，读者朋友可自行参阅jdk源码。
接下来进入getEntry(key)方法体里面去。
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key);
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 != null && key.equals(k))))
return e;
}
return null;
} 嘿，这不和存储的方式有些相似吗，由hash的到索引，如果索引位置为空，就不存在此key
values返回的就是空。如若索引位置不为空，该位置下可能是一条链，找到这条链里面可key的
hash相同的key，返回其对应的values。呵呵，取元素的方法是否简单多了呢？
5、删除元素
对于删除元素的原理和上述都是差不多的，这里笔者也就不解析了嘛。
6、HashMap优化
容量调整
对于容量的调整，这个是HashMap较为重点的部分，仔细想想看，对于hashMap我们应该
做的是尽量的避免hash冲突 ，此时对于数组的扩容就应该考虑了。不过一个蛋疼的问题也就
出现了，由于新数组的容量变了，原数组的数据就必须重新计算其再数组中的位置，并放入
这就是resize。同时这也是最消耗性能的地方。
那么在什么情况下对HashMap进行扩容呢？一般当HashMap的元素个事超过数组大小*
*loadFactory的时候，就会进行扩容，而loadFactor就是上文所说的负加载因子。默认值为0.75
例如数组空间为16，当元素超过16*0.75=12的时候就把数组大小扩为2*16=32，然后resize
这是一个非常消耗性能的是，因此如果我们预料到HashMap中元素的个数，这就能够有效的
提高hashMap的性能。
负载因子
为确定何时调整大小，而不是对每个存储桶中的链接列表的深度进行计数，基于hash的
Map使用一个额外的参数并粗略计算存储桶的密度。Map在调整大小之前，使用名为LoadFactory
的参数指示Map将承担的“负载”量，即它的负载程度。loadFactory、map大小、容量之间关系：
如果（负载因子）x（容量）>（Map 大小），则调整 Map 大小
7、快速失败机制和迭代遍历
对于HashMap的迭代，请参考： http://blog.csdn.net/kiritor/article/details/8872565
相关阅读：
Map源码学习 http://blog.csdn.net/kiritor/article/details/8884371
hashCode方法相关 http://blog.csdn.net/kiritor/article/details/8885022