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来保证操作的原子性
5084
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
