目录
3）构造方法，注意：HashMap只有在put的时候才会进行初始化
9）树化：treeifyBin()，treeify(), untreeify()
一、HashMap简介
HashMap是基于哈希表的 Map 接口的实现。它还实现了Serialiable接口，因为存储数据的变量被transient修饰，所以它和ArrayList一样重写了writeObject方法和readObject方法。
HashMap以键值对的方式来存储数据，根据键的hashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，线程不安全的。
HashMap是无序的，它不会记录存储数据时的顺序。
HashMap底层存储的数据结构为：数组＋链表。
二、源码分析
1）变量
/**
* HashMap的默认初始化容量：16，HashMap要求设置初始容量时最好是2的幂次方
* 如果不是他会自动帮你转化成离初始值最近的一个2的幂次方
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* HashMap的最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认加载因子，当map中的元素大于 table.length * 0.75 时则进行扩容
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 默认树化阈值，当数组内的某个链表长度大于8，该链表就会转换为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 默认的退化阈值，当数组内的某棵红黑树中的节点个数小于6，该红黑树就会转换为链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 默认的最小容量
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 存储链表的数组
*/
transient Node<K,V>[] table;
/**
* 存储map中的key的集合
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 记录map中的元素个数
*/
transient int size;
/**
* 记录操作次数
*/
transient int modCount;
/**
* 扩容阈值
*/
int threshold;
/**
* 加载因子
*/
final float loadFactor;2）内部类
/**
* 链表节点
*/
static class Node<K,V> implements Map.Entry<K,V> {
//key的hash值
final int hash;
final K key;
V value;
//记录下一节点，hashMap中的链表是单向链表只记录下一节点
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
/**
* 红黑树节点，详细的方法就不贴出来了
* TreeNode是HashMap.Node<K,V>的子类，所以他也有next属性，方便数据迁移时使用。
*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
//树的根节点
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
//当前节点的父节点
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
//获取当前节点所在树的根节点
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
...........
}3）构造方法，注意：HashMap只有在put的时候才会进行初始化
/**
* 无参构造方法
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* 有参构造方法，给HashMap设置初始值，初始值最好是2的幂次方
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 有参构造方法，给HashMap设置初始值并设置加载因子来确定扩容阈值
*/
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，后续初始化的时候会根据这个值初始化tab的大小
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 将某个Map的子类对象转换为HashMap
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}4）tableSizeFor方法
HashMap中推荐初始化容量最好是2的幂次方但并没有强制要求，但是进行扩容等操作时又需要容量为2的幂次方，所以HashMap会自动将你设置的初始值转换为大于等于参数的第一个2的幂次方。
原理：2的幂次方以二进制的形式表示时，除了最高有效位其余位都为0。例如: 8->1000 16->10000。所以，我们只要将参数的最高有效位及其以后的位都变为1，然后再+1就可以把参数变为2的幂次方数。
/**
* 计算出大于等于参数的第一个2的幂次方
*/
static final int tableSizeFor(int cap) {
// cap - 1是为了防止cap本来就是2的幂次方
int n = cap - 1;
// 将n无符号右移1位再与n进行或运算
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;
} 初始值：
位运算的目的是为了将所有的x变为1：
然后结果+1就会得到大于参数的第一个2的整数幂数：
全过程示意图：
右移一位：
右移两位：
右移四位：
右移八位：
右移16位：
＋１变为２的整数幂：
总结：HashMap通过位运算将设置的初始值转为位２的整数幂的数。因为位运算是偏底层的运算所以是比较高效的。只通过五次位运算因为HashMap中规定了最大容量位 1 << 30,而五次位运算的位数是31，如果运算结果大于1 << 30 则将容量设置为默认的最大容量。
参考资料：https://www.cnblogs.com/xiyixiaodao/p/14483876.html
5）put方法
插入元素时可能发生hash碰撞，HashMap中是通过链式寻址法来解决hash碰撞的。
/**
* 往map中添加元素
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* 这里的onlyIfAbsent表示如果出现hash冲突是否替换值，false为替换
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// HashMap的懒加载的只有再用到map的时候才会进行初始化
// 只有第一次put的时候才会进行初始化操作
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 这里先计算key的hash值，再判断tab中的该位置有无元素，没有则直接放入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 如果有计算出来的位置有对象则进行判断，即发生hash碰撞。
Node<K,V> e; K k;
// 该位置的第一个节点内容是否与待插入的对象一致，如果一样就进行替换
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果不一样就判断该位置现在放的是链表还是红黑树
// 如果是红黑树就调用红黑是的putTreeVal方法进行插入
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)
// 注意： 当binCount == 7 时链表中已经有9个节点了
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;
}
}
// 此时如果e的值不为null说明上面的判断中记录了冲突节点，此时就需要对冲突节点的值进行 替换
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 记录操作次数
++modCount;
// map当前容量+1，并判断+1后是否大于扩容阈值，如果大于则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}6）hash值的计算与put对象插入位置的计算
/**
* 计算对象的hash值
* 让对象hashCode方法计算出来的值的高16位与低16位进行异或运算
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
tab[i = (n - 1) & hash]
(n - 1) & hash: 将对象的hash值与数组长度-1进行与运算则可以得到对象在数组中的位置。
为什么要数组长度-1？
与运算：就是第一个操作数的第n位和第二个操作数的第n位都为1，结果数的第n位才为1否则为0
假设数组长度为16
如果不减一的话，那么16的二进制为：10000，任何hash值与它进行与运算只有两个结果10000或者00000这两个结果。
减一的话，那么15的二进制为：1111，任何hash值与它进行与运算的结果都在0-15之间，这样保证了计算结果不会超过数组下标
7）resize方法
HashMap调用这个方法只有两个目的：
1、初始化数组
2、扩容
扩容时是逐一遍历数组，然后将数组内的链表或者红黑树的节点进行迁移
链表：链表中的节点迁移时需要逐一遍历链表节点，计算节点在新数组中的位置。迁移时计算位置并没有像插入数据时一样，将节点的hash值与新数组长度进行与运算。而是通过将链表中的节点分为高位链表和低位链表两条链表，低位链表是呆在新数组的原位，高位链表则是呆在新数组的 原位下标+旧数组长度 的位置。
如何区分节点属于高位链表还是低位链表呢？
将节点的hash值与旧数组长度进行与运算，如果为0则为低位链表，如果不为零则为高位链表。为什么只有两种结果，前面的hash值计算时我有说过。
为什么高位链表的位置是原位下标+旧数组长度？
假设扩容器数组长度为16，扩容后为32.
从图中可以看出，hash值于新数组长度-1进行与运算后，，结果与原下标的差距只在第五位，而第五位的结果只有0或1。即下标的变化只有在原下标或者原下标+16（旧数组长度）。
/**
* 进行初始化或扩容的方法
*/
final Node<K,V>[] resize() {
// 旧数组
Node<K,V>[] oldTab = table;
// 旧数组的大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 旧map的扩容阈值
int oldThr = threshold;
// 新map的大小，扩容阈值
int newCap, newThr = 0;
// 判断旧map的大小是否大于0
// 大于0说明是要扩容
if (oldCap > 0) {
// 如果oldCap已经是最大容量了，则无法继续扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 这里将newCap扩大为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 因为容量给扩大了，所以加载因子也得随之扩大两倍
newThr = oldThr << 1; // double threshold
}
// 如果oldCap小于0说明还未进行初始化
// 这里是判断之前创建对象时是否有设置初始容量，如果有则按照设置的初始容量来
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 如果没设置初始容量，则将初始容量设置为默认容量(16),将加载因子设置为默认加载因子(0.75)
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 代码走到这newCap的值已经不可能为0了，这里就是对新扩容的计算
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 将计算出的新扩容阈值复制给threshold
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 按照计算出的newCap创建新数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 将新数组赋值给table
table = newTab;
// -------------代码走到这初始化的操作已经完成了-------------
// oldTab如果为空说明调用此方法是为了初始化数组，就可以直接return table；了
if (oldTab != null) {
//下面是扩容操作的数据迁移
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 判断数组当前位置是否为空, 并将对象赋值给 e
if ((e = oldTab[j]) != null) {
// 不为空则进行数据迁移，先将内存释放
oldTab[j] = null;
// 如果e的下一节点为空则说明此处只有一个元素，直接迁移即可
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;
}8）红黑树的数据迁移
红黑树的数据迁移和链表差不多，先将红黑树上的节点分为高位链表和低位链表。在判断高位链表和低位链表是否需要树化或者退化成链表。
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
// 低位头节点和尾节点
TreeNode<K,V> loHead = null, loTail = null;
// 高位头节点和尾节点
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
// 遍历树
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
// bit就是就数组长度 hash值与旧数组长度进行与运算，判断下标是否改变
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) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
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);
}
}
}
43万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
