一、HashMap 结构分析
（一）HashMap关系图
此图是使用idea生成的HashMap的类关系图
在代码中是这样子的：
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
....省略中间的代码
}
我们可以忽略所实现的Cloneable与Serializable接口。
为了缩小篇幅，这里就不介绍了
- Cloneable: Cloneable接口的作用与深入理解深度克隆与浅度克隆
- Serializable: 为什么要实现Serializable
忽略之后是这样子的，可以看出这样子就不太复杂了：
（二）属性解析
重要的属性介绍：
//序列化ID
private static final long serialVersionUID = 362498820763181265L;
/*
1<<4计算步骤：
1*2 = 2
2*2 = 4
4*2 = 8
8*2 = 16
*/
//HashMap的默认初始容量，必须是2的幂，1 << 4：向左移4位。
//如果你了结果2禁止运算的话，应该可以反应的过来。 1<<4 = 16，具体计算请看上面步骤
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//HashMap的最大的容量，同样必须也是2的幂，那么默认的HashMap最大容量就是：1073741824
static final int MAXIMUM_CAPACITY = 1 << 30;
/*
源码中是这么说的：默认的负载系数0.75是一个权衡时间和空间成本的。
在源码中会把HashMap的容量大小与负载因子相乘例如：16*0.75=12
那么作用就出来了：如果HashMap中存在了12个数据时，会自动扩容。
*/
//默认的负载因子，这个数字很神奇，我一直认为这是一个精华，有一篇文章写的不错，放到最后了，大家可以看看。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树化阈值，至于解释请看文章最后
static final int TREEIFY_THRESHOLD = 8;
//树退化阈值
static final int UNTREEIFY_THRESHOLD = 6;
//最小表容量
static final int MIN_TREEIFY_CAPACITY = 64;
//hash表负载因子
final float loadFactor;
（二）HashMap的构造方法解析
一共有4种，下面分别进行看下有什么作用
1、HashMap()默认构造方法
一般在用的时候通常都是这么使用：
HashMap<String,String> map = new HashMap<>();
也就是说走的是默认构造方法：
可以看出如果走默认构造方法的话，就会把DEFAULT_LOAD_FACTOR的默认值给loadFactor
使用默认容量构造一个空的HashMap
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
2、HashMap(int initialCapacity)构造方法
会调用HashMap(int initialCapacity, float loadFactor)这个构造方法
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
3、HashMap(int initialCapacity, float loadFactor)构造方法
功能就是手动填写初始化容量和负载因子，一般不会去动
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);
}
4、HashMap(Map<? extends K, ? extends V> m)构造方法
功能：就是把一个hashmap添加到另一个hashmap中
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
看用途的例子：
HashMap<String,String> map = new HashMap<>();
map.put("1", "2");
HashMap<String,String> map2 = new HashMap<>(map);
map2.put("2", "3");
for(String key:map2.keySet()) {
System.out.println("Key: "+key+" Value: "+map2.get(key));
}
打印结果：
Key: 1 Value: 2
Key: 2 Value: 3
(1)putMapEntries(Map<? extends K, ? extends V> m, boolean evict)方法解析
功能：把map名字为m中所有的数据都追加到另一个map中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size(); //获取被追加的map中的元素个数
if (s > 0) { //如果被追加的map的个数不为空，就追加数据
if (table == null) { // 如果是拷贝函数来调用putMapEntries，或者构造后还没传进来参数，table表是空的时
//(float)s / loadFactor：计算一个值（容量），使得size刚好不大于阈值
float ft = ((float)s / loadFactor) + 1.0F; //+1.0是为了向上取整。因为括号中计算出来的是小数
//如果小于最大容量，就进行阶段；否则就赋值为最大容量
int t = ((ft < (float)MAXIMUM_CAPACITY) ?(int)ft : MAXIMUM_CAPACITY);
//计算的t大于当前的容量时，才会继续修改
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold) //如果m的容量大于当前map的容量，
resize(); //就重新计算容量大小
//便利m中的数据，put进现在的map中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);//暂且先不深究这个
}
}
}
二、例子实战
(一)map.put(K,V)方法解析
例子1如下：
HashMap<String,String> map = new HashMap<>();
map.put("a", "1");
map.put("b", "2");
put方法入口：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
会调用putVal方法
/**
* 实现Map.put方法和相关的方法
* @param hash key的hash值
* @param key key值
* @param value value值
* @param onlyIfAbsent 如果是true的话就不更改现有的值
* @param evict 如果为false，就代表table表在创建模式
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果存储元素的table表为空，则进行相关的赋值
if ((tab = table) == null || (n = tab.length) == 0)
//赋值阶段，可以看错两个步骤，1：把tab = resize()也就是把table赋值给tab，2：然后把tab的长度给n
n = (tab = resize()).length; //初始值为16
//写这个代码的人真的是很有智慧的，一个步骤就解决了多个步骤，
//首先根据hash值获取结点，赋值给p，，这里的p节点史
//如果p等于null，就创建一个新节点
if ((p = tab[i = (n - 1) & hash]) == null) //&用法：除法散列法进行散列
tab[i] = newNode(hash, key, value, null); //创建新节点
else { //如果拿到的不等于空
Node<K,V> e; K k;
//如果新插入的结点和table中p结点的hash值，key值相同的话
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;//就把p赋值给e
//如果是红黑树结点的话，就进行红黑树插入
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
//如果单链表只有一个头部结点，则直接建一个结点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//链表长度大于8时，将链表转成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//更新p
p = e;
}
}
//如果已经存在了这个映射，进行覆盖操作
if (e != null) { // existing mapping for key
V oldValue = e.value;
//判断是否允许覆盖，并且value是否为空
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//回调以允许LinkedHashMap后置操作
afterNodeAccess(e);
return oldValue;
}
}
//记录操作的次数
++modCount;
//如果size加1后大于临界值
if (++size > threshold)
resize();//就重新计算，进行调整，扩容操作
afterNodeInsertion(evict);
return null;
}
(二)resize()方法解析
resize()方法应该很熟悉了，看到多次了。在初始化的时候，在扩容的时候，都能见到这个resize方法。
//初始化或扩容（扩大到之前的2倍）
final Node<K,V>[] resize() {
//拿到旧的table表，暂时保存
Node<K,V>[] oldTab = table;
//旧的table表没有数据的时候oldCap=0；否则oldCap就等于oldTab的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//扩容的临界值
int oldThr = threshold;
//定义新数组的长度和扩容的临界值，并初始化为0
int newCap, newThr = 0;
//如果旧的table表中的数据不为空
if (oldCap > 0) {
//如果数组长度达到了最大值，则修改临界值为Integer.MAX_VALUE
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//否则，就进行扩容操作（扩容2倍，） newCap = oldCap << 1
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // oldThr << 1：将oldThr左移1位就是oldThr*2
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
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;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
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);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
参考文章
1、HashMap的负载因子为什么默认是0.75？这篇文章告诉你答案
2、JAVA8 的 HashMap 中 TREEIFY_THRESHOLD 常量为什么是 8？
3、
