HashMap结构图
一.下面先看下结构图：
1、JDK7及之前
2、JKD8及之后
由上面结构图可知，HashMap由数组和链表共同构成，JDK8对HashMap做了优化，采用了红黑树的数据结构来做优化，使得HashMap存取速度更快。
二、HashMap实例化过程
1、几个重要的参数
| 属性名 | 属性说明 | JDK7 | JDK8 |
| loadFactor | 加载因子，初始值=0.75，与扩容有关 | √ | √ |
| threshold | 临界值，与HashMap扩容相关 | √ | √ |
| modCount | map中数据改变次数的统计 | √ | √ |
| DEFAULT_INITIAL_CAPACITY | 默认的初始容量 ，=1<<4=16 | √ | √ |
| MAXIMUM_CAPACITY | 最大容量，=1<<30 | √ | √ |
| DEFAULT_LOAD_FACTOR | 默认加载因子，=0.75 | √ | √ |
| TREEIFY_THRESHOLD | 使用TreeNode的临界值，默认=8 | × | √ |
| UNTREEIFY_THRESHOLD | 与split方法有关 | × | √ |
| MIN_TREEIFY_CAPACITY | 最小TreeNode的容量为64 | × | √ |
2、构造函数HashMap
JDK8
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;
this.threshold = tableSizeFor(initialCapacity);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
JDK7
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();
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
比较发现最大的改变就是在无参构造函数时，JDK8仅仅是初始化loadFactor让其等于默认值。而JDK7是调用了一个有参的构造函数，参数使用了默认值。
Map通过构造函数new一个HashMap时，其内部存储数据的数组并没有实例化，而是在PUT方法中去做了一件判断table是否为空的事，若为空就会调用resize()方法，resize()第一次调用就会实例化一个长度为DEFAULT_INITIAL_CAPACITY的Node[]。
三、HashMap存取put/get
1、put(K key,V value)
先来看一张流程图：
该流程图阐述了putVal()方法的整个执行过程。现在我们来看putVal()的源码
//对外开发使用
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//存值的真正执行者
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
//定义一个数组，一个链表，n永远存放数组长度，i用于存放key的hash计算后的值，即key在数组中的索引
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断table是否为空或数组长度为0，如果为空则通过resize()实例化一个数组并让tab作为其引用，
//并且让n等于实例化tab后的长度
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根据key经过hash()方法得到的hash值与数组最大索引做与运算得到当前key所在的索引值，
//并且将当前索引上的Node赋予给p并判断是否该Node是否存在
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);//若tab[i]不存在，则直接将key-value插入该位置上。
//该位置存在数据的情况
else {
Node<K,V> e; K k; //重新定义一个Node，和一个k
// 该位置上数据Key计算后的hash等于要存放的Key计算后的hash并且该位置上的Key等于要存放的Key
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p; //true，将该位置的Node赋予给e
else if (p instanceof TreeNode) //判断当前桶类型是否是TreeNode
//ture，进行红黑树插值法,写入数据
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//false, 遍历当前位置链表
for (int binCount = 0; ; ++binCount) {
//查找当前位置链表上的表尾，表尾的next节点必然为null,找到表尾将数据赋给下一个节点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null); //是，直接将数据写到下个节点
// 如果此时已经到第八个了，还没找个表尾，那么从第八个开始就要进行红黑树操作
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash); //红黑树插值具体操作
break;
}
//如果当前位置的key与要存放的key的相同，直接跳出，不做任何操作
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
//将下一个给到p进行逐个查找节点为空的Node
p = e;
}
}
//如果e不为空，即找到了一个去存储Key-value的Node
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//当最后一次调整之后Size大于了临界值，需要调整数组的容量
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
2、取值，请看源码解析：
//对外公开方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//实际逻辑控制方法
final Node<K,V> getNode(int hash, Object key) {
//定义相关变量
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//保证Map中的数组不为空，并且存储的有值，并且查找的key对应的索引位置上有值
if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
// always check first node 第一次就找到了对应的值
if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
return first;
//判断下一个节点是否存在
if ((e = first.next) != null) {
//true,检测是否是TreeNode
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key); //通过TreeNode的get方法获取值
//否，遍历链表
do {
//判断下一个节点是否是要查找的对象
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
return e;
}while ((e = e.next) != null);
}
}//未找到，返回null
return null;
}
四、HashMap扩容机制resize()
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length; //未扩容时数组的容量
int oldThr = threshold;
int newCap, newThr = 0;//定义新的容量和临界值
//当前Map容量大于零，非第一次put值
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) { //超过最大容量:2^30
//临界值等于Integer类型的最大值 0x7fffffff=2^31-1
threshold = Integer.MAX_VALUE;
return oldTab;
}
//当前容量在默认值和最大值的一半之间
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; //新临界值为当前临界值的两倍
}
//当前容量为0，但是当前临界值不为0，让新的容量等于当前临界值
else if (oldThr > 0)
newCap = oldThr;
//当前容量和临界值都为0,让新的容量为默认值，临界值=初始容量*默认加载因子
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的临界值为0
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
}
//临界值赋值
threshold = newThr;
//扩容table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;//此时newCap = oldCap*2
else if (e instanceof TreeNode) //节点为红黑树，进行切割操作
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { //链表的下一个节点还有值，但节点位置又没有超过8
//lo就是扩容后仍然在原地的元素链表
//hi就是扩容后下标为 原位置+原容量 的元素链表，从而不需要重新计算hash。
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//循环链表直到链表末再无节点
do {
next = e.next;
//e.hash&oldCap == 0 判断元素位置是否还在原位置
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//循环链表结束，通过判断loTail是否为空来拷贝整个链表到扩容后table
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
五、几个重点解析
1、HashMap中各个元素位置的确定
String类型和Integer类型的hashCode值，Map中hash方法
//String类型 HashCode
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
//Integer类型的 HashCode ,就是value本身
public static int hashCode(int value) {
return value;
}
//HashMap中的hash(), 小于2^16的值的hashCode都是其本身
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
HashMap put与resize的实例图
就此先描述这些，后期还需要进行进一步的描述。