HashMap添加元素大致步骤
HashMap添加元素过程如下：
- HashMap在jdk1.8版本之后数据结构 = 数组 + 链表 + 红黑树，内部是通过Node类来实现基本结构的。
- HashMap在添加元素的时候是通过调用HashMap中的put()方法，在调用此方法的时候内部紧接着调用了putVal()方法,在此方法中：
2.1 首先会调用hash()方法然后在内部接着调用传入的键值的元素的hashCode()方法，接着经过位运算计算得出hash值。
2.2 在putVal()方法中首先通过tab对象记录之前对象table中的数据，接着判断table中有没有元素，如果没有任何元素，则将tab赋值给resize()方法返回的Node对象，在resize()方法中：
2.2.1 首先是将之前的table数组对象记录一下，然后判断其长度，根据长度来进行后续操作
2.2.2 如果之前table数组为空，那么将table数组的初始化容量设置为16，将阈值设置为12（在不指定加载因子的情况下）。
2.2.3 如果之前调用了HashMap中的带参构造器，那么将会设置扩容阈值，如果在添加时刚好要超过阈值，那么将会通过resize()方法把容器扩容两倍，
然后在resize()方法中重新设置HashMap中元素的位置，经过resize()中逻辑判断之后元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置，当然这其中还得判断链表还是红黑树。2.3 在进行table初始化容量之后通过此式子（i = (n - 1) & hash）确定下标，
2.4 如果此下标位置为空，那么就直接将此元素添加到此数组位置（桶位）上，
2.5 如果此位置下标所对应位置不为空，那么将添加元素与此桶位元素比较，比较时首先是比较两元素hash值是否相等然后调用元素所自带的equals()方法判断是否相等，如果相等就覆盖之前元素，如果不相等判断此元素所在位置数据结构是否为红黑树，如果为红黑树就用红黑树的方式添加元素，如果不为红黑树那么就是链表，然后遍历整个链表，遍历过程进行判断，如果两元素hash值和equals()方法比较结果都为true，就直接覆盖之前元素，否者添加在链表尾部。
2.6 在后续继续添加元素之后，如果元素中table中元素个数超过了加载因子*数组容量那么就将table数组扩容两倍（跟2.2.3类似），否则正常添加，或者继续添加元素的时候在table数组上链表元素超过树化阈值（8）之后，会调用treeifyBin()方法，判断是否达到了树化容量，如果没有达到将它进行扩容两倍，只有当达到了树化阈值（8）且同时达到了树化容量之后才会将链表树化（红黑树）。
- 最后执行完上述过程之后就已经确定容量和位置之后会将哈希值，key值，value值，以及下一元素引用传入，如果没有下一元素就传入null。
HashMap内部重点属性
//16 默认的初始化容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//默认的加载因子，决定扩容的边界 length*0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树化的阈值
static final int TREEIFY_THRESHOLD = 8;
//树的降级阈值
static final int UNTREEIFY_THRESHOLD = 6;
//设置做小的树化容量 和 TREEIFY_THRESHOLD一起来决定是否转成红黑树
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap集合中每个元素对应的节点类型
static class Node<K,V> implements Map.Entry<K,V>
final int hash;//当前元素的hash值
final K key;//key
V value;//value
Node<K,V> next;//下一个节点的地址
//Map集合中用来保存数据的数组，刚创建完map集合table默认为null
transient Node<K,V>[] table;
//跟踪当前集合元素的个数
transient int size;
//阈值，当table中有内容的个数超过此阈值就扩容
int threshold=length*DEFAULT_LOAD_FACTOR;HashMap添加元素重点方法
put()方法实际上是调用了putVal()方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}hash()方法通过计算得出一个值，用于确定数组小标
static final int hash(Object key) {
int h;
//通过位运算符得出值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}putVal()方法实际添加元素方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab用来储存之前的数组
//p用来存储数组的下标中的元素，指向最后一个元素
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果集合中无任何内容，通过resize方法初始化数组容量
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果此数组下标所在桶位为空，那么直接添加元素
if ((p = tab[i = (n - 1) & hash]) == null)
//通过上述算法能够尽量均匀分配桶位
tab[i] = newNode(hash, key, value, null);
//在桶位有元素的情况
else {
Node<K,V> e; K k;
//首先判断桶位元素是否与传入元素键值相等
//判断是先判断hash值，再通过equals方法继续判断。在这里可以看出一定要在传入元素内重写hashCode方法和equals方法
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果没有在桶位找到，再判断此桶位数据结构是否为红黑树
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);
//加入元素之后判断是否超过树化阈值，如果超过通过treeifyBin方法扩容或者树化
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 = e;
}
}
//在找到相同键值情况替换之
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果在添加元素之后元素个数超过阈值就扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}reseze()方法用于集合扩容
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//老的数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//老的扩容阈值
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//大于最大数组容量
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//将新容量设置为原来的两倍，判断之前容量是否不够
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//将阈值也设置为原来两倍
newThr = oldThr << 1; // double threshold
}
//如果之前集合为空，且阈值大于0，将新容量设置为老阈值
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;
}treeifyBin()方法用于集合树化
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果之前数组长度少于树化阈值，就进行扩容
//而且进入此方法的前提条件是超过或等于树化阈值，
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//只有当超过树化阈值且超过树化容量，才进行树化（转为红黑树）
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
