Map
Map作为顶层结构不实现任何接口也不继承某类,用于<K,V>结构的存储。不允许Key重复,但允许多个Key映射相同的Value。常见的实现类HashMap,TreeMap,LinkedHashMap、ConcurrentHashMap
HashMap
首先是一些static final的常量
默认大小
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
最大容量,一位符号位
static final int MAXIMUM_CAPACITY = 1 << 30;
负载因子,计算扩充阈值
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;
HashMap实行了懒加载, 新建HashMap时不会对table进行赋值, 而是到第一次插入时, 进行resize时构建table。
bucket中存储的结构
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
…………………………………………
}
HashMap比较重要,逐行记录。
put:
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) {
// 定义Node数组(// JDK1.7之前使用了HashEntry,1.8之后使用Node)、Node、以及两个变量n、i
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 判断当前实例里的数组是否为空,如果数组为空,则通过resize方法进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// n是2的幂,通过(n-1)&hash 取模计算出bucket并赋值给p,
// 如果当前位置不存在Node,则通过Node的构造方法插入一个新Node
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// bucket至少存在一个元素
Node<K,V> e; K k;
// p已经指向当前bucket链表第一个节点(或者红黑树首节点),通过hash以及key判断
// 是否相同,如果相同则将e指向p
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果不相同,则判断当前bucket是否构成红黑树,如果是则直接插入一个新的树节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 链表结构且第一个节点不相同,开始循环链表
for (int binCount = 0; ; ++binCount) {
// 将e指向p的下一个节点 并判断是否为链表的最后一个节点
if ((e = p.next) == null) {
// 为最后一个节点的情况下,生成一个新的Node节点放入链表尾部
p.next = newNode(hash, key, value, null);
// 判断当前链表长度是否为7(插入的新节点未+1,因此为7,转换红黑树为8)
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 将链表转为红黑树并退出
treeifyBin(tab, hash);
break;
}
// 该节点不为链表最后一个节点,判断值是否相同,相同直接退出循环,因为此时e指向
// p.next 即p.next是相同节点,需要替换
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 上述两种情况都不满足的情况下,p指向e,继续循环
p = e;
}
}
// e不为空的情况下,说明存在相同元素 需要替换,并将替换前的节点值返回
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 操作次数+1
++modCount;
// threshold = capital*loadFactor 也就是HashMap扩容值 如果当前数组扩大1超过该值,则进行
// 扩容操作
if (++size > threshold)
resize();
// 该方法在HashMap中是个空方法(实际是给LinkedHashMap使用,因此忽略即可)
afterNodeInsertion(evict);
return null;
}
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;
// 对原table的「容量oldCap」、「阈值oldThr」状态进行判断,并确定新 table 的「容量 newCap」、「阈值 newThr」
// 原 table 「容量」大于 0
if (oldCap > 0) {
// 若 oldTab 的「容量oldCap」大于最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE; // 将「阈值oldThr」设置为整数最大值
return oldTab; // 直接返回
}
// 若 oldTab 扩容后的「容量newCap」仍在合理范围内且不小于默认的初始容量
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold // 将「阈值oldThr」扩大一倍得到 「newThr」
}
// oldTab「容量oldCap」等于 0,但是「阈值oldThr」大于 0
// (table 容量小于0会抛出异常的,所以一定是等于0)
else if (oldThr > 0)
newCap = oldThr; // 将 oldTab 「阈值oldThr」赋值给 newTab 的「容量newCap」
else {
// 对未初始化的 table 进行初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 对于 「newThr」 未赋值的情况进行处理
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE); // 若ft在合理范围内,将其赋给 newThr,否则newThr赋值为整数最大值
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 新建 newTab
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 若 oldTab 不为null,对 oldTab 里的元素进行遍历
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 取出当前桶里的元素
if ((e = oldTab[j]) != null) {
oldTab[j] = null; // 将 oldTab 的这个位置置为空(暂时不理解是否有必要这样做)
if (e.next == null)
// 如果桶里只有一个元素,直接重新计算该元素在 newTab 的位置
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 如果桶里的元素是红黑树形式的,将其拆分rehash
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 若桶里不止一个元素,且是以链表形式存在的
Node<K,V> loHead = null, loTail = null; // 前缀为lo的变量指向的是rehash后新旧Tab位置一样的链表,loHead和loTail分别指向链表头部和尾部
Node<K,V> hiHead = null, hiTail = null; // 前缀为hi的变量指向的是rehash后新旧Tab位置不一样的链表,hiHead和hiTail分别指向链表头部和尾部
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);
// 将链表放进 newTab 中
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 将链表放进 newTab 中
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
- 先判断 oldTab 的状态,然后确定 newTab 的容量和阈值
- 对于容量已经超过最大指的table,将 threshold 赋予整数最大值后,返回
- 未被初始化的table(即容量和阈值都为0)会按照默认值进行初始化
- 对于 table 为空,threshold 不为空的,把threshold赋给新 table 的容量
- 之后,将 oldTab 桶里的元素放入到 newTab 中。
JDK1.7的时候,是将数组扩容为两倍,然后将HashMap中所有的key重新进行hash寻址算法然后再放入到扩容后的新的数组的新的位置。
Jkd1.8后,单个节点依然是寻址,而链表则是rehash之后重新拆分为了两个链表,一个链表rehash之后还是在当前的位置index,另一个链表rehash之后的位置变成了index + oldCap。
- 为什么拆两个
hash寻址算法对一个数组下标的所有节点,扩容后进行重新计算的时候,会发现计算出来的位置要么是在原来的index,要么实在原来的index + oldCap的位置,这是hash寻址的一个特点,所以基于这一个既定的结论,就去判断一下【框1】每个节点重新hash寻址之后是原来的位置还是index + oldCap的位置就行了,判断是在原来的位置然后一个新的链表,在index + oldCap的位置也形成一个新的链表,这样计算完之后只要把新的两个链表挂在【框2】新的数组的 index 和 index + oldCap就行了。这样就避免了对每个节点重新进行hash寻址算法,重新放到hash表中的过程。
TreeMap
LinkedHashMap
ConcurentHashMap
这部分源码暂时不看了。jdk1.7时用的分段锁实现线程安全,1.8的时候改为syncronized加分段cas来提高效率,syncronized对桶操作进行并发控制,采用 cas来保证操作的原子性