容器(十四):Map家族的老大哥 HashMap
标签: Java编程思想
HashMap在Map家族中的地位相当于ArrayList在List家族中的地位,是当之无愧的老大哥
什么是HashMap
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
顾名思义,HashMap是一个基于哈希表实现Map接口的集合。我们已经知道,hash的优势就是在查找时速度很快,因此:
HashMap 其特殊存储结构使得在获取指定元素前需要经过哈希运算,得到目标元素在哈希表中的位置,然后再进行少量比较即可得到元素,这使得 HashMap 的查找效率贼高。
虽然HashMap具有很快的访问速度,但遍历顺序却是不确定的。
HashMap最多只允许一条记录的键为null,允许多条记录的值为null。HashMap非线程安全,即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致。如果需要满足线程安全,可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力,或者使用ConcurrentHashMap。
HashMap 的特点
总结HashMap具有一下特点:
- 底层实现是链表 + 数组,JDK 8 后又加了红黑树
- 实现了 Map 全部的方法
- key 用 Set 存放,因此 key 不允许重复,如果重复,会覆盖
- 最多只允许一条记录的键为null(空键放在首位),允许多条记录的值为null。
- 元素是无序的,而且顺序会不定时改变,特别说明这个无序指的是遍历HashMap的时候,得到的元素的顺序基本不可能是put的顺序
- 插入、获取的时间复杂度基本是O(1)(前提是有适当的哈希函数,让元素分布在均匀的位置)
- 遍历整个 Map 需要的时间与 桶(数组) 的长度成正比(因此初始化时 HashMap 的容量不宜太大)
- 两个关键因子:初始容量、加载因子
- 除了不允许 null 并且同步,Hashtable 几乎和他一样。
- HashMap非线程安全,即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致。
HashMap的原理
首先简单讲解下HashMap的原理:
HashMap基于Hash算法,我们通过put(key,value)
来存储键值对,通过get(key)
来获取。当传入key时,HashMap会根据key.hashCode()
计算出hash值,根据hash值将value保存在“桶”里。当计算出的hash值相同时怎么办呢,我们称之为Hash冲突,HashMap的做法是用链表和红黑树存储相同hash值的value。当Hash冲突的个数比较少时,使用链表,否则使用红黑树。
从结构实现来讲,HashMap是数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的,如下如所示。
搞清楚HashMap,首先需要知道HashMap的内部存储结构;其次弄明白它能干什么,即它的功能实现方法。下面我们针对这两个方面详细展开讲解。
HashMap的内部结构
HashMap的成员变量
下面给出一些比较重要的成员变量:
- 默认初始容量:16,必须是 2 的整数次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
- 默认加载因子的大小:0.75,可不是随便的,结合时间和空间效率考虑得到的
static final float DEFAULT_LOAD_FACTOR = 0.75f;
- 阈值,所能容纳的key-value对极限
int threshold;
- 当前 HashMap 修改的次数,这个变量用来保证 fail-fast 机制
transient int modCount;
- 缓存的 键值对集合(另外两个视图:keySet 和 values 是在 AbstractMap 中声明的)
transient Set<Map.Entry<K,V>> entrySet;
- 哈希表中的链表数组
transient Node<K,V>[] table;
- 键值对的数量
transient int size;
- 哈希表的加载因子
final float loadFactor;
我们可以在HashMap的源码中找到这样一句:
transient Node<K,V>[] table;
很明显,HashMap还是凭借数组实现的,辅以链表和红黑树。我们知道数组的特点:寻址容易,插入和删除困难,而链表的特点是:寻址困难,插入和删除容易,红黑树则对插入时间、删除时间和查找时间提供了最好可能的最坏情况担保。HashpMap将这三者结合在一起。
初始容量和加载因子
由于 HashMap 扩容开销很大(需要创建新数组、重新哈希、分配等等),因此与扩容相关的两个因素:容量、加载因子成为了 HashMap 最重要的部分之一,它们决定了 HashMap 什么时候扩容:
- 容量:数组的数量
- 加载因子:决定了 HashMap 中的元素占有多少比例时扩容
HashMap 的默认加载因子为 0.75,这是在时间、空间两方面均衡考虑下的结果:
- 加载因子大,填满的元素多,空间利用率高,但是发生冲突的几率大,查找的效率低
- 加载因子小,填满的元素少,空间浪费多,但冲突的机会减小,查找效率高。
因此在设置初始容量时,需要提前考虑Map中可能有多少对键值对,设计合理的加载因子,尽可能避免进行扩容。
如果存储的键值对很多,干脆设置个大点的容量,这样可以少扩容几次。
构造方法
HashMap提供了三个构造函数:
HashMap()
: 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。HashMap(int initialCapacity)
: 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。HashMap(int initialCapacity, float loadFactor)
: 构造一个带指定初始容量和加载因子的空 HashMap。HashMap(Map<? extends K, ? extends V> m)
: 创建一个内容指定Map的一个HashMap。
重点:链表节点 Node<K,V>
前面提到,HashMap 的底层数据结构之一就是链表数组:transient Node<K,V>[] table;
,即哈希桶数组(桶这个概念,应该是指同一数组元素所对应的链表装载一个桶里)
明显它是一个Node的数组。我们来看Node[JDK1.8]是何物:
//Node是HashMap的一个内部类,实现了Map.Entry接口,本质是就是一个映射(键值对)
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //哈希值,用来定位数组索引位置
final K key;
V value;
Node<K,V> next; //链表,Node<K,V>类型的下一个node
//构造方法,需要传进hash值,键,值,链表的下一个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; }
//重写hashCode()方法
//对于Node节点的hashCode(),是key的hashCode 对 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()方法,以key和value的值相等作为判断依据
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
////Map.Entry 相等的条件:键相等、值相等、个数相等、顺序相等
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
分析:
Node是HashMap的一个内部类,实现了Map.Entry接口,本质是就是一个映射(键值对)。
HashMap就是使用哈希表来存储的。Java中HashMap采用了链地址法来解决冲突,简单来说,就是在每个数组元素上都有一个链表结构,当数据被Hash后,得到数组下标,把数据放在对应下标元素的链表上。
例如程序执行下面代码:
map.put("实验室","Japson");
系统将调用”实验室”这个key的hashCode()方法得到其hashCode值(该方法适用于每个Java对象),然后再通过Hash算法的后两步运算(高位运算和取模运算,下文有介绍)来定位该键值对的存储位置,有时两个key会定位到相同的位置,表示发生了Hash碰撞。当然Hash算法计算结果越分散均匀,Hash碰撞的概率就越小,map的存取效率就会越高。
这里面涉及两个概念:哈希桶和哈希桶数组:
- 哈希桶(Hash Bucket):哈希表中同一个位置可能存有多个元素,以应对哈希冲突问题。这样,哈希表中的每个位置表示一个哈希桶。
- 哈希桶数组(Hash bucket array):Node[] table
如果哈希桶数组很大,即使较差的Hash算法也会比较分散,如果哈希桶数组数组很小,即使好的Hash算法也会出现较多碰撞,所以就需要在空间成本和时间成本之间权衡,其实就是在根据实际情况确定哈希桶数组的大小,并在此基础上设计好的hash算法减少Hash碰撞。那么通过什么方式来控制map使得Hash碰撞的概率又小,哈希桶数组(Node[] table)占用空间又少呢?答案就是好的Hash算法和扩容机制。
功能方法
HashMap的内部功能实现很多,本文主要从根据key获取哈希桶数组索引位置、添加方法的详细执行、扩容过程、获取等几个具有代表性的点深入展开讲解。
确定哈希桶数组索引位置
不管增加、删除、查找键值对,定位到哈希桶数组的位置都是很关键的第一步。前面说过HashMap的数据结构是数组和链表的结合,所以我们当然希望这个HashMap里面的元素位置尽量分布均匀些,尽量使得每个位置上的元素数量只有一个,那么当我们用hash算法求得这个位置的时候,马上就可以知道对应位置的元素就是我们要的,不用遍历链表,大大优化了查询的效率。HashMap定位数组索引位置,直接决定了hash方法的离散性能。先看看源码的实现(方法一+方法二):
方法一:
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 将 hashCode 进行无符号右移 16 位,然后进行按位异或
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二:
static int indexFor(int h, int length) { //jdk1.7的源码,jdk1.8没有这个方法,但是实现原理一样的
return h & (length-1); //第三步 取模运算
}
这里的Hash算法本质上就是三步:取key的hashCode值、高位运算、取模运算。
对于任意给定的对象,只要它的hashCode()返回值相同,那么程序调用方法一所计算得到的Hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算,这样一来,元素的分布相对来说是比较均匀的。但是,模运算的消耗还是比较大的,在HashMap中是这样做的:调用方法二来计算该对象应该保存在table数组的哪个索引处。
这个方法非常巧妙,它通过h & (table.length - 1)
来得到该对象的保存位,而HashMap底层数组的长度总是2的n次方,这是HashMap在速度上的优化。当length总是2的n次方时,h& (length-1)
运算等价于对length取模,也就是h%length
,但是&比%具有更高的效率。
在JDK1.8的实现中,优化了高位运算的算法,通过hashCode()的高16位异或低16位实现的:(h = k.hashCode()) ^ (h >>> 16)
,主要是从速度、功效、质量来考虑的,这么做可以在数组table的length比较小的时候,也能保证考虑到高低Bit都参与到Hash的计算中,同时不会有太大的开销。
put方法
public V put(K key,V value)
添加指定的键值对到Map中,如果已经存在,就替换。
HashMap的put方法执行过程可以通过下图来理解:
步骤详解:
判断键值对数组table[i]是否为空或为null,若为空或null,则执行resize()进行扩容;
根据键值key计算hash值得到插入的数组索引i,如果table[i]==null,直接新建节点添加,转向6,如果table[i]不为空,转向3;
判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向4,这里的相同指的是hashCode以及equals;
判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向5;
遍历table[i],判断链表长度是否大于8,大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;
插入成功后,判断实际存在的键值对数量size是否超多了最大容量threshold,如果超过,进行扩容。
HashMap的put方法源码如下:
public V put(K key, V value) {
// 对key的hashCode()做hash,计算key的位置
return putVal(hash(key), key, value, false, true);
}
/**
* @param onlyIfAbsent 若是true,不更改现有值;若为false,则更改现有值。
* @param evict 若是true,则该表不是创建模式;若是false,则该表处于创建模式。
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//步骤1:当前哈希表tab为空则创建,n指向最后一个桶的位置
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//步骤2:计算哈希桶数组索引位置p:
//如果p位置为null,新建个节点并放进去
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果p位置已经有元素,则替换,过程如下:
else {
Node<K,V> e; // e 指向被替换的元素
K k;
// 步骤3:节点key存在(p的hash值和key都和要添加的一样)直接覆盖,令 e 指向 p
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 步骤4:如果判断该链为红黑树,调用 putTreeVal 插入
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//步骤5:若该链为链表,从链表数组查找、替换
else {
//遍历链表
for (int binCount = 0; ; ++binCount) {
//若是链表中最后一个节点,则将新Node节点插入
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果添加之后链表长度大于8,则转换为红黑树进行处理
if (binCount >= TREEIFY_THRESHOLD - 1)
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;
}
}
// 步骤6:超过最大容量 就扩容
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict); //这是一个空的方法
return null;
}
插入过程中涉及到几个其他关键的方法 :
hash()
:计算对应的位置
resize()
:扩容
putTreeVal()
:树形节点的插入
treeifyBin()
:树形化容器
afterNode系列方法
我们在putVal方法中看到,不少地方都调用了afterNodeAccess(e)
和afterNodeInsertion(evict)
方法,但是我们点进去之后发现,是一个空的方法。
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
这个三个方法都是为了继承HashMap的LinkedHashMap类服务的,将会在LinkedHashMap中被使用。
get方法
在理解了put之后,get就很简单了。大致思路如下:
- bucket里的第一个节点,直接命中;
- 如果有冲突,则通过key.equals(k)去查找对应的entry
- 若为树,则在树中通过key.equals(k)查找,O(logn);
- 若为链表,则在链表中通过key.equals(k)查找,O(n)。
具体代码的实现如下:
public V get(Object key) {
Node<K,V> e;
//返回key所对应的值
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNode(int hash, Object key)
需要传入key的hash值和key。
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) {
// 若是在红黑树中,则调用 getTreeNode(hash, key)方法
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 若是在链表中,通过对链表do-while循环对比来get
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
扩容机制
当put时,如果发现目前的bucket占用程度已经超过了Load Factor所希望的比例,也就是当前的size >= threshold,那么就会发生resize。在resize的过程,简单的说就是把bucket扩充为2倍,之后重新计算index,把节点再放到新的bucket中。resize的注释是这样描述的:
nitializes 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.
大致意思就是说,当超过限制的时候会resize,然而又因为我们使用的是2次幂的扩展(指长度扩为原来2倍),所以,元素的位置要么是在原位置,要么是在原位置再移动2次幂的位置。
怎么理解呢?例如我们从16扩展为32时,具体的变化如下所示:
因此元素在重新计算hash之后,因为n变为2倍,那么n-1的mask范围在高位多1bit(红色),因此新的index就会发生这样的变化:
因此,我们在扩充HashMap的时候,不需要重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”。可以看看下图为16扩充为32的resize示意图:
这个设计非常的巧妙,既省去了重新计算hash值的时间,而且同时,由于新增的1bit是0还是1可以认为是随机的,因此resize的过程,均匀的把之前的冲突的节点分散到新的bucket了。
下面是代码的具体实现:
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) { //当旧表的长度 > 0
// 若超过最大值就不再扩充了
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; // 二倍的阈值
}
//如果旧表长度为0,且旧阈值>0,说明之前创建了哈希表但没有添加元素,新的表长为原来的阈值
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和newThr后,计算新的resize上限:
//如果新的阈值为 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];
table = newTab;
//若旧表不空,则遍历旧表,复制到新表
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//将旧的桶赋给新的 e ,旧的桶置为空(方便回收)
oldTab[j] = null;
//当前的桶只有一个元素(即只有链表的头结点),直接赋值给对应位置
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//如果旧哈希表中这个位置的桶是红黑树,则调用split方法将新表的当前桶也变为红黑树
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-while 循环赋值给新哈希表
do {
next = e.next;
// 如果hash值新增的bit是0,则是原索引不变
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 如果hash值新增的bit是1,则新索引为原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
}
while ((e = next) != null);
// 原索引放到bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
总结扩容的思路:
- 判断旧表的长度,若没超过最大值,就将新表扩充为原来的2倍;
- 若之前创建了哈希表但没有添加元素,新的表长为原来的阈值;
- 若之前没创建哈希表,容量为默认容量,阈值为容量*加载因子(相当于初始化);
- 更新阈值
- 创建一个新的长度为原来表长2倍的数组,然后将旧表复制过去:
- 遍历旧表的每一个桶(位置);
- 若该桶没有next(只有链表的头节点),则直接赋值给对应位置;
- 若该桶是红黑树,则将新表的当前桶也变为红黑树;
- 若该桶是链表,则保留旧哈希表桶中链表的顺序:
- 如果hash值新增的bit是0,则是原索引不变;
- 如果hash值新增的bit是1,则新索引为原索引+oldCap;
- 装入桶中
总结
我们通过一些问题,加深对HashMap的理解:
- 什么时候会使用HashMap?他有什么特点?
答: 是基于Map接口的实现,存储键值对时,它可以接收null的键值,是非同步的,HashMap存储着Entry(hash, key, value, next)对象。
- 你知道HashMap的工作原理吗?
答: 通过hash的方法,通过put和get存储和获取对象。存储对象时,我们将K/V传给put方法时,它调用hashCode计算hash从而得到bucket位置,进一步存储,HashMap会根据当前bucket的占用情况自动调整容量(超过Load Facotr则resize为原来的2倍)。获取对象时,我们将K传给get,它调用hashCode计算hash从而得到bucket位置,并进一步调用equals()方法确定键值对。如果发生碰撞的时候,Hashmap通过链表将产生碰撞冲突的元素组织起来,在Java 8中,如果一个bucket中碰撞冲突的元素超过某个限制(默认是8),则使用红黑树来替换链表,从而提高速度。
- 你知道get和put的原理吗?equals()和hashCode()的都有什么作用?
答: 通过对key的hashCode()进行hashing,并计算下标( n-1 & hash),从而获得buckets的位置。如果产生碰撞,则利用key.equals()方法去链表或树中去查找对应的节点
- 你知道hash的实现吗?为什么要这样实现?
答: 在Java 1.8的实现中,是通过hashCode()的高16位异或低16位实现的:(h = k.hashCode()) ^ (h >>> 16),主要是从速度、功效、质量来考虑的,这么做可以在bucket的n比较小的时候,也能保证考虑到高低bit都参与到hash的计算中,同时不会有太大的开销。
- 如果HashMap的大小超过了负载因子(load factor)定义的容量,怎么办?
答: 如果超过了负载因子(默认0.75),则会重新resize一个原来长度两倍的HashMap,并且重新调用hash方法。
- 为什么哈希表的容量一定要是 2的整数次幂?
答: capacity 为2的整数次幂的话,计算桶的位置 h&(length-1) 就相当于对 length 取模,提升了计算效率;并且 capacity 为2的整数次幂的话,为偶数,这样 capacity-1 为奇数,奇数的最后一位是 1,这样便保证了 h&(capacity-1) 的最后一位可能为 0,也可能为(这取决于h的值),即与后的结果可能为偶数,也可能为奇数,这样便可以保证散列的均匀性;
- HashMap和Hashtable的区别?
答: HashMap是非同步的,多线程操作会有问题,并可以接受为null的ke和value,而Hashtable是同步的,且不接受null。另一个区别是HashMap的迭代器是fail-fast迭代器,而Hashtable的迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构,将会抛出ConcurrentModificationException,但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。
- 我们能否让HashMap同步?
答: HashMap可以通过下面的语句进行同步:
Map m = Collections.synchronizeMap(hashMap);