注：本文源码版本为JDK1.7.0_79
如有理解不到位的地方，欢迎大家多多指正
1.定义
顾名思义，HashMap就是以键值对(key-value)的方式进行数据存储，并以hash散列的方式进行数据分布。HashMap继承AbstractMap，并实现了Map、Cloneable、Serializable接口。如下所示：
public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable
2.成员变量
| 变量名 | 含义 | 默认值 |
|---|---|---|
| size | HashMap中数据的个数 | 0 |
| loadfactor | 负载因子，衡量散列表空间的使用程度 | 0.75f |
| threshold | 表示当HashMap的size大于threshold时会执行resize操作 | capacity*loadFactor |
| modcount | 记录map的修改次数，在迭代器中使用，具体见后面分析 | 0 |
| capacity | 容量，即为HashMap中数组的长度,table.length | 无直接此变量，数组的默认长度为16 |
附上源码：
/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* An empty table instance to share when the table is not inflated.
*/
static final Entry[] EMPTY_TABLE = {};
/**
* The table, resized as necessary. Length MUST Always be a power of two.
*/
transient Entry[] table = (Entry[]) EMPTY_TABLE; //Entry类型的数组，hashMap的内部数据结构
/**
* The number of key-value mappings contained in this map.
*/
transient int size;
/**
* The next size value at which to resize (capacity * load factor).
*/
// If table == EMPTY_TABLE then this is the initial capacity at which the
// table will be created when inflated.
int threshold;
/**
* The load factor for the hash table.
*/
final float loadFactor;
/**
* The number of times this HashMap has been structurally modfied
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash). This field is used to make iterators on Collection-views of
* the HashMap fail-fast. (See ConcurrentModificationException).
*/
transient int modCount;
// These methods are used when serializing HashSets
int capacity() { return table.length; }
float loadFactor() { return loadFactor; }
3.数据结构
由上面的源码我们得知，HashMap的内部结构为一个Entry类型的数组，它的数据结构如下图所示：
HashMap数据结构 图片来自网络
Entry数据结构如下：
static class Entry implements Map.Entry {
final K key;
V value;
Entry next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry n) {
value = v;
next = n;
key = k;
hash = h;
}
....
}
4.构造函数
HashMap提供了3个构造函数，如下：
| 方法 | 释义 |
|---|---|
| HashMap() | 无参构造，默认容量(capacity)为16,默认负载因子为0.75f |
| HashMap(int initialCapacity) | 初始化数组长度,默认负载因子为0.75f |
| HashMap(int initialCapacity, float loadFactor) | 初始化数组长度和负载因子 |
注意：调用HashMap的构造函数时，并没有去初始化内部结构table的大小，只是给成员变量赋值了。
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();
}
5.方法解读
5.1 put()方法
public V put(K key, V value) {
if (table == EMPTY_TABLE) { //构造函数的时候，并没有去操作table，故第一次put的时候，table就为默认值EMPTY_TABLE
inflateTable(threshold); //初始化table，初始化的table长度一定时2的幂次。
}
if (key == null) //判断插入的值是否为null，如果为null的化，则调用插入key为null的方法
return putForNullKey(value);
int hash = hash(key); //获取key的hash值，如果key对应的类类型重写了hashCode()方法，则会调用
int i = indexFor(hash, table.length); //获取这个key位于那个hash桶(即数组的坐标)
for (Entry e = table[i]; e != null; e = e.next) { //如果有存在相同key的，则将其value覆盖。
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++; //变更次数加1
addEntry(hash, key, value, i); //添加数据到Entry[]中
return null;
}
- 构造函数部分，我们讲到调用构造函数的时候，并没有去操作内部的Entry数组。从put方法里，我们看到了是在第一次put数据的时候才去new Entry[] table。
- 我们可以看到，如果map中存在相同key值的时候，对应的value会被覆盖。由此可得出HashMap可允许有且仅有一个key为null。
- 不可忽视的一点：获取数组下标：int i = indexFor(hash, table.length);
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
}
解读如下：
查看源码HashMap的底层数组长度总是2的n次方，h&(length - 1)就相当于对length取模，而且速度比直接取模快得多，这是HashMap在速度上的一个优化。综合起来数据分布也相对更均匀。更多了解，请参考：http://www.cnblogs.com/chenssy/p/3521565.html
- 需要扩展的一点：代码中会调用key.hashCode()和key.equals(k)；类的hashCode()方法和equal()方法，在map的使用中有很重要的作用，所以常说如果重写equal方法的时候，必须重写hashCode方法。大家可以参考https://www.jianshu.com/p/75d9c2c3d0c1
添加元素方法addEntry()
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
我们先看下createEntry方法，如下。可以看到createEntry就是采用链表的头插法新增一个Entry。
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry e = table[bucketIndex]; //获取当前hash桶中得值
table[bucketIndex] = new Entry<>(hash, key, value, e); //new 一个key-value对应得Entry数组，并将new的Entry的next指向原来hash桶的值，并赋值给hash桶
size++;
}
我们再来看看resize的部分，当map中存储的数据大于等于map设定的阀值，且当前hash桶中也有值时，就会进行扩容。扩容每次都是以2倍的长度扩展的。
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, initHashSeedAsNeeded(newCapacity)); //将原数组的数据移动到新数组中
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); //更新map的存储阀值
}
移动数据方法：transfer()
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry e : table) {
while(null != e) {
Entry next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
阅读后，我们发现，如果移动后还是在一个hash桶中，顺序相对于之前是颠倒的。
5.2 get()方法
final Entry getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
for (Entry 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;
}
get方法比较简单，首先根据key找到对应的hash桶，然后在遍历查找。
5.3 remove()方法
final Entry removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry prev = table[i];
Entry e = prev;
while (e != null) {
Entry next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
remove方法的本质就是，找到hash桶之后，使用单向链表的删除方法。
6.modcount分析
简言之就是，用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你（你已经出错了）。
7.HashMap存在的问题？
- 线程安全问题：多线程情况下，在扩容的时候，可能会形成循环链表，可参考：
https://www.cnblogs.com/RGogoing/p/5285361.html
http://blog.csdn.net/aichuanwendang/article/details/53317351