一般般帅
上一篇:LinkedList详解
HashMap详解*
5622 2017-09-25 2020-06-25
前言：这次我们看下传说中面试必问的HashMap。
一、类结构
1、概述
常规的类结构声明，值得注意的是里面的常量定义，如下
// 基于JDK8
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
// 默认的初始容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量即2的30次方，注意int最大值为2^31 - 1,这个值是经过考虑而决定的
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认的加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 由链表转换成红黑树的阈值（又称临界值），树化阀值
static final int TREEIFY_THRESHOLD = 8;
// 由红黑树转换成链表的阈值，去树化阀值
static final int UNTREEIFY_THRESHOLD = 6;
// 链表树化时最小的hash表容量，树化最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
// 不可被序列化的Node[]数组，元素键值对，又称哈希桶数组
transient Node<K,V>[] table;
// 用于迭代遍历的Set缓存集合
transient Set<Map.Entry<K,V>> entrySet;
// Map容器存放的键值对个数
transient int size;
// 对容器大小进行修改的次数，可以根据这个值判断是否在高并发情况下出现问题
transient int modCount;
// 扩容的阀值，threshold = length * loadFactor，如默认为16 * 0.75,那么大于12时就要扩容了
int threshold;
// 加载因子，限定阀值，可以大于1
final float loadFactor;
// 其它略
}
更详细的解释说明见下文。
2、内部类Node
这个内部类是HashMap内部键值对的载体，它可以单个存在，也可以以链表方式存在，还可以以红黑树的方式存在，实际上，它在HashMap内部就是这三种形态。详见下文图4-1。
// 内部类Entry是一个规范，下面的TreeNode也实现了，因此可以用父接口Map.Entry<K,V>代替两者
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;// 这个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() {
// 返回Node的哈希值，异或运算符，相同为0，不同为1
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;
}
}
3、内部类TreeNode
这个就是下文提到红黑树的数据结构了，占了HashMap源代码的四分之一。类似于二叉树，定义了一些对树节点增删改查的操作，这里简单提一下红黑树的概念。
红黑树（red black tree）是具有下列着色性质的二叉查找树：
- 每一个节点或者着成红色，或者着成黑色。
- 根是黑色的。
- 如果一个节点是红色的，那么它的子节点必须是黑色的。
- 所有叶子都是黑色（叶子是NIL或NULL节点，即空引用）。
- 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
这些约束确保了红黑树的关键特性：从根到叶子的最长的可能路径不多于最短的可能路径的两倍长，结果是这个树大致上是平衡的。
/**
* Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn
* extends Node) so can be used as extension of either regular or
* linked node.
*/
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;
// 其他略
}
二、构造方法
本质只有一个构造方法，如下
// 默认的初试容量为1 << 4为16(向左移位4个单位，乘以2的4次方)，加载因子为0.75f
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);//往下看
}
// >>>表示无符号右移,高位补0 表示>>表示带符号右移，两者对于正数没有区别，对于负数有区别，这里需要用>>>
static final int tableSizeFor(int cap) {
int n = cap - 1;// 原理等同与n += 1，即n = n + 1
n |= n >>> 1; // 于是n = n | n>>>2，n>>>2近似n>>2，即除以2的2次方，再进行或运算(有1为1)
n |= n >>> 2;// 假设n为100，二进制数为100 0100
n |= n >>> 4;// 1)一路除下来为n=100 0100|10 0010=110 0110
n |= n >>> 8;// 2)n=110 0110|1 1001=111 1111
n |= n >>> 16;// 3),4)都是n = 111 1111=127
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
// 后面这个有点吓人，但其实从右往左看，返回为n+1=128
// 由此我们可以推断这个函数的作用了，为返回最小大于目标数的2的幂次方，这个数是有特殊用意的
}
三、hash方法
在正式介绍入口-put方法和出口-get方法之前，需要一些准备工作。我们先来看先哈希码的计算，因为整个HashMap都是基于哈希码的（又称散列）
-
第一步：确定对象哈希值（码）
在有关数据结构的课程中，针对哈希的构造方法一般有这么几种：直接地址法（对象地址的一个函数）、数字分析法（数据有数字规律）、平方取中法（平方后选取中间几位）、折叠法、除留余数法、随机数法。在这里的哈希构造是基于二进制的位运算。注意，这里对null进行了特殊处理。
static final int hash(Object key) {
int h;
// 返回对象的哈希值，并与h>>>16进行异或运算（相同为0，不同为1）
// 假设127，则有111 1111 ^ 0 = 127
// 假设65535,1111 1111 1111 1111 ^ 0 = 65535说明对于16位以下的二进制没影响
// 假设262143,11 1111 1111 1111 1111 ^ 011 = 262140，后面四位为1000
// 注意这里对null的特殊处理
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
// 据说高16位异或低16位，可以有效的优化哈希碰撞。唉，处处皆学问
}
- 第二步：确定在数组中的位置
n = (tab = resize()).length//为2的倍数
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//出现哈希碰撞，添加至链表或红黑树中
}
在数组中的位置是通过容器大小 - 1与对象哈希值进行与运算得出的，借用一下别人的图，由计算哈希值，到定位在数组中的位置，整个过程大致如下
小结：通过某种算法确定了哈希值，再使用某种算法由哈希值确定在数组中的位置，若出现哈希冲突，再选定某种数据结构进行扩展补充，这就是整个HashMap的核心思想了。核心点就是这两种算法的选定以及如何优化哈希冲突了，既要考虑到在数组中分布均匀，还要考虑减少碰撞，以及如何优化碰撞。
这里有两个问题，一是为什么哈希值=hashCode ^ hashCode >>> 16，二是为什么是(n - 1) & hash。对于第一个疑问，这里引用一下别人的
- 右位移16位，正好是32bit的一半，自己的高半区和低半区异或（不同为1，相同为0），就是为了混合原始码的高位和低位，以此加大随机性。而且混合的低位掺杂了高位的部分特征，这样高位的信息被变相的保存了下来。
对于第二个，这里引用一下别人的
- 看下图，左边两组是数组长度为16（2的4次方），右边两组是数组长度为15。两组的hashcode均为8和9，但是很明显，当它们和1110“与”的时候，产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到同一个链表上，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hashcode的值会与14（1110）进行“与”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！
这也解释了n为什么要为2的幂次方，因为这可以在一定程度上避免哈希冲突。
四、resize方法
知道了HashMap的核心思想后，一个关键问题出现了。多次put后，如何动态调整哈希桶（键值对载体或容器）数组的大小呢？实际上，HashMap内部有一系列规则对哈希桶数组大小进行约束，其主要实现就是resize方法。 这个方法管理着Map容器的大小，或者说键值对容纳数组Node<K,V>[] table的大小。在看代码之前，我们借用一下别人的图，如下
我们知道HashMap内部是数组来存储的键值对的，这个解释是不完整的，它内部还可能依赖于链表和红黑树（当哈希值冲突时），下面针对开头出现的一大堆常量进行说明（本文有时会以“容器”代替“内部键值对数组“，不区分两者）
- 默认的容量是16，加载因子是0.75。
- 上面出现的链表，单个长度大于8个时，且容器的容量大于等于64，转换为红黑树存储。
- 红黑树个数小于6个时，转换为链表存储。
- 容器阀值=加载因子 * 容器大小，当容器大小大于阀值时，进行扩容（非极端情况下，阀值和容量翻倍）。
下面我们来看代码实现
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the 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;
// 已经初始化过
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {// 对最大值的处理
threshold = Integer.MAX_VALUE;// 阀值为Integer.MAX_VALUE
return oldTab; // 已到达容纳上线
}
// 如果容器的两倍小于2的30次方且现容量>=16，newCap = 2 * oldCap
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;
// 无参的HashMap构造
else { // 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"})
// 好奇为什么不是new Node<K,V>[newCap]吗？请看泛型那一节
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) {// 只针对不为空的哈希项
// e和oldTab[j]都指向堆内存特定块，因此oldTab的改变不会影响e
oldTab[j] = null;// 老容器的哈希项为null，但e不为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 对链表的处理，猜测是把链表规范好，放进新容器
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;// 返回新容器
}
从上面代码中我们可以得知，每次进行容器大小改变（扩容）时，会将旧table里面的元素逐个添加到新table中，除了包含对链表节点、红黑树节点的特殊处理，还包含了对于元素扩容后位置的处理。简单总结一下（细节处请自行走一遍源代码）：
- 围绕上面所述4条规则，对容器内部存储结构进行约束。
- 围绕扩容后的容器大小（非极端情况下，容器大小和阀值翻倍），以便把原来的数据存进新的容器。
对于原来已存在的元素位置的处理，下面是一个例子
扩容后（非极端情况下，容量和阀值翻倍），原对象的hash值不变，则原容量1111变为了0001 1111，两者相与，结果只是第5位为0或1，即只能有两种可能。
- 为0的话，元素位置不变，这里体现为index = 0101 = 5（容量为n - 1 + 1 = 16）
- 为1的话，元素位置 = 元素位置 + 原始容量n，这里体现为index = 1 0101 = 21(容量为n - 1 + 1 = 32)
所以，对象的哈希值并不会因为扩容后哈希桶容量变化而变化，这里并不存在二次哈希。
五、主要操作
如果上面两个方法你都看懂了，那么下面的是水到渠成的了。
1、put方法
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;
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;
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) {
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;// 没错，返回的是null
}
水到渠成，不是吗？为了方便描述，再次借用一下别人的图（画得真好），如下
2、get方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
// 就是一系列节点的查找了，值得注意只有一点：根据哈希值找到数组位置后，但节点不唯一，即是链表或红黑树....
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 && // always check first node
((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;
}
当根据哈希值找到在数组中的位置时，它会根据对象的equals方法，再去找到唯一的目标对象。整个流程如下：
- 根据哈希值寻找在哈希桶数组中的位置，没有返回null；找到且.next为null，直接返回；否则执行下一步
- 调用equals方法比较两个对象，true的返回，否则返回null
通过上面我们知道，要想作为HashMap的键对象，必须要实现自己特定且有效的hashCode方法和equals方法，否则是不能作为一个有效的键对象的。那么什么是特定且有效的呢？它要满足以下条件：
- 必须重写hashCode方法，否则存进去的对象哈希值是可能是当前对象内存地址的一个函数(参见这篇)，这个内存地址可能被其他对象占用，意味着，键对象和值对象不是一一对应的关系。这是不行的！
- 无论何时何地，对于同一个对象，通过hashCode产生哈希值是确定的。而且，最好是基于对象的某些特征而产生的，不会被修改
- 必须重写equals方法，且equals方法是能确定对象的唯一性。因为hasCode具有不唯一性
鉴于以上几点，要想写一个可行的键对象也不是那么简单的。这里有个推荐（其实不推荐大家也是这么用得，虽然不知道为什么），就是包装类String、Integer等。包装类被声明为final，具有不变性，即hashCode不会发生改变，且equals能唯一确定一个对象，符合上面的所有条件，你有我用，何乐不为？
3、remove方法
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 {
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)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
有了前面的基础后，过一遍代码就大概知道了。分为三种情况，如下
- 键对象无效，返回null。
- 键对象有效，且值对象.next为null，移除并返回。
- 键对象有效，在值对象存在于链表中，链表移除该对象并返回。
- 键对象有效，在值对象存在于红黑树中，红黑树移除该对象并返回。
4、遍历
本质只有两种遍历，一种是先遍历所有key，再通过key找到value。一种是遍历Node内部类数组的非空节点。主要依托以下两种数据结构
final class KeySet extends AbstractSet<K> {
public final int size() { return size; }//返回的HashMap的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();
}
}
}
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public final int size() { return size; }//返回的HashMap的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();
}
}
}
通过源码我们可以得出以下结论：
- 所谓的遍历，是临时遍历，并非事先在某种容器中存储好的。
- 通过key遍历，首先需要查找Node内部类的K，再通过K，查找Node内部类的V，相当于查找了两次。
- 通过内部类Entry遍历，相对于每次遍历一个Node节点，只查找了一次，因此效率较好。
- 当然也可以通过迭代器来遍历，等同于foreach语句。
六、对比
| - | 应用场景 | 线程安全 | 是否允许null值 |
|---|---|---|---|
| HashMap | 非高并发情况下使用 | 否，没有采取同步措施 | 允许null键、null值 |
| Hashtable | 并发度不高情况下使用 | 是，public方法由synchronized修饰 | 不允许null键、null值 |
| HashSet | 用于某些去重的情况 | 否，内部还是使用HashMap | 允许null对象 |
对于并发度要求高的，JDK建议使用安全且高效的ConcurrentHashMap，读者可查看Java多线程的相关章节。下面是一些测试代码
// HashMap均可通过
// Hashtable均不通过，第一次put就会抛出异常
// ConcurrentHashMap同Hashtable，不允许null键和null值
private static void test(Map<String, Integer> map) {
map.put("1", null);
map.put(null, null);
map.put(null, 1);
System.out.println(map.get(1));
System.out.println(map.get(null));
}
对于为什么HashMap可以存null键值以及HashTable、ConcurrentHashMap不能存null键值对，我是这么想的。
ConcurrentHashmap和Hashtable都是支持并发的，这样会有一个问题，当你通过get(k)获取对应的value时，如果获取到的是null时，你无法判断，它是put(k,v)的时候value为null，还是这个key从来没有做过映射，这样会损失一些精度，故值不能为null。特别的，由于null作为键没有hashCode，如果允许null的话，需要对其做特殊处理，索性直接禁止使用null作为键（这点在使用的时候需要注意，个人认为这只是一个规范而已，硬要允许null键值也是可以的）。
HashMap是非并发的，可以通过contains(key)来做这个判断。而支持并发的Map在调用map.contains(key)和map.get(key)，map可能已经不同了。
七、总结
HashMap是我写博客以来，感觉最为有深度的一个了。覆盖了Java初级、Java高级、数据结构、算法等内容，被设计的很有深度，每个细节都是深思熟虑过的，值得好好看看。
总访问次数: 235次, 一般般帅 创建于 2017-09-25, 最后更新于 2020-06-25
欢迎关注微信公众号，第一时间掌握最新动态！