版权声明：本文为博主原创文章，欢迎大家转载！
但是转载请标明出处： https://blog.csdn.net/t000818/article/details/82883103 ，本文出自:【唐宏宇的博客】
备注：以下都是基于JDK8 源码分析
HashMap简介
HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
值得注意的是HashMap不是线程安全的，如果想要线程安全的HashMap，可以使用ConCurrentHashMap
HashMap的数据结构
HashMap的底层主要是基于数组和链表来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置。HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。学过数据结构的同学都知道，解决hash冲突的方法有很多，HashMap是通过数组+链表+红黑树来解决hash冲突的
从源码可知，HashMap类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组，明显它是一个Node的数组。
Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)。上图中的每个黑色圆点就是一个Node对象。
代码如下：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//用来定位数组索引位置
final K key;
V value;
Node<K,V> next;//链表的下一个node
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就是使用哈希表来存储的。哈希表为解决冲突，可以采用开放地址法和链地址法等来解决问题，Java中HashMap采用了链地址法。链地址法，简单来说，就是数组加链表的结合。在每个数组元素上都一个链表结构，当数据被Hash后，得到数组下标，把数据放在对应下标元素的链表上。例如程序执行下面代码：
map.put("美团","小美");系统将调用”美团”这个key的hashCode()方法得到其hashCode 值（该方法适用于每个Java对象），然后再通过Hash算法的后两步运算（高位运算和取模运算，下文有介绍）来定位该键值对的存储位置，有时两个key会定位到相同的位置，表示发生了Hash碰撞。当然Hash算法计算结果越分散均匀，Hash碰撞的概率就越小，map的存取效率就会越高。
如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。那么通过什么方式来控制map使得Hash碰撞的概率又小，哈希桶数组（Node[] table）占用空间又少呢？答案就是好的Hash算法和扩容机制。
HashMap属性
/**
* 初始容量，也就是默认会创建 16 个箱子，箱子的个数不能太多或太少。如果太少，很容易触发扩容，
* 如果太多，遍历哈希表会比较慢
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的负载因子。因此初始情况下，当键值对的数量大于 16 * 0.75 = 12 时，就会触发扩容
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
*树化链表节点的阈值，当某个链表的长度大于或者等于这个长度，则将链表转为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 在扩容时，如果发现链表长度小于 6，则会由树重新退化为链表
*
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。这是为了避免在哈希表建
* 立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化.
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 存储数据的Node数组，长度是2的幂。
*/
transient Node<K,V>[] table;
/**
* keyset 方法要返回的结果
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* map中保存的键值对的数量
*/
transient int size;
/**
* hashmap 对象被修改的次数
*/
transient int modCount;
/**
* threshold = (capacity * load factor)，如果键值对的数量等于该值，则调用resize方法，扩大
* 容量，同时修改threshold的值。
*
* @serial
*/
int threshold;
/**
* 加载因子
*
*
*/
final float loadFactor;
学过概率论的读者也许知道，理想状态下哈希表的每个箱子中，元素的数量遵守泊松分布:
当负载因子为 0.75 时，上述公式中 λ 约等于 0.5，因此箱子中元素个数和概率的关系如下:
| 数量 | 概率 |
|---|---|
| 0 | 0.60653066 |
| 1 | 0.30326533 |
| 2 | 0.07581633 |
| 3 | 0.01263606 |
| 4 | 0.00157952 |
| 5 | 0.00015795 |
| 6 | 0.00001316 |
| 7 | 0.00000094 |
| 8 | 0.00000006 |
这就是为什么箱子中链表长度超过 8 以后要变成红黑树，因为在正常情况下出现这种现象的几率小到忽略不计。一旦出现，几乎可以认为是哈希函数设计有问题导致的。
Java 对哈希表的设计一定程度上避免了不恰当的哈希函数导致的性能问题，每一个箱子中的链表可以与红黑树切换。
构造方法
默认构造方法
默认构造方法将使用默认的加载因子（0.75）初始化。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
HashMap(int initialCapacity, float loadFactor)
使用指定的初始容量和默认的加载因子初始化HashMap，这里需要注意的是，并不是你指定的初始容量是多少那么初始化之后的HashMap的容量就是多大，例如new HashMap(20,0.8); 那么实际的初始化容量是32，因为tableSizeFor（）方法会严格要求把初始化的容量是以2的次方数成长只能是16、32、64、128
/**
* 指定初始容量和负载因子的空哈希表
*
* @param initialCapacity 初始化容量
* @param loadFactor 加载因子
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
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方法的实现：
/**
* 计算并返回一个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;
}
这是一个小巧但精妙的方法，这里通过异或的位运算将两个字节的 n 打造成比 cap 大但最接近 2 的 n 次幂的一个数值。首先，为什么要对cap做减1操作。int n = cap - 1; 这是为了防止，cap已经是2的幂。如果cap已经是2的幂， 又没有执行这个减1操作，则执行完后面的几条无符号右移操作之后，返回的capacity将是这个cap的2倍。
下面看看这几个无符号右移操作：
如果n这时为0了（经过了cap-1之后），则经过后面的几次无符号右移依然是0，最后返回的capacity是1（最后有个n+1的操作）。
这里只讨论n不等于0的情况。
第一次右移
n |= n >>> 1;第二次右移
n |= n >>> 2;注意，这个n已经经过了n |= n >>> 1; 操作。假设此时n为000011xxxxxx ，则n无符号右移两位，会将最高位两个连续的1右移两位，然后再与原来的n做或操作，这样n的二进制表示的高位中会有4个连续的1。如00001111xxxxxx 。
第三次右移
n |= n >>> 4;这次把已经有的高位中的连续的4个1，右移4位，再做或操作，这样n的二进制表示的高位中会有8个连续的1。如00001111 1111xxxxxx 。
以此类推
注意，容量最大也就是32bit的正数，因此最后n |= n >>> 16; ，最多也就32个1，但是这时已经大于了MAXIMUM_CAPACITY ，所以取值到MAXIMUM_CAPACITY 。
put方法
执行逻辑：
1）根据key计算当前Node的hash值，用于定位对象在HashMap数组的哪个节点。
2）判断table有没有初始化，如果没有初始化，则调用resize（）方法为table初始化容量，以及threshold的值。
3）根据hash值定位该key 对应的数组索引，如果对应的数组索引位置无值，则调用newNode（）方法，为该索引创建Node节点
4）如果根据hash值定位的数组索引有Node，并且Node中的key和需要新增的key相等，则将对应的value值更新。
5）如果在已有的table中根据hash找到Node，其中Node中的hash值和新增的hash相等，但是key值不相等的，那么创建新的Node，放到当前已存在的Node的链表尾部。
如果当前Node的长度大于8,则调用treeifyBin（）方法扩大table数组的容量，或者将当前索引的所有Node节点变成TreeNode节点，变成TreeNode节点的原因是由于TreeNode节点组成的链表索引元素会快很多。
5）将当前的key-value 数量标识size自增，然后和threshold对比，如果大于threshold的值，则调用resize（）方法，扩大当前HashMap对象的存储容量。
6）返回oldValue或者null。
put 方法比较经常使用的方法，主要功能是为HashMap对象添加一个Node 节点，如果Node存在则更新Node里面的内容。
/**
* 将数据存入哈希表中，如果Key相同，则旧的Value将会被覆盖
*
* @param key
* @param value
* @return 如果Key相同，对应返回旧的value，如果没有则返回null
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
*
*
* @param hash Key的hash值
* @param key
* @param value
* @param onlyIfAbsent 如果为true，则不会替换旧的value
* @param evict if false,
* @return 如果Key相同，对应返回旧的value，如果没有则返回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;
if ((tab = table) == null || (n = tab.length) == 0)
//如果 table 还未被初始化，那么初始化它
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//根据键的 hash 值找到该键对应到数组中存储的索引
//如果为 null，那么说明此索引位置并没有被占用,则新建Node存到table中
tab[i] = newNode(hash, key, value, null);
else {//不为 null，说明此处已经被占用，则需要判断几种情况
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//当前结点和将要插入的结点的 hash 和 key 相同，说明这是一次修改操作
e = p;
else if (p instanceof TreeNode)
//如果 p 这个头结点是红黑树结点的话，以红黑树的插入形式进行插入
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果hash值一致，但是key不一致，那么将新的key-value遍历此条链表，
将构建一个节点插入到该链表的尾部
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1)
//如果插入后链表长度大于等于 8 ，将链表裂变成红黑树
treeifyBin(tab, hash);
break;
}
//遍历的过程中，如果发现与某个结点的 hash和key，这依然是一次修改操作
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e 不是 null，说明当前的 put 操作是一次修改操作并且e指向的就是需要被修改的结点
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//hash值和key值相等的情况下，更新value值
e.value = value;
//留给LinkedHashMap实现
afterNodeAccess(e);
//返回旧的value
return oldValue;
}
}
++modCount;
//如果添加后，数组容量达到阈值，进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}上面调用到了一个resize方法， 实现逻辑如下：
1）如果当前数组为空，则初始化当前数组
2）如果当前table数组不为空，则将当前的table数组扩大两倍，同时将阈值（threshold）扩大两倍
数组长度和阈值扩大成两倍之后，将之前table数组中的值全部放到新的table中去
/**
* 初始化或者加倍扩容哈希表，table的容量是按照2的指数增长的。
* 当扩量的时候，元素的hash值以及位置可能发生变化。
*
* @return the table
*/
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) {
//达到极限容量，不能扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//未达到极限容量，将其容量（size）和阈值（threshold）扩大两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//数组未初始化，但阈值不为 0，为什么不为 0 ？
//上述提到 jdk 大神偷懒的事情就指的这，构造函数根据传入的容量打造了一个合适的数组容量暂
//存在阈值中这里直接使用
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//数组未初始化并且阈值也为0，说明一切都以默认值进行构造
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//这里也是在他偷懒的后续弥补
//newCap = oldThr 之后并没有计算阈值，所以 newThr = 0
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将新的阈值存储起来
threshold = newThr;
//根据新的容量创建新的哈希表
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//旧数组不为 null，这次的 resize 是一次扩容行为
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)
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;
//计算hash&容量是否为0，如果是0，则仍然在原位置
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) {//新索引+oldCap存放链表
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
这部分其实是一个优化操作，将当前链表上的一些结点移出来向刚扩容的另一半存储空间放，一般我们有如下公式：
index = e.hash & (oldCap - 1)
//计算下标
e.hash 0000 0000 0000 0101 0111 0101 0100 0101
oldCap=16 0000 0000 0000 0000 0000 0000 0001 0000
index =e.hash&(oldCap-1) 0101 0111 0101 0100 0101 & 1111 = 0101 = 5
//扩容后，计算下标，位置不变
e.hash 0000 0000 0000 0101 0111 0101 0100 0101
newCap=32 0000 0000 0000 0000 0000 0000 0010 0000
index =e.hash&(newCap-1) 0101 0111 0101 0100 0101 & 11111 = 0101 = 5
//计算下标
e.hash 0000 0000 0000 0101 0111 0101 0101 0101
oldCap=16 0000 0000 0000 0000 0000 0000 0001 0000
index =e.hash&(oldCap-1) 0101 0111 0101 0100 0101 & 1111 = 0101 = 5
//扩容后，计算下标。下标=原下标+oldCap
e.hash 0000 0000 0000 0101 0111 0101 0101 0101
newCap=32 0000 0000 0000 0000 0000 0000 0010 0000
index =e.hash&(newCap-1) 0101 0111 0101 0100 0101 & 11111 = 10101 = 5+16由以上我们可以得出为什么要计算 e.hash & (oldCap) == 0。
如果原 oldCap 为 10000 的话，那么扩容后的 newCap 则为 100000，会比原来多出一位。所以我们只要知道原索引值的前一位是 0 还是 1 即可，如果是 0，那么它和新容量与后还是 0 并不改变索引的值，如果是 1 的话，那么索引值会增加 oldCap。
这样就分两步拆分当前链表，一条链表是不需要移动的，依然保存在当前索引值的结点上，另一条则需要变动到 index + oldCap 的索引位置上。
e.hash 0000 0000 0000 0101 0111 0101 0100 0101
oldCap=16 0000 0000 0000 0000 0000 0000 0001 0000
index =e.hash&(oldCap) 0101 0111 0101 0100 0101 & 1000 = 0
e.hash 0000 0000 0000 0101 0111 0101 0101 0101
newCap=32 0000 0000 0000 0000 0000 0000 0001 0000
index =e.hash&(oldCap) 0101 0111 0101 0100 0101 & 10000 = 10000下面我们来看看treeifyBin方法的具体实现
/**
* 如果table长度太小，则扩大table 的数组长度
* 否则，将所有链表节点变成TreeNode，提高索引效率
*
*/
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);
}
}
get方法
根据key的hash值和key，可以唯一确定一个value，下面我们来看看get方法执行的逻辑
1）根据key计算hash值
2）根据hash值和key 确定所需要返回的结果，如果不存在，则返回空。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 根据hash和key获取节点
*
* @param hash key的hash值
* @param key
* @return 返回节点，否则返回null
*/
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) {
//找到指定节点的第一个节点，如果hash值和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) {//如果索引到的第一个Node 不符合要求，循环变量它的下一个节点
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;
}containsKey方法
containsKey方法实际也是调用getNode方法实现的，如果key对应的value不存在则返回false
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
containsValue方法
containsValue方法的话需要遍历对象所有的value，遇到value相等的，则返回true，具体实现如下
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) {
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;
}remove方法
执行逻辑：
1）根据key得到key的hash值
2）根据key 和hash值定位需要remove的Node
3) 将Node从对应的链表移除，然后再将Node 前后的节点对接起来。如果是待删结点就是一个头节点，那么用它的 next 结点顶替它作为头节点存放在 table[index] 中，如果删除的是普通链表中的一个节点，用该结点的前一个节点直接跳过该待删结点指向它的 next 结点即可
4）如果 removeNode 方法删除成功将返回被删结点，否则返回 null
5）key-value的数量减一，修改次数加一
/**
* 移除与哈希表中与该Key匹配的节点
*
* @param key
* @return 返回删除指定Key的value，如果没有匹配或者value为null，都会返回null
*
*/
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
* @param value t
* @param matchValue 如果是true，value相等才删除节点
* @param movable 如果是false，删除节点后，不移动其他节点
* @return 返回节点，如果是null返回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;
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))))
//第一个找到的节点，如果hash值和key完全相同，则删除。
node = p;
else if ((e = p.next) != null) {
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;
break;
}
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)//头节点被删除，将它next的节点接上
tab[index] = node.next;
else//链表中某个节点被删，用该结点的前一个节点直接跳过该待删结点指向它的 next 结点
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
replace方法
replace(K key, V value)
根据key定位到Node，然后将Node中的value 替换，返回旧的value，否则返回空
@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;
}replace(K key, V oldValue, V newValue)
根据key和value定位到Node，然后将Node中的value用新value 替换，返回旧的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)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
clear方法
clear 方法将每个数组元素置空
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;
}
}
KeySet
HashMap 中定义了一个 keySet 的实例属性，它保存的是整个 HashMap 中所有键的集合。下面所列出的 KeySet 类是 Set 的一个实现类，它负责为我们提供有关 HashMap 中所有对键的操作。
可以看到，KeySet 中的所有的实例方法都依赖当前的 HashMap 实例，也就是说，我们对返回的 keySet 集中的任意一个操作都会直接映射到当前 HashMap 实例中，例如你执行删除一个键的操作，那么 HashMap 中将会少一个节点
/**
* 返回一个包含当前哈希表中所有Key的集合，这个集合是当前map的映射备份
* 如果修改此集合也会同步修改该表，反之亦然。当正在迭代遍历该集合的时候，
* 修改该表，则结果不可预知。
*
* @return a set view of the keys contained in this map
*/
public Set<K> keySet() {
Set<K> ks = keySet;
if (ks == null) {
ks = new KeySet();
keySet = ks;
}
return ks;
}
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 (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.key);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
values方法
values 方法其实和 keySet 方法类似，它返回了所有节点的 value 属性所构成的 Collection 集合。
/**
* 返回一个包含当前Map所有value的集合，该集合是当前map的映射备份，如果
* 对集合做修改，map也会被修改，反之亦然。
*
* @return
*/
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 (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
EntrySet
它返回的是所有节点的集合，或者说是所有的键值对集合。
/**
* 返回一个包含当前Map的所有键值对的集合，该集合是当前Map的映射备份he
*
* @return
*/
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 (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
参考链接：
https://blog.csdn.net/fighterandknight/article/details/61624150
https://blog.csdn.net/fan2012huan/article/details/51097331
http://www.importnew.com/20386.html
520
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
