一、HashMap简介
基本结构：
HashMap主要用来存放键值对。
JDK1.8以前底层实现为数组加链表的形式，具体表现为一个Node数组，数组中的每个元素存储链表的第一个节点，链表主要为了解决哈希地址冲突(即拉链法)。
JDK1.8后底层实现为数组加链表/红黑树的形式，当链表元素达到8个以后，会转换为红黑树 (在将链表转化为红黑树之前，首先判断数组的长度是否超过了64，如果没超过64，首先进行数组扩容，然后将元素重新hash到数组中)。
HashMap中的每个元素都是一个Node，Node保存了自身的Hash值、Key值、Value、以及指向下个节点的指针。
/*
Node的定义：
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
扩容策略：
HashMap的Node数组默认大小为16，负载因子默认为0.75，HashMap中有一个元素size用来记录数组被使用了多少，同时还有一个成员threshold表示扩容的阈值(threshold = 负载因子*总容量)，当size≥threshold时，HashMap会进行扩容，扩容的大小为原来的2倍。
具体步骤：
- 扩容：重新创建一个原数组两倍大小的新数组
- ReHash：遍历原数组，将原数组中的元素(Node)重新Hash到新数组,JDK1.7是重新Hash一次，JDK1.8改变了扩容时的数据重新分配策略，改为了原始节点的hash值与旧的容量进行&操作。即重分配的时候，看hash值新增的一个有效位到底是0还是1，如果是0,在原链表的位置上进行尾插，如果是1，则在原链表+旧容量大小的位置进行尾插。
//具体代码
//..
else { // 这里是resize()函数进行重分配时，如果元素的组织形式是链表时的分支处理逻辑
//e是当前链表的头节点
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) {
//如果新增的bit位为0，说明在该节点在新table的索引和旧table相同，尾插
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {//如果新增的高位bit为1，则该节点在新table中的索引是
//在旧索引的基础上加上旧的容量。
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//前面的操作只是形成了两个链表，还未正式插入到新table数组中
if (loTail != null) {//新产生的高位bit为0，索引为原索引
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
//新的bit为1，索引为元索引+原容量大小的偏移量
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
这里，HashMap的索引计算是hash&(n-1)，n为现在table的容量。
当扩容后，n变为2倍，相当于在增加了一个二进制位。(初始容量为16，n-1表示为1111，扩容后变为32，n-1为11111)，所以计算索引时可以多保留一个bit位。因此，这样既可以实现重分布，还减去了重新计算hash值得时间。(JDK1.7中，索引的计算是通过hash经过一系列变换得到的，同一个hash值，扩容后得到的index是不同的，现在扩容后，一个元素要不索引和原来相同，要不就是原索引+旧的table容量)
插入元素的策略：
- JDK1.8之前，使用头插法
- JDK1.8之后，使用尾插法
为何使用尾插法？
这是因为HashMap扩容时，会进行rehash，会遍历一遍数组，有可能产生环形链表的情况。
其他注意点：
-
为何初始大小为16？
源码中设定初值为1<<4，所以默认初始大小为16，使用位运算是因为效果与算数计算 相同，但效率更高。 而且最好初始值为2的幂，因为(2^n)-1用二进制表示为全1，与hashcode进行&运 算，得到的结果为Hashcode的后n位,这样只要输入的hashcode是均匀的，那么算出 来的index就是均匀的。16是一个经验数字。 -
为何重写equals时要重写hashcode？
这是因为Object默认的equals比较的时两个对象的地址是否相同//Object中的equals源码 public boolean equals(Object obj) { return (this == obj); }此时，当我们重写equals方法后，表示我们对于对象的判断相等逻辑被改写了。例如我们判断两个学生是否相等是通过学号来判断的，只要一个学生对象持有的“学号”这个成员变量是一样的，我们就可以断定两个拥有同样学号的学生对象是同一个对象。
所以，当我们改写了equals()方法，就表明对象的判断是否相等的逻辑改变了，当我们往容器中存储对象的时候(对象作为key)，首先会经过hash函数计算一个hash值 (hash函数使用的是对象的hashCode值来计算hash值的)，然后通过hash值来计算索引，得到索引后，再通过equals去进行比较，决定是替换某个Node，还是在链表中插入一个新Node。如果，我们不重写hashCode()，那么两个学号相同的学生对象采用默认的hashCode函数，产生的hashCode不相同，计算出来的hash值就不相同。这样往容器中存储的时候就会造成两个相同的key在容器中存储了两个的情况。
而且HashMap进行查找时，会将key转化为hashCode进行查找，所以改写equals后，如果不改写hashCode，会导致我们存入一个key，当按照key来查找时，由于hashCode不同，而导致查找不到。
为了避免这种情况，重写equals()时一般也要重写hashCode()。
-
HashMap和HashTable的区别：HashMap是线程不安全的，HashTable是线程安全的，因为HashTable中对数据的操作都加了synchronized，而且HashTable的key和value不允许为null，HashMap是可以的，HashMap会将key为null时会映射到数组的0号索引处。HashTable的初始容量为11，每次扩容当前容量的两倍然后再加1。
由于HashTable是支持并发的，因此不允许key和value为null，例如某个key为null，我们使用get获取该key时，我们无法判断是该key本来就不存在，还是该key值就是null，在这种情况下使用Contains(key)来判断一个key是否存在时，由于多个线程同时在操作，Contains(key)执行完后，在使用get(key)取值时，在这两个操作之间可能有别的进程已经删除该key了，所以不允许key和value为null。而HashMap是线程不安全的，在单线程情况下使用才能保证安全，此时可以通过contains(key)来判断该key到底是null还是不存在。
-
HashMap的hash函数为何是高16异或低16位呢？
目的是使得每一位都尽可能的参与到运算中，让得到的下标尽可能的均匀。HashMap算地址时使用的是hashCode&(length - 1)，通常情况下，HashMap的大小小于2^16，所以都是hashCode的低16位参与元素，而如果让高16位与低16位异或，会让高位也参与到运算中，使得index更加随机。 -
HashMap为何从链表转红黑树的默认阈值为8？
根据泊松分布，当链表长度大于8的概率小于百万分之一，所以，8是一个实验出来的经验数字。 -
put的详细流程
1、判断table是否为空或者length为0，如果是，则执行扩容操作，创建一个默认大小16的HashMap。
2、根据key计算其hash值，然后计算index
3、判断table[index]是否是null，如果是null，直接插入，否则判断key是否存在，如果已经存在，则直接覆盖。如果不存在，判断当前table[index]的元素时链表还是红黑树，如果是链表，插入一个新的节点，并判断是否链表长度大于等于8，大于8，将链表转换为红黑树。如果table[index]是红黑树节点，则直接插入一个新的红黑树节点。
4、插入完成后，size加1，判断是否超过最大阈值，如果大于，则扩容。(JDK1.7是根据index的数目来决定的，1.8以后就改为根据KV键值对的数目来决定是否扩容了。)
二、源码分析
package java.util;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import jdk.internal.access.SharedSecrets;
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
//默认的初始容量，大小必须为2的整数次幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转换为树所需要的节点数
static final int TREEIFY_THRESHOLD = 8;
//重新hash时，如果某个树的节点数小于该值，则从树退化为链表
static final int UNTREEIFY_THRESHOLD = 6;
//链表转化为红黑树时，数组的最小长度，即前面说，当数组长度到达64，且某条链表的长度大于8，才会进行转换
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap中的基本存储单元，即数组每个位置都存储了一条Node链表的第一个节点
static class Node<K,V> implements Map.Entry<K,V> {
//该Node元素的hash值
final int hash;
final K key;
V value;
Node<K,V> next;//指向下一个节点
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
/*
该条语句相当于：
key !=null ? key.hashCode():0 ^ value != null ? value.hashCode():0
*/
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//判断两个Node是否相等，如果引用相等，则指向的对象肯定相等
//否则，比较两个引用指向的Node的value和key,若都相等，则Node相等
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
//通过key的hashCode计算hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
* 根据传入的参数确定容量的大小，同时如果2的cup次方大于最大容量，返回最大容量
*/
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
//实际存储元素的数组
transient Node<K,V>[] table;
//保存不重复的Node，当使用keySet()方法时，返回该对象
transient Set<Map.Entry<K,V>> entrySet;
//table数组的容量
transient int size;
//hashMap的改变次数，当遍历或者对hashMap读写时，如果此值和迭代器的不相等，则快速失败
transient int modCount;
//扩容的阈值，大小等于size*loadFactor
int threshold;
//负载因子
final float 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);//调用前面的tableSizeFor方法
}
//指定数组初始大小的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//不带参数的构造器，此时负载因子为默认0.75，数组大小为默认的16
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//通过别的Map来构造
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
//计算出存储该Map所有元素所需要的数组长度
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//所需容量大于扩容阈值，直接将数组大小扩展为能容下的大小
if (t > threshold)
threshold = tableSizeFor(t);
} else {
//如果map不是空的，当传入一个Map时，我们不能像空Map那样直接创建一个对应的Node数组
//所以，要不断扩容，resize为扩容函数，每次扩容两倍
while (s > threshold && table.length < MAXIMUM_CAPACITY)
resize();
}
//数组扩容完毕后，挨个将传入Map的元素存入table数组中
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);
}
}
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
//hashMap的get方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//查找，索引的计算方式为hash&(n-1)
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) {
//查找到对应的链表
if (first.hash == hash && // 如果第一个就匹配，则返回
((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 boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
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<K,V>[] tab; Node<K,V> p; int n, i;
// 如果数组未进行初始化或者为空，则通过resize()初始化,并返回数组的长度
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<K,V> e; K k;
//如果存在和该key一模一样的节点，替换
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//此时还没替换，只是用e记录了下来
//否则插入
//红黑树的情况
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;
}
//如果在链表中找到相同的key，则替换
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { //实际的替换操作，如果e不为空，则说明存在相同的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;
}
//扩容函数
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = 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;
} //容量和阈值都扩充为2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 扩容两倍
}
else if (oldThr > 0) //如果原来的table长度为0，但是旧阈值不为0，这里还没想清楚什么条件下会
//触发该分支
newCap = oldThr;
else { //旧table容量为0，阈值为0，使用默认的参数构造table
//该分支当我们使用无参的构造器生成hashmap对象，第一次向其中放入元素时执行
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值为0，重新计算新的扩容阈值
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];//创建新的Node数组
table = newTab;
//进行rehash，将旧table中的值重新分布到新table中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//数组中某个元素不为null，即某个链表不为空
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//只有一个头节点，直接重hash到新的数组中
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 { // 如果是链表,前面已经单独讲过
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) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
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;
//使用node记录要删除的节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;//如果某个链表的第一个元素就是要删除的key,用node记录
else if ((e = p.next) != null) {
//第一个节点未匹配，但是hash值对应的索引处是有多个数据的
//如果数据组织结构为红黑树
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//数据组织结构为链表
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e; //在链表中找到了该key
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果找到了对应的key，进行删除
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
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;//没有找到，则不删除
}
/**
* Removes all of the mappings from this map.
* The map will be empty after this call returns.
*/
public void clear() {
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
for (Node<K,V> e : tab) {
for (; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
public Set<K> keySet() {
Set<K> ks = keySet;
if (ks == null) {
ks = new KeySet();
keySet = ks;
}
return ks;
}
//keySet方法返回该Set
final class KeySet extends AbstractSet<K> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<K> iterator() { return new KeyIterator(); }
public final boolean contains(Object o) { return containsKey(o); }
public final boolean remove(Object key) {
return removeNode(hash(key), key, null, false, true) != null;
}
public final Spliterator<K> spliterator() {
return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super K> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (Node<K,V> e : tab) {
for (; e != null; e = e.next)
action.accept(e.key);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
public Collection<V> values() {
Collection<V> vs = values;
if (vs == null) {
vs = new Values();
values = vs;
}
return vs;
}
final class Values extends AbstractCollection<V> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<V> iterator() { return new ValueIterator(); }
public final boolean contains(Object o) { return containsValue(o); }
public final Spliterator<V> spliterator() {
return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super V> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (Node<K,V> e : tab) {
for (; e != null; e = e.next)
action.accept(e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator();
}
public final boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
Object key = e.getKey();
Node<K,V> candidate = getNode(hash(key), key);
return candidate != null && candidate.equals(e);
}
public final boolean remove(Object o) {
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
Object key = e.getKey();
Object value = e.getValue();
return removeNode(hash(key), key, value, true, true) != null;
}
return false;
}
public final Spliterator<Map.Entry<K,V>> spliterator() {
return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (Node<K,V> e : tab) {
for (; e != null; e = e.next)
action.accept(e);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
// Overrides of JDK8 Map extension methods
@Override
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
@Override
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}
@Override
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
@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)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
@Override
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;
}
//.....后面还有红黑树的实现等等 暂时没有时间阅读了
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
