写在前面
最近有空就去翻了下JDK的集合源码，之前也去看了下，但理解得不是很透彻，这次是更深入的了解，顺便记录下。List和Set的实现相对比较简单，这里不深入讲解。项目中用得比较多的是ArrayList、HashSet、TreeSet、HashMap、TreeMap、ConcurrentHashMap，这里主要讲解HashMap。
实现类
AbstractMap的重要方法基本被重写，并且重写了clone方法
public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable
和ConcurrentHashMap比较
相同点
- 实现的数据结构基本一致（数组+链表+红黑树）
不同点
- HashMap是非线程安全的，而ConcurrentHashMap是线程安全的
- ConcurrentHashMap的key和value都不能为null，而HashMap都可以
ConcurrentHashMap线程安全实现方式
ConcurrentHashMap在1.6版本是通过分段式锁实现的，具体不了解，1.8版本是通过CAS+Synchronized实现的，这里不详述，有兴趣的同学可以自己去了解。
- 什么是CAS？，这个讲得比较通俗易懂
- 狼哥深入浅出ConcurrentHashMap1.8
数据结构
我们先看下它的数据结构，HashMap的数据结构是采用数组+单向链表+红黑树实现的，数据结构草图如下
HashMap数据结构草图
基本数据结构
- node：数据节点，最小单元
static class Node implements Map.Entry {
final int hash; // key的hash值
final K key;
V value;
Node next;
// ...省略代码
- tree node：红黑树节点，node子实现
static final class TreeNode extends LinkedHashMap.Entry {
TreeNode parent; // red-black tree links
TreeNode left;
TreeNode right;
TreeNode prev; // needed to unlink next upon deletion
boolean red;
// ...省略代码
- table：一个node数组，HashMap的数据仓库，默认的情况下为null，当第一次插入数据时才会初始化
transient Node[] table;
假象
HashMap底层采用数组实现，但并不是顺序置入node，也不是数组的每个位置都会置入node，后面会讲解
开始剖析
插入数据
- 计算key的hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
- 计算node的数组下标位置
(n - 1) & hash，n为数组容量，如果该位置没有node，直接将node插入到该位置；这里会出现有些位置没有元素，浪费了空间 - 如果该位置有node，并且hash值一致，key一致，则将该值覆盖，条件判断如下
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
- 如果已存在的node为tree node(红黑树)，根据tree node的规则插入到树中
- 若以上都不成立，则将已存在的node做成链表结构，将新的node添加到该node后面
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
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 e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode)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);
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;
}
什么是key碰撞，为何会发生key碰撞
当新node计算出table的下标位置已存在node，并且两个node的key不一样，则已经发生key碰撞；下标的值由(n - 1) & hash计算而来，因此很容易产生相同值
如何解决key碰撞
首先会通过链表解决碰撞问题，将新node加到存在的node的后面做成链表结构，但这又产生另一个问题，链表越来越长怎么办，查找速度会很慢
如何解决链表查找速度慢问题
当链表长度<=8时则继续以链表的结构存储；而当大于8时，若此时数组容量小于64则触发数组扩容，否则将链表做成红黑树(tree node)结构，红黑树是一种有顺序的二叉树，查找速度相对于链表快
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
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;
}
final void treeifyBin(Node[] tab, int hash) {
int n, index; Node e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//数组 扩容
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode hd = null, tl = null;
do {
TreeNode 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还是链表结构
hd.treeify(tab);
}
}
什么是红黑树
这里不具体讲解，看看大神神作
- 根节点必须是黑色
- 每个叶节点(最后一个节点)的未来子节点都是黑的
- 任意从根到叶子的路径不包含连续的红色节点
- 如果一个节点是红的，那么它的两个子节点都是黑的
- 任意从根到叶子的路径的黑色节点总数相同
如何实现红黑树
实现原理是根据key的hash值去比较大小，小的放左边，因此左边最下面那个的hash值是最小的，保证红黑树是有顺序，这样查找速度是不是上去了；如果这时做出来的红黑树不符合上面的红黑树规则，则需要平衡红黑树，保证是一颗比较平衡的二叉树。实现代码比较复杂，容易懵逼，如有误解，欢迎指正。
final void treeify(Node[] tab) {
TreeNode root = null;
for (TreeNode x = this, next; x != null; x = next) {
next = (TreeNode)x.next;
x.left = x.right = null;
if (root == null) {
x.parent = null;
x.red = false;
root = x;
}
else {
K k = x.key;
int h = x.hash;
Class kc = null;
for (TreeNode p = root;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}
数组扩容
- 数组的容量是2的幂次方，通过tableSizeFor方法保证，cap参数初始化容量，可以在new HashMap(int cap)传入，cap的推荐计算值为cap=size/0.75F+1。默认情况下数组容量为16
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;
}
- 扩容主要分两步走，第一步计算扩容数组的容量，创建新的数组；第二步将原数组的数据装入新数组，并且不是按原位置装入。扩容的具体实现如下
final Node[] resize() {
// 1. 计算扩容后的数组容量
Node[] 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
}
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[] newTab = (Node[])new Node[newCap];
table = newTab;
// 2. 重新装配原数组的数据
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node 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)e).split(this, newTab, j, oldCap);
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node 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;
}
- 由上述代码可知，数组扩容开销很大，每扩容一次需要重新计算元素在新数组的存储位置，原数组对象变成垃圾对象，增加了JVM垃圾回收的负担
- 为什么cap=size/0.75F+1，HashMap计算下次扩容的容量等于这次要扩容的量*0.75，部分代码如下，但这并不绝对，容量计算条件比较复杂。为了减少HashMap发生扩容次数，我们在创建HashMap对象的时候计算出数组的容量，比如目前有20条数据要插入到HashMap对象，通过计算数组容量大概为27。但是这并不代表不会再扩容，至少需要扩容的几率大大缩小了。
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
什么时候数组会扩容
- 首次插入数据会初始化数组
- key碰撞的时候（不绝对）
- map的siae大于下次扩容的量时
get方法和remove方法
了解如何放入元素之后，这两个方法看源码就相对比较容易理解，这里不做深入解析
扩展
- TreeMap是用红黑树实现的
- HashSet是用HashMap实现的
- TreeSet是用TreeMap实现的
写在最后
如有误解，欢迎指正