1.HashMap构造函数:
//无参的构造函数
public HashMap() {
//加载负载因子;
//注意 这里并没有初始化shreshold,默认还是为0
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//传入容量参数的构造函数
public HashMap(int initialCapacity) {
//调用下边的构造函数
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//传入容量参数和负载因子的构造函数
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);
}
//传入一个Map,核心是使用了putAll方法
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
用户在构造HashMap时,不管有没有传入容量参数,HashMap在初始化的时候其容量都是为0;
因为HashMap使用的懒加载机制,只有你第一次向HashMap中添加元素(put)时,才进行第一次的容量设置
1.如果用户没有传入容量参数,那么调用的是无参的构造函数进行初始化,此时容量为0;
2.如果用户传入了容量参数,那么也只是将容量参数initialCapacity通过tableSizeFor方法找出距离该initialCapacity最近的2的幂次方数值,然后将该数值赋给了扩容阀值threshold;
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
1.HashMap开始put元素:
1.1 首先调用Val函数
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
1.2 putVal函数:
1.如果链表数组table为空,则直接进行扩容
2.用hash%n(等于(n-1) & hash),计算出要插入的元素A存放在table数组的哪个位置
如果该位置为空,则生成一个链表节点放入
3.如果该位置已经存在节点元素p
3.1 如果p节点的key与要插入的元素A的key相同,则重新将p的value置为A的value
3.2 如果不同,并且p节点为红黑树的子节点,则插入到红黑树中
3.3 如果不同,且p元素为链表节点,则遍历该链表,如果出现3.1情况,直接break,没有的话 就插入到链表尾部
3.4 如果链表长度大于等于8,调用treeifyBin函数尝试扩容,如果数组长度小于64则扩容,如 果大于64,则该链表转为红黑树
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未初始化或者长度为0,进行扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// (n - 1) & hash 确定元素存放在哪个桶中,桶为空,新生成结点放入桶中(此时,这个结点是放在数组中)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 桶中已经存在元素(处理hash冲突)
else {
Node<K,V> e; K k;
// 判断table[i]中的元素是否与插入的key一样,若相同那就直接使用插入的值p替换掉旧的值e。
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);
// 结点数量达到阈值(默认为 8 ),执行 treeifyBin 方法
// 这个方法会根据 HashMap 数组来决定是否转换为红黑树。
// 只有当数组长度大于或者等于 64 的情况下,才会执行转换红黑树操作,以减少搜索时间。否则,就是只是对数组扩容。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
// 跳出循环
break;
}
// 判断链表中结点的key值与插入的元素的key值是否相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 相等,跳出循环
break;
// 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
p = e;
}
}
// 表示在桶中找到key值、hash值与插入元素相等的结点
if (e != null) {
// 记录e的value
V oldValue = e.value;
// onlyIfAbsent为false或者旧值为null
if (!onlyIfAbsent || oldValue == null)
//用新值替换旧值
e.value = value;
// 访问后回调
afterNodeAccess(e);
// 返回旧值
return oldValue;
}
}
// 修改的次数
++modCount;
// 实际大小大于阈值则扩容
if (++size > threshold)
resize();
// 插入后回调
afterNodeInsertion(evict);
return null;
}
1.3 插入元素后,可能会调用resize函数进行扩容:
1.如果数组table不为空,也就是oldCap>0,则说明已经被初始化过
1.1 如果原来的容量大于2^31,则容量已经达到最大,无法扩容,直接返回
1.2 如果扩容到两倍之后大于等于16且小于2^31(最大容量),则扩容到两倍
2.如果threshold>0
说明是通过传入容量参数(initialCapacity)的构造函数进行初始化的,newCap的值变为threshold,
在后面的判断中,threshold的默认值变为initialCapacity0.75,则newThr值为initialCapacity0.75
3.如果threshold=0,是调用的无参构造函数 ,threshold默认为0,则扩容到16,且决定是否扩容的newThr变量为默认容量*填充因子
4.如果newThr == 0,说明是走到2这个步骤的,也就是通过传入容量参数进行初始化的,则计算新的newThr
5.算出新的threshold(决定是否扩容,超过该值,则扩容)和newCap(数组容量),则开始新建一个扩容后的Node数组newTab,将oldTab的值移动到newTab中
遍历oldTab元素e,如果e不为空,则开始移动这一整个链表/红黑树的节点到newTab中。
如果当前元素e只有一个元素,则计算出放在newTab中的位置,也就是e.hash%newCap = e.hash&(newCap-1),再放入到newTab中。
如果当前元素e是红黑树节点,则调用split方法(在后面解释)
到这里,只可能是当前元素e有多个后继节点:
由于数组扩容了两倍,但是e.hash没有改变,会导致下标大于oldCap的位置是空着的,所以需要将e.hash小于oldCap的数组元素放入到原来的下标j中,将e.hash大于oldCap的元素放入到新的下标j+oldCap中
为什么这样,举个例子:e.hash=6,oldCap=5,则j=6%5=1,扩容后的数组长度为10,则 j=6%10=6,刚好等于j+oldCap。
将e.hash小于oldCap的数组元素,也就是低位的元素,通过loTail进行遍历,头节点 放入到loHead中, 同理,将e.hash大于oldCap的数组元素,也就是高位的元素,通 过HiTail进行遍历,头节点放入到HiHead中。
最后,将数组i中的各个链表元素一分为二,低位的去j,高位的去j + oldCap,返回 newTab数组
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) {
// MAXIMUM_CAPACITY: 如果原来的容量大于2^31,则无法扩容,直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 如果扩容2倍之后大于等于16且小于2^31,则扩容一倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 如果threshold,table容量*(loadFactor=0.75)>0,说明初始的容量放在threshold中
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 如果原来的表还没有被初始化,threshold默认为0,则扩容到16
// 且决定是否扩容的newThr变量为默认容量*填充因子
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的threshold(决定是否扩容的变量,新容量>table容量*(loadFactor=0.75),则扩
// 容)
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;
// 如果当前数组i元素有值
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果当前数组i元素只有这一个值,塞到新数组中
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 如果当前数组i元素是红黑树的结点
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 如果当前数组i元素的链表有多个值
// 注意 数组扩容了两倍
// 但是e.hash不变,元素数组下标又需要改变
// 所以需要将e.hash小于oldCap容量的放置在原来的下标j中,
// 将e.hash大于oldCap的放置在新的下标(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;
// 如果e.hash小于oldCap
// loTail类似于cur指针
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 如果e.hash大于等于oldCap
// hiTail类似于cur指针
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 将数组i中的各个链表元素一分为二,低位的去j,高位的去j + oldCap
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
((TreeNode<K,V>)e).split(this, newTab, j, oldCap)方法:
final void split(HashMap<K,V> map, HashMap.Node<K,V>[] tab, int index, int bit)
{
HashMap.TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
HashMap.TreeNode<K,V> loHead = null, loTail = null;
HashMap.TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
// 数组[i]的各个链表节点的值,低位转到数组[i]中,高位转换到数组[i+bit]中,
// 有可能低位或者高位也要转换为红黑树
for (HashMap.TreeNode<K,V> e = b, next; e != null; e = next)
{
next = (HashMap.TreeNode<K,V>)e.next;
e.next = null;
// 与resize函数类似++lc和++hc统计低位链表和高位链表的值
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
// 如果低位的头不为空,且链表里面的个数小于等于6,把treeNode类型转换为Node类型,又将红黑树转为链表
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
// 如果低位的头不为空,且链表里面的个数大于6,则重新生成红黑树
else {
tab[index] = loHead;
// 如果低位的头不为空,且链表里面的个数大于6,高位为空的话,就把不用多此一举了,就让它全部在低位就行了
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}