目录
- 方法详解
- 方法定义
- clear() 详解
- clone() 详解
- resize() 详解：扩容
- compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)详解
- computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) 详解
- computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 详解
- containsKey(Object key) 详解
- hash(Object key) 详解
- comparableClassFor(Object x) 详解
- compareComparables(Class<?> kc, Object k, Object x) 详解
- tableSizeFor(int cap) 详解
- entrySet() 详解
- putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)、treeifyBin(Node
方法详解
方法定义
方法 | 作用 |
void clear() | 从此映射中删除所有映射 |
Object clone() | 返回此HashMap实例的浅表副本：键和值本身没有被克隆 |
V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) | 尝试计算指定键及其当前映射值的映射（如果没有当前映射，则为null ） |
V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) | 如果指定的键尚未与值关联（或映射到null ），则尝试使用给定的映射函数计算其值并将其输入到此映射中，除非为null |
V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) | 如果指定键的值存在且非空，则尝试在给定键及其当前映射值的情况下计算新映射。如果函数返回null ，则删除映射。 如果函数本身抛出（未经检查的）异常，则重新抛出异常，并且当前映射保持不变 |
boolean containsKey(Object key) | 如果此映射包含指定键的映射，则返回true |
boolean containsValue(Object value) | 如果此映射将一个或多个键映射到指定值，则返回 |
trueSet<Map.Entry<K,V>> entrySet() | 返回此映射中包含的映射的Set视图 |
void forEach(BiConsumer<? super K,? super V> action) | 对该映射中的每个条目执行给定的操作，直到处理完所有条目或该操作引发异常 |
V get(Object key) | 返回指定键映射到的值，如果此映射不包含该键的映射，则返回null |
V getOrDefault(Object key, V defaultValue) | 返回指定键映射到的值，如果此映射不包含该键的映射，则返回defaultValue |
boolean isEmpty() | 如果此映射不包含键值映射，则为true |
Set keySet() | 返回此映射中包含的键的Set视图 |
V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) | 如果指定的键尚未与值关联或与 null 关联，则将其与给定的非 null 值关联。 否则，将关联的值替换为给定重映射函数的结果，或者如果结果为null则删除 |
V put(K key, V value) | 将指定的值与此映射中的指定键相关联。 如果映射先前包含键的映射，则替换旧值 |
void putAll(Map<? extends K,? extends V> m) | 将所有映射从指定映射复制到此映射。 这些映射将替换此映射对当前指定映射中的任何键的任何映射 |
V putIfAbsent(K key, V value) | 如果指定的键尚未与值关联（或映射到null ），则将其与给定值关联并返回null ，否则返回当前值 |
V remove(Object key) | 如果存在，则从此映射中删除指定键的映射 |
boolean remove(Object key, Object value) | 仅当当前映射到指定值时，才删除指定键的条目V |
replace(K key, V value) | 仅当当前映射到某个值时才替换指定键的条目 |
boolean replace(K key, V oldValue, V newValue) | 仅当当前映射到指定值时才替换指定键的条目 |
void replaceAll(BiFunction<? super K,? super V,? extends V> function) | 将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都已处理或该函数引发异常。 函数抛出的异常被转发给调用者 |
int size() | 返回此映射中键值映射的数量 |
Collection values() | 返回此映射中包含的值的Collection视图 |
clear() 详解
/**
* 从此映射中删除所有映射。此调用返回后，映射将为空
*/
public void clear() {
Node<K,V>[] tab;
// 结构修改次数+1
modCount++;
// 存储元素数组赋值tab，并且不为空、元素数量大于0
if ((tab = table) != null && size > 0) {
// 元素数量置为0
size = 0;
// 循环置为null
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}clone() 详解
/**
* 返回此 HashMap 实例的浅克隆：键和值本身不会被克隆
*/
@Override
public Object clone() {
HashMap<K,V> result;
try {
// 克隆
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
// 初始化
result.reinitialize();
result.putMapEntries(this, false);
return result;
}
/**
* 重置为初始默认状态，由 clone 和 readObject 调用
*/
void reinitialize() {
// 初始化各个属性
table = null;
entrySet = null;
keySet = null;
values = null;
modCount = 0;
threshold = 0;
size = 0;
}
/**
* 实现 Map.putAll 和 Map 构造函数
* @param m 映射
* @param evict 最初构造此映射时为 false，否则为 true
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
// 获取 m 的元素数量
int s = m.size();
// 元素数量大于0
if (s > 0) {
// 如果存储元素的数组为null
if (table == null){ // pre-size
// ft = (元素数量/加载因子) + 1
float ft = ((float)s / loadFactor) + 1.0F;
// 如果 ft 小于 1<<30，t = ft,反之 t = 1<<30
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
// 如果 t > 临界值，临界值 = 大于 t 最近的2次幂
if (t > threshold)
threshold = tableSizeFor(t);
}
// 如果元素数量 > 临界值，扩容
else if (s > threshold)
resize();
// 循环此 map 中包含的映射的Set视图
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}resize() 详解：扩容
当table初始化时 或者 元素个数 > 临界值时，进行扩容操作
/**
* 初始化或加倍表大小
* 如果为空，则按照字段阈值中保存的初始容量目标进行分配。否则以二次幂的偏移量移动
*/
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// 获取元素数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 临界值（阈值）
int oldThr = threshold;
int newCap, newThr = 0;
// 只有非第一次扩容才会进来（第一次扩容在第一次put）
if (oldCap > 0) {
// 原数组长度大于 2^30 时，临界值为2^31-1
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// newCap = 元素数组长度左移1位 小于 1<<30 并且 元素数组长度大于等于16，新阈值为旧阈值的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold 阈值翻倍
}
// 原数组长度小于等于0 并且原阈值大于0，初始容量被置为阈值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 原数组长度小于等于0 并且原阈值小于等于0，初始容量为16，阈值为12
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 阈值为0时，当新容量小于 1<<30 并且 新容量乘加载因子 小于 1<<30，新阈值为新容量乘加载因子，反之新阈值为2^31-1
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;
// 复制数据到新table中
if (oldTab != null) {
// 遍历Node
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// j下标的元素不为空
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果只有一个节点,则直接赋值
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 将树形容器中的节点拆分为上下树形容器，如果太小则取消树形容器
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order 维护规则
// 之所以定义两个头两个尾对象,是由于链表中的元素的下标在扩容后,要么是原下标+oldCap,要么不变
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
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);
// 原下标对应的链表
if (loTail != null) {
// 尾部节点next设置为null
loTail.next = null;
newTab[j] = loHead;
}
// 新下标对应的链表
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)详解
/**
* 尝试计算指定键及其当前映射值的映射（如果没有当前映射，则为null ）
*/
@Override
public V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
if (remappingFunction == null)
throw new NullPointerException();
// 计算key的hashCode
int hash = hash(key);
Node<K,V>[] tab; Node<K,V> first; int n, i;
int binCount = 0;
TreeNode<K,V> t = null;
Node<K,V> old = null;
// size大于临界值 或者 存储元素数组为空 或者 存储元素数组长度为0
if (size > threshold || (tab = table) == null ||
(n = tab.length) == 0)
// 进行扩容并获取扩容后的数组长度
n = (tab = resize()).length;
// 拿到 key 值对应的桶位下标，并获取首元素的节点
if ((first = tab[i = (n - 1) & hash]) != null) {
// first 若属于树节点，使用树节点的查找Node节点方法getTreeNode()
if (first instanceof TreeNode)
old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
else {
// 链表查找 node 节点
Node<K,V> e = first; K k;
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
old = e;
break;
}
// 计算当前链条的元素个数
++binCount;
} while ((e = e.next) != null);
}
}
// 获取旧节点的值，不存在返回 null
V oldValue = (old == null) ? null : old.value;
// 调用指定的执行方法，传入 key，oldValue
V v = remappingFunction.apply(key, oldValue);
// 旧节点不为 null
if (old != null) {
// 指定方法执行后，若返回 null，删除该节点，否则 old节点的值设置为返回的值
if (v != null) {
old.value = v;
// 预留方法
afterNodeAccess(old);
}
else
removeNode(hash, key, null, false, true);
}
// 旧节点为null，remappingFunction.apply() 返回的 v 不为null
else if (v != null) {
// != null 则当前桶位的节点为 树节点
if (t != null)
// 调用树节点的添加方法，value 为返回的 v 值
t.putTreeVal(this, tab, hash, key, v);
else {
// 当前桶位的节点为链节点，添加一个新元素(key，v)
tab[i] = newNode(hash, key, v, first);
// binCount >= 7 即元素有 8 个时，尝试转化成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
// 更新 modCount, size
++modCount;
++size;
// 预留方法
afterNodeInsertion(true);
}
// 返回 v 值 即新值
return v;
}computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) 详解
@Override
public V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
if (mappingFunction == null)
throw new NullPointerException();
// 计算 key 的 hashCode
int hash = hash(key);
Node<K,V>[] tab; Node<K,V> first; int n, i;
int binCount = 0;
TreeNode<K,V> t = null;
Node<K,V> old = null;
// size大于临界值 或者 存储元素数组为空 或者 存储元素数组长度为0
if (size > threshold || (tab = table) == null ||
(n = tab.length) == 0)
// 进行扩容并获取扩容后的数组长度
n = (tab = resize()).length;
// 拿到 key 值对应的桶位下标，并获取首元素的节点
if ((first = tab[i = (n - 1) & hash]) != null) {
// first 若属于树节点，使用树节点的查找Node节点方法getTreeNode()
if (first instanceof TreeNode)
old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
else {
// 链表查找 node 节点
Node<K,V> e = first; K k;
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
old = e;
break;
}
++binCount;
} while ((e = e.next) != null);
}
V oldValue;
// old 不为空 并且 old.value 不为空，返回旧值oldValue
if (old != null && (oldValue = old.value) != null) {
// 预留方法
afterNodeAccess(old);
return oldValue;
}
}
// 执行指定的操作
V v = mappingFunction.apply(key);
// v 为 null 返回 null
if (v == null) {
return null;
// old 不为null，但old.value 为 null，设置旧值为 v 并返回
} else if (old != null) {
old.value = v;
// 预留方法
afterNodeAccess(old);
return v;
}
// t != null 即 当前桶位的元素为树节点，添加新值(key, v)
else if (t != null)
t.putTreeVal(this, tab, hash, key, v);
else {
// 添加链节点(key,v)
tab[i] = newNode(hash, key, v, first);
// 判断 binCount >= 8 - 1,是否需要转化树节点
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
// 更新 modCount，size
++modCount;
++size;
// 预留方法
afterNodeInsertion(true);
return v;
}computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 详解
public V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
if (remappingFunction == null)
throw new NullPointerException();
Node<K,V> e; V oldValue;
// 计算 key 的 hashCode
int hash = hash(key);
// e 不为空 并且 e.value 不为空
if ((e = getNode(hash, key)) != null &&
(oldValue = e.value) != null) {
// 执行指定动作 返回v
V v = remappingFunction.apply(key, oldValue);
// v不为空，替换该value值
if (v != null) {
e.value = v;
// 预留方法
afterNodeAccess(e);
return v;
}
else
// v 为null 则删除 key 对应的节点
removeNode(hash, key, null, false, true);
}
// 找不到 key 对应的节点 或者 Node.value 为空，直接返回 null
return null;
}containsKey(Object key) 详解
/**
* 是否包含key值
*/
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}hash(Object key) 详解
/**
* 计算 key.hashCode() 并将哈希的较高位传播（XOR）到较低位
*/
static final int hash(Object key) {
int h;
// key为null，返回0，反之返回 key的hashCode 按位与 key的hashCode无符号右移16位
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}comparableClassFor(Object x) 详解
/**
* 如果x是Comparable实例，返回x.getClass()，反之返回null
*/
static Class<?> comparableClassFor(Object x) {
// x是Comparable实例
if (x instanceof Comparable) {
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
// x的类对象等于String的类对象，返回x的类对象
if ((c = x.getClass()) == String.class) // bypass checks 绕过检查
return c;
// x.getClass()所表示的对象或接口直接实现的接口不为null
if ((ts = c.getGenericInterfaces()) != null) {
// 循环x.getClass()所表示的对象或接口直接实现的接口
for (int i = 0; i < ts.length; ++i) {
// t = ts[i],如果t为ParameterizedType的实例 并且
// 声明t类型的类或接口的 Type对象等于Comparable类对象 并且
// 此类型的实际类型参数的数组 Type对象不为null 并且
// 此类型的实际类型参数的数组长度为1 并且
// 此类型的实际类型参数的数组第一个元素等于x.getClass()
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType)t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c 类型参数是c
return c;
}
}
}
// 如果x不是Comparable实例
return null;
}compareComparables(Class<?> kc, Object k, Object x) 详解
static int compareComparables(Class<?> kc, Object k, Object x) {
// 如果x为null或x.getClass()不等于kc，返回0，反之返回k.compareTo(x)
return (x == null || x.getClass() != kc ? 0 :
((Comparable)k).compareTo(x));
}tableSizeFor(int cap) 详解
/**
* 返回大于cap值、且离其最近的2次幂，例如cap为7，则返回的值是8
*/
static final int tableSizeFor(int cap) {
// n = cap - 1
int n = cap - 1;
// n 或等于 n无符号右移1位
n |= n >>> 1;
// n 或等于 n无符号右移2位
n |= n >>> 2;
// n 或等于 n无符号右移4位
n |= n >>> 4;
// n 或等于 n无符号右移8位
n |= n >>> 8;
// n 或等于 n无符号右移16位
n |= n >>> 16;
// 如果n 小于 0，返回1
// 如果n 大于等于0 并且 n 大于等于 1<<30，即大于1073741824，返回1<<30
// 如果n 大于等于0 并且 n 小于 1<<30，返回 n+1
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}entrySet() 详解
/**
* 返回此 map 中包含的映射的Set视图
*/
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
// 如果entrySet 为 null,返回一个空entrySet，反之返回es即entrySet
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)、treeifyBin(Node<K,V>[] tab, int hash) 详解
/**
* 实现了Map.put()及相关方法
*
* @param hash key的hash
* @param key key
* @param value 放的值
* @param onlyIfAbsent 如果为true，则不更改现有值
* @param evict 如果为false，则表处于创建模式
* @return 上一个值，如果没有则为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;
// 如果元素数组为 null 或者 元素数组长度为0,n = 扩容后元素数组的长度
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// i = n-1 按位与 hash，如果 tab[i]的元素为null，tab[i] = 创建一个新节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// tab[i]的元素不为null
else {
Node<K,V> e; K k;
// 如果p节点的hash属性值 等于 hash，并且p节点的key属性值 等于 key 或者 key 不为 null 并且 key.equals(p节点的key属性值) 为true，节点e赋值p
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果p节点是TreeNode的实例，
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)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;
}
/**
* 链表节点转化为树节点，但当前容量必须大于最小树化容量 = 64
*/
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); // 继续遍历链表
// 到目前为止 也只是把Node对象转换成了TreeNode对象，把单向链表转换成了双向链表
// 把转换后的双向链表，替换原来位置上的单向链表
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}putMapEntries(Map<? extends K, ? extends V> m, boolean evict) 详解
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取 m 的元素数量
int s = m.size();
//元素数量大于0
if (s > 0) {
//如果存储元素的数组为null
if (table == null) {
//ft = (元素数量/加载因子) + 1
float ft = ((float)s / loadFactor) + 1.0F;
//如果 ft 小于 1<<30，t = ft,反之 t = 1<<30
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//如果 t > 临界值，临界值 = 大于 t 最近的2次幂
if (t > threshold)
threshold = tableSizeFor(t);
}
//如果元素数量 > 临界值，扩容
else if (s > threshold)
resize();
//循环此 map 中包含的映射的Set视图
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
