equals、hashcode和==的区别
在介绍HashMap之前，我想先阐述一下我对这三者的理解，equals这个方法呢，就是在判断是否为同一对象（注意，这里的同一对象和相同的内存地址是不同的），是否为同一对象其实看一看做一种我们对事物的主观定义，如果我是个佛系青年，认为世间万物都是相同的，那么我只需要在equals里只return一个true。hashcode我们可以看做是一个对象的表示符，同一对象的表示符肯定是一样的，不同对象的表示符理论上来说应该是不同的，但是现实永远不太尽如人意，不同的对象hashcode相同，就是所谓的冲突。所以当我们重写Object中的equals方法的时候，一定要记得重写hashcode方法。==很好理解，它就表示是不是同一内存地址。
接下来我们就从原理和源码两方面去介绍一下hashcode，并且对hashcode的非线程安全进行一些简单的讨论，下文参考了https://www.cnblogs.com/softidea/p/7261111.html这篇文章
一、HashMap原理
在最初的HashMap中，其底层的实现数组加链表的数据结构，基本单元为Entry，但是在java8之后进行了优化，增加了红黑树，底层结构也由Entry变成了Node和TreeNode组合完成，但是TreeNode其实还是继承自Node。
数组的优缺点：优点是根据下标进行查找，十分迅速，缺点是在数组中插入元素，删除元素效率极低
链表的优缺点：优点是对于增删操作非常方便 ，但是查找起来却很慢
红黑树优缺点：优点是查找非常迅速，缺点是插入元素的时候又费时间又费空间
HashMap就是综合了以上几点，构成的一种数据结构：首先用一个数组来构成散列表，然后用链表来解决冲突，当冲突项大于默认值8时，会将链表转化成一颗红黑树，提高查询效率（链表就是一颗退化树）。
如下图所示：
从上图我们可以发现HashMap是由Entry数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。
二、源码分析
1、底层数据类
/**
* 这里可见，Node是实现了Entry
*/
static class Node<K,V> implements Map.Entry<K,V> {
/**
* 注意hash和key都是final修饰的，说明作为key需要是不可变值，比如String很常用
* 如果采用自己创建的对象
*/
final int hash;
final K key;
//value是可变的
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; }
/**
* key的hash值和value的hash值做与操作，所以key和value需要重写hashCode方法
*/
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
//这里设置新值的时候会返回旧值
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//这里需要注意要重写equals方法
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;
}
}/**
* 这里介绍一下红黑树的五条性质
* 1、节点是红色或者是黑色；
* 2、根节点是黑色；
* 3、每个叶节点（NIL或空节点）是黑色；
* 4、每个红色节点的两个子节点都是黑色的（也就是说不存在两个连续的红色节点）；
* 5、从任一节点到其没个叶节点的所有路径都包含相同数目的黑色节点；
*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}2、HashMap的常量和属性
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
/**
* 默认初始化容量，必须是2的次方。这个容量就是table的长度
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 这里指定了一个容量的上限，如果自己指定的值大于上限的话，就采用该默认值
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认加载因子，当没有指定加载因子的时候会采用该值，这个值的意义在于，当有效值比容量大于加载因子时
* 会扩容table数组
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 这个是一个链表在多长时转化为红黑树，默认为8
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当一颗树的节点少于6个的时候，将这棵树转化为链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 当哈希表中的容量大于这个值时，表中的桶才能进行树形化 否则桶内元素太多时会扩容，而不是树形化 为了
* 避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 这个数组会在第一次使用时初始化，并且在条件合适的时候重构，它的长度一定是2的整数次方
*/
transient Node<K,V>[] table;
/**
* 一个包含所有节点的Set
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* Map中的当前元素数量
*/
transient int size;
/**
* 这个是Map当中元素的修改次数（这里的修改只是说增加和减少元素时，该量会加一）
*/
transient int modCount;
/**
* 当大于这个值的时候会执行重构数组操作(capacity * load factor).
*/
int threshold;
/**
* 自定义的加载因子
*/
final float loadFactor;
}3、HashMap的resize
final Node<K,V>[] resize() {
//将原来的table指针保存
Node<K,V>[] oldTab = table;
//获取原来数组的长度，oldTab为null说明还没有进行初始化
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//保存以前重构table的阈值
int oldThr = threshold;
int newCap, newThr = 0;
//oldCap > 0表示已经初始化过了
if (oldCap > 0) {
//当原来的容量已经达到最大容量的时候，将阈值设置为Integer.MAX_VALUE，这样就不会再发生重构的情况
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) //虽然还没有初始化，但是设置过了阈值，将旧的阈值设置为新的容量
newCap = oldThr;
else { //没有初始化阈值的时候采用默认算法计算阈值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {//对应oldCap = 0 && oldThr > 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) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
//(newCap - 1)是一个尾部全部为1的数
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//判断旧的节点是一个树节点，则对树进行操作，重构树或者变成链表等等
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
// 对原来的链表部分进行重构 所以新索引要么是原索引，要不就是原索引+oldCap
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//比如原来容量为16，二进制则为10000，扩展为32位后，取模则为e.hash对11111取模与对10000一致，只在乎最高位，当为0时候效果是一样，
if ((e.hash & oldCap) == 0) {
//如果链尾为null，则将e赋值给链头，
if (loTail == null)
loHead = e;
else
//将e赋值给链尾的下一个节点
loTail.next = e;
//并将链尾赋值为e
loTail = e;
}
else {
if (hiTail == null)
//如果链尾为null，则将e赋值给链头，
hiHead = e;
else
//将e赋值给下一个节点
hiTail.next = e;
//并将链尾赋值为e
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
//取模结果一致，则将数据放到对应的bucket里面
loTail.next = null;
newTab[j] = loHead;
}
//(16-1) & hash 自然就是取hash值的低4位,我们假设它为 abcd.当我们 将oldCap扩大两倍后, 新的index的位置就变成了 (32-1) & hash,
//其实就是取 hash值的低5位. 那么对于同一个Node, 低5位的值无外乎下面两种情况:0abcd或者 1abcd
//其中, 0abcd与原来的index值一致, 而1abcd = 0abcd + 10000 = 0abcd + oldCap,所以新的下标就为新的取模值加上原容量
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}举个例子（例子来自https://blog.csdn.net/lianhuazy167/article/details/66967698）
4、修改方法
4.1、put
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* @param hash 计算出来key的hash值
* @param key key的值
* @param value value的值
* @param onlyIfAbsent 当为true的时候，如果key对应有值，则不修改这个值
* @param evict 当为false时，表示这个处于创建模式，现在由于afterNodeInsertion中什么都没有，这里没有实际意
* evict参数用于LinkedHashMap中的尾部操作
*/
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为null或者tab的长度为0时，即table尚未初始化，此时通过resize()方法得到初始化的table
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//当p为null时，表明tab[i]上没有任何元素，那么接下来就new第一个Node节点，调用newNode方法返回新节点赋值给tab[i]
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//HashMap中判断key相同的条件是key的hash相同，并且符合equals方法。这里判断了p.key是否和插入的key相等，如果相等，则将p的引用赋给e
//这里为什么要把p赋值给e，而不是直接覆盖原值呢？答案很简单，现在我们只判断了第一个节点，后面还可能出现key相同，所以需要在最后一并处理
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
//现在开始了第一种情况，p是红黑树节点，那么肯定插入后仍然是红黑树节点，所以我们直接强制转型p后调用TreeNode.putTreeVal方法，返回的引用赋给e
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
//最后一个参数为新节点的next，这里传入null，保证了新节点继续为该链表的末端
//e=p.next,将p的next赋值给e
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入成功后，要判断是否需要转换为红黑树，因为插入后链表长度加1，而binCount并不包含新节点，所以判断时要将临界阈值减1
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//在遍历链表的过程中，我之前提到了，有可能遍历到与插入的key相同的节点，此时只要将这个节点引用赋值给e，最后通过e去把新的value覆盖掉就可以了
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//p=e,将上面的e=p.next赋值给p,下次的p.next即相当于将p向后遍历循环
p = e;
}
}
//左边注释为jdk自带注释，说的很明白了，针对已经存在key的情况做处理
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//收尾工作，值得一提的是，对key相同而覆盖oldValue的情况，在前面已经return，不会执行这里，所以那一类情况不算数据结构变化，并不改变modCount值
++modCount;
//当HashMap中存在的node节点大于threshold时，hashmap进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
4.2、putAll
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
/**
* @param m 需要放入的Map
* @param evict 在此处并无意义
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取添加元素的数量
int s = m.size();
//添加的Map中有元素
if (s > 0) {
//table == null表达现在还没有被初始化
if (table == null) { // pre-size
//通过加载因子计算出大概需要初始化的空间,加1.0F原因是向上取值，防止转int精度数据丢失
float ft = ((float)s / loadFactor) + 1.0F;
//检查这个需要的空间有没有大于最大容量MAXIMUM_CAPACITY
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//如果大于了当前resize()的阈值，就要重新计算
if (t > threshold)
//这里会得到一个比t大的最小的2的整数次幂的值
threshold = tableSizeFor(t);
}
else if (s > threshold)//在已经创建Map的情况下，s如果直接大于阈值，直接重构现在的Map
resize();
//将传入的Map的每个值都插入到现在的Map中
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);
}
}
}
4.3、remove
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
* @param hash key的hash值
* @param key key的值
* @param value 传入匹配的value值，如果matchValue=false，直接忽略
* @param matchValue 为true时，会去进一步匹配value
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
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值有元素
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;
//不是的话，就从相同hash值的所有元素中去查找,将p.next赋值给e
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
//该列表已经转换成红黑树的情况
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//在列表中查找的情况,如果找到值则，跳出循环，将对应值的指引赋给node
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
//将e的引用赋值给p，下次循环取next
p = e;
} while ((e = e.next) != null);
}
}
//找到了目标节点
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)//是一个链表开头元素的情况
//当前节点指引等于node指引，则将当前node的next(为null)节点赋值给当前节点的下标
tab[index] = node.next;
else
//将当前node的next(为null)节点赋值给当前节点的下标
p.next = node.next;//是一个链表中间元素的情况
++modCount;//结构改变，需要加一
--size;//容量-1
afterNodeRemoval(node);
return node;
}
}
return null;
}
4.4 clear
public void clear() {
Node<K,V>[] tab;
modCount++;//对table结构修改加一
if ((tab = table) != null && size > 0) {
size = 0;
//释放数组的每一个指针
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
5、查询方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//根据输入的hash值，可以直接计算出对应的下标（n - 1）& hash，缩小查询范围，如果存在结果，则必定在table的这个位置上
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断第一个存在的节点的key是否和查询的key相等。如果相等，直接返回该节点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//遍历该链表/红黑树直到next为null
if ((e = first.next) != null) {
//当这个table节点上存储的是红黑树结构时，在根节点first上调用getTreeNode方法，在内部遍历红黑树节点，查看是否有匹配的TreeNode
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//当这个table节点上存储的是链表结构时，方法同上
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}6、静态方法
/**
* 对于这个函数，我想说两点，第一点是支持key==null，返回位置为0
* 第二点是(h = key.hashCode()) ^ (h >>> 16)，一个int32bit
* 这里正好将高16位移到了低16位，然后产生的hash值即包含了高位信息又包含了低位信息
* 还解决了地址空间不够引起的冲突问题
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
* 当x的类型为X，且X直接实现了Comparable接口（比较类型必须为X类本身）时，返回x的运行时类型；否则返回null。
*/
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {// 判断是否实现了Comparable接口
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
if ((c = x.getClass()) == String.class) // bypass checks
return c; // 如果是String类型，直接返回String.class
if ((ts = c.getGenericInterfaces()) != null) {// 判断是否有直接实现的接口
for (int i = 0; i < ts.length; ++i) { // 遍历直接实现的接口
if (((t = ts[i]) instanceof ParameterizedType) &&// 该接口实现了泛型
((p = (ParameterizedType)t).getRawType() ==// 获取接口不带参数部分的类型对象
Comparable.class) &&// 该类型是Comparable
(as = p.getActualTypeArguments()) != null && // 获取泛型参数数组
as.length == 1 && as[0] == c) // 只有一个泛型参数，且该实现类型是该类型本身
return c;
}
}
}
return null;
}
/**
* kc是k的类型，并且可以比较
*/
@SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
static int compareComparables(Class<?> kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable)k).compareTo(x));
}
/**
* 返回不小于cap的最小的2的整次幂
*/
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;
}
7、迭代器
/**
* 这里我感觉设计的还挺好的，这里是编写了一个Node节点的迭代器，这是一个抽象类，虽然是个抽象类，但是没哟抽象方法
* 留下了next方法去给子类实现，因为子类只有nest返回的东西是不同的
*/
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = 0;
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
}
public final boolean hasNext() {
return next != null;
}
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
//注意，这里在生成迭代器后，如果原来的图不是通过迭代器进行对图结构修改，那么就会报错
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
//在不是通过remove修改之前，通过其他方式是不允许修改图的结构的
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
final class KeyIterator extends HashIterator
implements Iterator<K> {
public final K next() { return nextNode().key; }
}
final class ValueIterator extends HashIterator
implements Iterator<V> {
public final V next() { return nextNode().value; }
}
final class EntryIterator extends HashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() { return nextNode(); }
}8、并行遍历迭代器
/**
* jdk1.8发布后，对于并行处理的能力大大增强，Spliterator就是为了并行遍历元素而设计的一个迭代器，
* jdk1.8中的集合框架中的数据结构都默认实现了spliterator
*
*/
static class HashMapSpliterator<K,V> {
final HashMap<K,V> map;
Node<K,V> current; // 当前节点
int index; // 当前节点下标，advance/split会修改这个值
int fence; // 最后一个节点的下标，注意这里不是元素个数，而是数组下标
int est; // 预测还有多少个元素
int expectedModCount; // 得到当前Map的结构修改次数
HashMapSpliterator(HashMap<K,V> m, int origin,
int fence, int est,
int expectedModCount) {
this.map = m;
this.index = origin;
this.fence = fence;
this.est = est;
this.expectedModCount = expectedModCount;
}
final int getFence() { // initialize fence and size on first use
int hi;
if ((hi = fence) < 0) {//当小于0的时候说明还没有初始化
HashMap<K,V> m = map;
est = m.size;
expectedModCount = m.modCount;
Node<K,V>[] tab = m.table;
hi = fence = (tab == null) ? 0 : tab.length;//这里可以看到给出的是数组长度
}
return hi;
}
public final long estimateSize() {
getFence(); // 这里是防止还没有初始化的情况
return (long) est;
}
}
static final class KeySpliterator<K,V>
extends HashMapSpliterator<K,V>
implements Spliterator<K> {
KeySpliterator(HashMap<K,V> m, int origin, int fence, int est,
int expectedModCount) {
super(m, origin, fence, est, expectedModCount);
}
/**
* 这个方法相当于把未遍历的元素分成两半，然后将前一半生成一个KeySpliterator，当前这个KeySpliterator
* 处理后一半数据
*/
public KeySpliterator<K,V> trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
return (lo >= mid || current != null) ? null :
new KeySpliterator<>(map, lo, index = mid, est >>>= 1,//est >>>= 1的意思是est = est >>> 1
expectedModCount);
}
/**
* 这个方法就是通过action方法处理还没有处理的元素
*/
public void forEachRemaining(Consumer<? super K> action) {
int i, hi, mc;
if (action == null)
throw new NullPointerException();
HashMap<K,V> m = map;
Node<K,V>[] tab = m.table;
if ((hi = fence) < 0) {//如果还没有被初始化
mc = expectedModCount = m.modCount;
hi = fence = (tab == null) ? 0 : tab.length;
}
else
mc = expectedModCount;//这个mc就是为了在KeySpliterator调用的过程中确认没有通过其他的方式改变Map的结构
if (tab != null && tab.length >= hi &&
(i = index) >= 0 && (i < (index = hi) || current != null)) {
Node<K,V> p = current;
current = null;
do {
if (p == null)//这里是处理数组
p = tab[i++];
else {//这里是处理链表
action.accept(p.key);
p = p.next;
}
} while (p != null || i < hi);
if (m.modCount != mc)
throw new ConcurrentModificationException();
}
}
//单个对元素执行给定的动作，如果有剩下元素未处理返回true，否则返回false
public boolean tryAdvance(Consumer<? super K> action) {
int hi;
if (action == null)
throw new NullPointerException();
Node<K,V>[] tab = map.table;
if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
while (current != null || index < hi) {
if (current == null)
current = tab[index++];
else {
K k = current.key;
current = current.next;
action.accept(k);
if (map.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
}
}
return false;
}
//返回当前对象有哪些特征值
public int characteristics() {
return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) |
Spliterator.DISTINCT;
}
}
//下面的就不再赘述，只是用方法处理的对象不一样，其他的都和上面一样
static final class ValueSpliterator<K,V>
extends HashMapSpliterator<K,V>
implements Spliterator<V> {
ValueSpliterator(HashMap<K,V> m, int origin, int fence, int est,
int expectedModCount) {
super(m, origin, fence, est, expectedModCount);
}
public ValueSpliterator<K,V> trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
return (lo >= mid || current != null) ? null :
new ValueSpliterator<>(map, lo, index = mid, est >>>= 1,
expectedModCount);
}
public void forEachRemaining(Consumer<? super V> action) {
int i, hi, mc;
if (action == null)
throw new NullPointerException();
HashMap<K,V> m = map;
Node<K,V>[] tab = m.table;
if ((hi = fence) < 0) {
mc = expectedModCount = m.modCount;
hi = fence = (tab == null) ? 0 : tab.length;
}
else
mc = expectedModCount;
if (tab != null && tab.length >= hi &&
(i = index) >= 0 && (i < (index = hi) || current != null)) {
Node<K,V> p = current;
current = null;
do {
if (p == null)
p = tab[i++];
else {
action.accept(p.value);
p = p.next;
}
} while (p != null || i < hi);
if (m.modCount != mc)
throw new ConcurrentModificationException();
}
}
public boolean tryAdvance(Consumer<? super V> action) {
int hi;
if (action == null)
throw new NullPointerException();
Node<K,V>[] tab = map.table;
if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
while (current != null || index < hi) {
if (current == null)
current = tab[index++];
else {
V v = current.value;
current = current.next;
action.accept(v);
if (map.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
}
}
return false;
}
public int characteristics() {
return (fence < 0 || est == map.size ? Spliterator.SIZED : 0);
}
}
static final class EntrySpliterator<K,V>
extends HashMapSpliterator<K,V>
implements Spliterator<Map.Entry<K,V>> {
EntrySpliterator(HashMap<K,V> m, int origin, int fence, int est,
int expectedModCount) {
super(m, origin, fence, est, expectedModCount);
}
public EntrySpliterator<K,V> trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
return (lo >= mid || current != null) ? null :
new EntrySpliterator<>(map, lo, index = mid, est >>>= 1,
expectedModCount);
}
public void forEachRemaining(Consumer<? super Map.Entry<K,V>> action) {
int i, hi, mc;
if (action == null)
throw new NullPointerException();
HashMap<K,V> m = map;
Node<K,V>[] tab = m.table;
if ((hi = fence) < 0) {
mc = expectedModCount = m.modCount;
hi = fence = (tab == null) ? 0 : tab.length;
}
else
mc = expectedModCount;
if (tab != null && tab.length >= hi &&
(i = index) >= 0 && (i < (index = hi) || current != null)) {
Node<K,V> p = current;
current = null;
do {
if (p == null)
p = tab[i++];
else {
action.accept(p);
p = p.next;
}
} while (p != null || i < hi);
if (m.modCount != mc)
throw new ConcurrentModificationException();
}
}
public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> action) {
int hi;
if (action == null)
throw new NullPointerException();
Node<K,V>[] tab = map.table;
if (tab != null && tab.length >= (hi = getFence()) && index >= 0) {
while (current != null || index < hi) {
if (current == null)
current = tab[index++];
else {
Node<K,V> e = current;
current = current.next;
action.accept(e);
if (map.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
}
}
return false;
}
public int characteristics() {
return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) |
Spliterator.DISTINCT;
}
}9、JDK1.8新增的方法部分
@Override
public V getOrDefault(Object key, V defaultValue) {//如果没有key的情况下会返回defaultValue
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
@Override
public V putIfAbsent(K key, V value) {//当存在key的时候，不会用value去覆盖
return putVal(hash(key), key, value, true, true);
}
@Override
public boolean remove(Object key, Object value) {//当key和value都相同时，才去删除这个值
return removeNode(hash(key), key, value, true, true) != null;
}
@Override
public boolean replace(K key, V oldValue, V newValue) {//当key和oldValue都相同时，用newValue去代替oldValue
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) {//这个和上面方法不同在于，不用确定旧的值，直接覆盖，并且返回oldValue
Node<K,V> e;
if ((e = getNode(hash(key), key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}
/**
* 这个方法就类似于get方法，但是不同之处在于当key不存在时不时返回null，而是通过mappingFunction计算出一个值返回
*/
@Override
public V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
if (mappingFunction == null)
throw new NullPointerException();
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;
if (size > threshold || (tab = table) == null ||
(n = tab.length) == 0)
n = (tab = resize()).length;
if ((first = tab[i = (n - 1) & hash]) != null) {
if (first instanceof TreeNode)
old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
else {
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;
if (old != null && (oldValue = old.value) != null) {
afterNodeAccess(old);
return oldValue;
}
}
V v = mappingFunction.apply(key);
if (v == null) {
return null;
} else if (old != null) {
old.value = v;
afterNodeAccess(old);
return v;
}
else if (t != null)
t.putTreeVal(this, tab, hash, key, v);
else {
tab[i] = newNode(hash, key, v, first);
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
++modCount;
++size;
afterNodeInsertion(true);
return v;
}
//这个方法和尚一个方法不同的是，这个方法在key存在时，通过key和value算出一个新的value返回，如果不存在，返回null
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;
int hash = hash(key);
if ((e = getNode(hash, key)) != null &&
(oldValue = e.value) != null) {
V v = remappingFunction.apply(key, oldValue);
if (v != null) {
e.value = v;
afterNodeAccess(e);
return v;
}
else
removeNode(hash, key, null, false, true);
}
return null;
}
@Override
//这个方法综合了上面的两个方法，都会带入remappingFunction进行运算新值，并且替换旧值
public V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
if (remappingFunction == null)
throw new NullPointerException();
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;
if (size > threshold || (tab = table) == null ||
(n = tab.length) == 0)
n = (tab = resize()).length;
if ((first = tab[i = (n - 1) & hash]) != null) {
if (first instanceof TreeNode)
old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
else {
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 == null) ? null : old.value;
V v = remappingFunction.apply(key, oldValue);
if (old != null) {
if (v != null) {
old.value = v;
afterNodeAccess(old);
}
else
removeNode(hash, key, null, false, true);
}
else if (v != null) {
if (t != null)
t.putTreeVal(this, tab, hash, key, v);
else {
tab[i] = newNode(hash, key, v, first);
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
++modCount;
++size;
afterNodeInsertion(true);
}
return v;
}
@Override
//这个函数就是将oldVAlue和value通过remappingFunction进行一下混合，然后代替旧值
public V merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
if (value == null)
throw new NullPointerException();
if (remappingFunction == null)
throw new NullPointerException();
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;
if (size > threshold || (tab = table) == null ||
(n = tab.length) == 0)
n = (tab = resize()).length;
if ((first = tab[i = (n - 1) & hash]) != null) {
if (first instanceof TreeNode)
old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
else {
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);
}
}
if (old != null) {
V v;
if (old.value != null)
v = remappingFunction.apply(old.value, value);
else
v = value;
if (v != null) {
old.value = v;
afterNodeAccess(old);
}
else
removeNode(hash, key, null, false, true);
return v;
}
if (value != null) {
if (t != null)
t.putTreeVal(this, tab, hash, key, value);
else {
tab[i] = newNode(hash, key, value, first);
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
++modCount;
++size;
afterNodeInsertion(true);
}
return value;
}
@Override
//对于Map中的每一项，进行action运算
public void forEach(BiConsumer<? super K, ? super V> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.key, e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
@Override
//Map中所有的值，都会被function(key,value)替换为新值
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Node<K,V>[] tab;
if (function == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
e.value = function.apply(e.key, e.value);
}
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
451
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
