继承结构
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
数据存储结构
数组 +（单项链表或红黑树)，链表深度大于8时，会将链表存储转化为红黑树存储 (线程不安全)
写在前面的一些方法、说明
- !!!
key和value都可为null - 位运算——详见 《与(&) 、或(|)、异或(^) 、取反(~) 运算 》
static final int tableSizeFor(int cap)扩容
// Returns a power of two size for the given target capacity.
//cap = 0 return 1
// cap = 1 return 1
// cap = 2 return 2
// cap = 3 return 4
// cap = 4 return 4
// 4 < cap <= 8 return 8
// 8 < cap <= 16 return 16
// cap > 16 return 32
// cap <= 32 return 32
// cap > 32 return 64
// ····
// cap = 12
// cap = 33
static final int tableSizeFor(int cap) {
// n = 11 -> 0000 1011
// n = 32 -> 0010 0000
int n = cap - 1;
// n >>> 1 -> 0000 0101,n | n >>> 1 -> 0000 1111
// n >>> 1 -> 0001 0000,n | n >>> 1 -> 0011 0000
n |= n >>> 1;
// n >>> 2 -> 0000 0011,n | n >>> 2 -> 0000 1111
// n >>> 2 -> 0000 1100,n | n >>> 2 -> 0011 1100
n |= n >>> 2;
// ...
// n >>> 4 -> 0000 1111,n | n >>> 4 -> 0011 1111
n |= n >>> 4;
// ...
// n >>> 8 -> 0000 0000,n | n >>> 8 -> 0011 1111
n |= n >>> 8;
// ...
// ...
n |= n >>> 16;
// n = 15
// n = 63
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
// return n = 16
// return n = 64
}
final Node<K, V>[] resize()扩容，返回扩容后的新数组
final Node<K, V>[] resize() {
Node<K, V>[] oldTab = table;
// 老table的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {// 老table中有值
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 { // 使用无参的构造方法，第一次put数据才会走到这里 // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY; // 16
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 12
}
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<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
table = newTab;
// 数据转移
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) { // 遍历老table数组
Node<K, V> e;
if ((e = oldTab[j]) != null) { // 当前位置有数据
oldTab[j] = null;// 释放
if (e.next == null) // 当前位置链表只有一个节点
newTab[e.hash & (newCap - 1)] = e; // 重新hash，并入新数组
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;
// 将同一桶中的节点按着 e.hash & oldCap 是否为0进行分割，分成两个链表完成rehash
do {
next = e.next;
// 根据算法 e.hash & oldCap判断节点位置rehash后位置是否改变
// 最高位为0，索引不变的链表
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
} else {
// 最高位为1，索引发生改变的链表
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) { // 愿bucket位置的尾指针不为null
loTail.next = null; // 链表最后需要有个null节点
newTab[j] = loHead; // 链表头指针放在新链表的原下标出
}
if (hiTail != null) {
hiTail.next = null;
// rehash后的节点新的位置一定是原来基础上加上oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
final void treeifyBin(Node<K, V>[] tab, int hash)树化：单链表>>>双向链表>>>红黑树
final void treeifyBin(Node<K, V>[] tab, int hash) {
int n, index;
Node<K, V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K, V> hd = null, tl = null;
do {// 遍历单项链表转为双向链表
TreeNode<K, V> 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.treeify(tab); // 双向链表转为红黑树
}
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)添加元素，返回前一个值，如果没有返回null
// Implements Map.put and related methods
// @param hash hash for key - key的hash值
// @param key the key - key值
// @param value the value to put - value值
// @param onlyIfAbsent if true, don't change existing value - 如果是true，同key不会被新值覆盖
// @param evict if false, the table is in creation mode.
// @return previous value, or null if none
//
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K, V>[] tab;
Node<K, V> p; // hash计算位置的node
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // 初始化table
if ((p = tab[i = (n - 1) & hash]) == null) // 当前位置没有数据，则新建赋值
tab[i] = newNode(hash, key, value, null);
else { // 当前位置存在数据
Node<K, V> e; // 当前key对应的node
K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode) // 如果当前位置的为红黑树
e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) { // 循环找key的hash值&&key对应的node，如果不存在，则创建新node
if ((e = p.next) == null) { // 该位置链表没有找到对应key的node
p.next = newNode(hash, key, value, null);//创建新node，放在链表队尾
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash); // 链表深度>=8，转为红黑树存储
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) // 根据onlyIfAbsent判断是否覆盖旧值
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict)
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
// 初始化阀值
float ft = ((float) s / loadFactor) + 1.0F;
int t = ((ft < (float) MAXIMUM_CAPACITY) ?
(int) ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
} else if (s > threshold)
resize(); // 扩容
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { // 遍历put单个元素
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
final Node<K, V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable)// 返回移除的节点对象
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;
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;
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);
else {
// 遍历链表匹配节点 始终保持p.next = e
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);
else if (node == p) // 当前位置第一个节点就是目标值的情况
tab[index] = node.next;
else // 移除node这个节点
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node; // 返回移除的节点对象
}
}
return null;
}
final Node<K, V> getNode(int hash, Object key)通过hash、key匹配查找node
final Node<K, V> getNode(int hash, Object key) {
Node<K, V>[] tab;
Node<K, V> first, e;
int n;
K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) { // 保证table中有数据，且对应的hash值有数据
if (first.hash == hash && // always check first node（先匹配first变量节点）
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)// 红黑树查找
return ((TreeNode<K, V>) first).getTreeNode(hash, key);
do { // 链表查找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
一、增
public V put(K key, V value)
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
public void putAll(Map<? extends K, ? extends V> m)
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
public V putIfAbsent(K key, V value)如果key对应的value不为null，则不会覆盖旧值
@Override
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}
二、删
public V remove(Object key)返回删除的节点的value值
public V remove(Object key) {
Node<K, V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
public boolean remove(Object key, Object value)返回值表示是否查找对应的node
@Override
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
三、改
public V put(K key, V value)如果key存在，修改value
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
public V replace(K key, V value)查找替换value，返回旧值value or null
@Override
public V replace(K key, V value) {
Node<K, V> e;
if ((e = getNode(hash(key), key)) != null) { // 只匹配key查找
V oldValue = e.value;
e.value = value;// 替换
afterNodeAccess(e);
return oldValue; // 返回旧value
}
return null;
}
public boolean replace(K key, V oldValue, V newValue)查找替换value，返回值表示是否查找到元素
@Override
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)))) { // 同时匹配key 和 value
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
四、查
public boolean containsKey(Object key)通过key是否能查找到元素，返回值表示通过key是否可以查找到node
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
public boolean containsValue(Object value)遍历table每个位置，返回值表示是否查找到value
public boolean containsValue(Object value) {
Node<K, V>[] tab;
V v;
if ((tab = table) != null && size > 0) {
// TreeNode中的包含了2种数据结构，双向链表和红黑树
for (int i = 0; i < tab.length; ++i) {
// 这种链表遍历方式可以完全遍历到所有元素
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;
}
【感谢】
HashMap源码解析——Java 8系列之重新认识HashMap
如果文章对你有帮助，点个赞再走呗
如果文章中存在错误，还望评论区指出
一起成长，共同进步
