本文为Java8源码解读，已有红黑树。
主要成员变量
// 存储的键值对，其length为capacity
transient Node<K,V>[] table;
// 实际存储的键值对的个数，超过threshold则resize
transient int size;
// 修改次数，当put/remove/clear等改变集合的操作时，都会加一
// 用于并发情况下：A线程迭代器遍历，B线程改变集合，此时出现fail-fast异常
transient int modCount;
// resize的阈值，默认值是(int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY)=0.75*16=12
int threshold;
// 负载因子，默认为0.75
final float loadFactor;
静态变量
// 默认容量，即table的默认长度
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;
// 小于这个阈值时，重新变为链地址法，只会在resize()的时候出现
// remove的时候，是否从红黑树转为链表的判断条件不是这个
static final int UNTREEIFY_THRESHOLD = 6;
// 当table的长度小于这个阈值时，只使用resize()扩充table；大于等于它的时候才会用红黑树解决哈希冲突
static final int MIN_TREEIFY_CAPACITY = 64;
构造函数
// tableSizeFor()会将initialCapacity变为不小于它的2^n值，并暂存于threshold中，注意是暂存，后面resize()的时候会改变
// 当第一次调用put()的时候，会启动resize()函数
// 而在resize()中，capacity=threshold，为tab申请capacity大小的内存，即tab的length为capacity
// 并且重置threshold=capacity*loadFactor
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);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// DEFAULT_LOAD_FACTOR=0.75
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
// 拷贝构造函数
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
内部类
// 存储键值对的类
static class Node<K,V> implements Map.Entry<K,V> {...}
// 红黑树节点，构造方法与Node一致
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {...}
// HashMap中的迭代器的父类，可以使用remove
abstract class HashIterator {
public final boolean hasNext() {...}
final Node<K,V> nextNode() {...}
public final void remove() {...}
}
// 用于遍历keySet的迭代器
final class KeyIterator extends HashIterator
implements Iterator<K> {
public final K next() { return nextNode().key; }
}
// 用于遍历valuse的迭代器
final class ValueIterator extends HashIterator
implements Iterator<V> {
public final V next() { return nextNode().value; }
}
// 用于遍历entrySet的迭代器
final class EntryIterator extends HashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() { return nextNode(); }
}
// iterator()返回keyIterator，并且可调用remove，forEach
final class KeySet extends AbstractSet<K> {...}
// 没有remove，其他与keySet差不多
final class Values extends AbstractCollection<V> {...}
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {...}
// 还有spliterator迭代器，用于并行迭代的，但是不常用
// 用了几次还会出Bug：元素没有迭代完。具体原因有待考究
查
// 若存在该key，则返回对应的value；否则返回null
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
// 若存在该key，则返回对应的value；否则返回defaultValue
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
// 查询是否存在该key
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
// 若存在该key，则返回该key所在的节点；否则返回null
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 如果table不为空，且该hash所在的bucket不为空，继续查询
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 如果第一个节点的key就是，直接返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 如果第一个节点不是我们要找的
if ((e = first.next) != null) {
// 如果是红黑树节点，则调用红黑树的方法查询，快一点：O(logn)
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 否则就是链表节点，直接使用next属性
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
// 确保从根节点开始，调用find()方法查询
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
// 若存在该key，则返回该key所在的节点；否则返回null
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
// 要查询的hash值小于当前节点hash值，进入左子树
if ((ph = p.hash) > h)
p = pl;
// 要查询的hash值大于当前节点hash值，进入右子树
else if (ph < h)
p = pr;
// 若hash值相等，且key相等，则返回该节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 若无右子树，则直接进入左子树
else if (pl == null)
p = pr;
// 若无左子树，则直接进入右子树
else if (pr == null)
p = pl;
// 若hash相等，key不相等，且左右子树皆在，则用key的class判断去左边还是右边
// 具体见下方链接
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
// 若key的class还是无法判断，即dir == 0，则穷举所有孩子节点
// 先穷举右子树
else if ((q = pr.find(h, k, kc)) != null)
return q;
// 右子树搜索不到，再穷举左孩子的右子树
else
p = pl;
} while (p != null);
// 实在找不到，返回null
return null;
}
// 若存在一个或者多个节点包括该value，返回true；否则返回false
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
for (int i = 0; i < tab.length; ++i) {
// 使用next属性遍历，Node和TreeNode都有该属性，比查询key慢
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
comparableClassFor、compareComparables、tieBreakOrder方法解读
增
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 如果是更新节点，则返回旧的value；如果是插入节点，返回null
// onlyIfAbsent默认为false，直接更新value的值；若为true，只有当vaule是null的时候才会更新
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申请空间，则先为其申请空间
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 若当前bucket节点为空，则直接新建节点赋值
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 若当前bucket的节点的key与要put的key一致，则先记录，后面更新value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 若是红黑树节点，调用putTreeVal()；
// 若在putTreeVal()中未找到该key，并且成功插入，则返回null；
// 若在putTreeVal()中找到了该key，返回找到的节点，用于后面更新value
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 链表节点
else {
// 记录当前bucket中链表节点的个数，若大于等于8，则转为红黑树
for (int binCount = 0; ; ++binCount) {
// 若没找到，则在链表结尾插入并跳出；此时e为null
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 若在链表中找到key一致的节点，直接跳出，此时e为要更新的节点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 更新value，返回旧的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
// 若为false，直接更新；若为true，只有当oldValue为null才更新
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 为LinkedHashMap提供的服务，由于LinkedashMap有befor和after属性指向前后的bucket
// 若LinkedHashMap按访问顺序排序，则该方法将当前节点放入双向bucket链表的末尾
// 若LinkedHashMap按插入顺序排序，该方法无用
afterNodeAccess(e);
return oldValue;
}
}
// 若是插入操作，记录变化
++modCount;
// 若超过负载的阈值，扩容
if (++size > threshold)
resize();
// 为子类LinkedHashMap服务的，删除最早放入Map的对象
// 虽然evict默认为true，但是由于LinkedHashMap的removeEldestEntry()方法默认返回false，一般调用不会成功
// 如果确实需要该功能，需要重写removeEldestEntry()方法
afterNodeInsertion(evict);
return null;
}
// 若找到key一致的节点，返回该节点；未找到则插入，并返回null
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
// 判断是在当前节点的左边还是右边
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
// 若哈希一致，且key一致，则返回该节点用于更新
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 若哈希一致，但key不一致，用key的class来区分在左子树还是右子树
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
// 若dir还等于0，即还未区分左右子树，则在该节点的左右子树中寻找
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
// 若找到，返回找到的节点
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
// 若还未找到，用这个方法来比较两个对象，返回值要么大于0，要么小于0，不会为0，用于区分左右子树
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
// 如果p为null，根据dir插入
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
// 调用构造函数时，已经指定了next关系，x.next = xpn
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
// balanceInsertion()调整红黑树的平衡，返回红黑树的根节点
// moveRootToFront()确保当前bucket存储的是红黑树的根节点
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
改
在put()中已经可以更新value的值了，但是还是有更新专用的方法的：
// 只有在key和oldValue都匹配的情况下，才更新value的值
public boolean replace(K key, V oldValue, V newValue) {
Node<K,V> e; V v;
if ((e = getNode(hash(key), key)) != null &&
((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
// 只需key匹配到，即可更新value
public V replace(K key, V value) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}
删
// matchValue为false，key相等即可删除该节点；返回删除节点的value
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
// matchValue为true，只有当key和value都相等的时候才删除该节点；返回是否删除成功
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
// 删除
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
// 确保table不为空且该hash所在bucket有值
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
// 如果第一个节点即为要删除节点，先赋值给node，删除操作在后面
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
// 如果第一个节点不是
else if ((e = p.next) != null) {
// 如果是红黑树节点，则调用红黑树查找得到要删除的节点，快一点
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
// 如果是链表节点，直接使用next属性查找
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
// matchValue为true时，还会判定value是否相等
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 若是红黑树节点，需要使用红黑树的删除节点的方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
// 若是第一个节点，则将bucket的地址指向其next节点
else if (node == p)
tab[index] = node.next;
// 否则直接删除
else
p.next = node.next;
// 累计修改次数
++modCount;
--size;
// 为LinkedHashMap提供的服务，由于LinkedHashMap使用双向链表串联所有bucket
// 每个节点具有before和after属性，该方法修改双向链表
afterNodeRemoval(node);
return node;
}
}
// 没找到要删除的节点，返回null
return null;
}
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable) {
int n;
if (tab == null || (n = tab.length) == 0)
return;
int index = (n - 1) & hash;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
// 如果是第一个节点，直接赋值next
if (pred == null)
tab[index] = first = succ;
// 否则 ，将next节点赋给prev节点的next
else
pred.next = succ;
// 如果next节点不为空，还要修改它的prev属性
if (succ != null)
succ.prev = pred;
// 如果删除之后，该bucket为空，直接结束
if (first == null)
return;
// 确保root为根节点
if (root.parent != null)
root = root.root();
// 如果根节点、右子树、左子树、左孩子的左子树，这四个中有一个为空，都会变为链表
if (root == null
|| (movable
&& (root.right == null
|| (rl = root.left) == null
|| rl.left == null))) {
tab[index] = first.untreeify(map); // too small
return;
}
// 确保红黑树的平衡
......
}
766
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
