HashMap遍历的几种方式，以及是否可以进行遍历删除
HashMap 遍历从大的方向来说，可分为以下 4 类：
迭代器（Iterator）方式遍历；
For Each 方式遍历；
Lambda 表达式遍历（JDK 1.8+）;
Streams API 遍历（JDK 1.8+）。
但每种类型下又有不同的实现方式，因此具体的遍历方式又可以分为以下 7 种：
使用迭代器（Iterator）EntrySet 的方式进行遍历；
使用迭代器（Iterator）KeySet 的方式进行遍历；
使用 For Each EntrySet 的方式进行遍历；
使用 For Each KeySet 的方式进行遍历；
使用 Lambda 表达式的方式进行遍历；
使用 Streams API 单线程的方式进行遍历；
使用 Streams API 多线程的方式进行遍历。
接下来我们来看每种遍历方式的具体实现代码。
//1.迭代器 EntrySet
@Test
public void EntrySetTest(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry<Integer, String> entry = iterator.next();
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
}
//2.迭代器 迭代器 KeySet
@Test
public void keySetTest(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
Iterator<Integer> iterator = map.keySet().iterator();
while (iterator.hasNext()){
Integer key = iterator.next();
System.out.println(key);
System.out.println(map.get(key));
}
}
//3.ForEach EntrySet
@Test
public void forEachEntryTest(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
// 遍历
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.print(entry.getKey());
System.out.print(entry.getValue());
}
}
//4.ForEach KeySet
@Test
public void forEachKeySetTest(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
// 遍历
for (Integer key : map.keySet()) {
System.out.print(key);
System.out.print(map.get(key));
}
}
//5.Lambda
@Test
public void lambdaTest(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
//遍历
map.forEach((key,value)->{
System.out.print(key);
System.out.print(value);
});
}
//6.Streams API 单线程
@Test
public void streamsAPITest(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
map.entrySet().stream().forEach((entry)->{
System.out.println(entry.getKey());
System.out.println(entry.getValue());
});
}
//Streams API 多线程
@Test
public void parallelStreamTest() {
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
map.entrySet().parallelStream().forEachOrdered((entry) -> {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
});
}
性能测试
接下来我们使用 Oracle 官方提供的性能测试工具 JMH（Java Microbenchmark Harness，JAVA 微基准测试套件）来测试一下这 7 种循环的性能。
首先，我们先要引入 JMH 框架，在 pom.xml 文件中添加如下配置：
关于 JMH，可以参考如下：
https://blog.csdn.net/sufu1065/article/details/106515342/
<!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-core -->
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>1.23</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>1.23</version>
<scope>provided</scope>
</dependency>
第二个依赖一定要引入，否则会报如下错误：
Unable to find the resource: /META-INF/BenchmarkList
然后编写测试代码，如下所示:
package com.sun.hashmap;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.Throughput) // 测试类型：吞吐量，一共有五种类型，有兴趣可以点进源码看看，
@OutputTimeUnit(TimeUnit.MILLISECONDS)
/*
* 预热所需要配置的一些基本测试参数，可用于类或者方法上。一般前几次进行程序测试的时候都会比较慢，所以要让程序进行几轮预热，保证测试的准确性。参数如下所示：
iterations：预热的次数
time：每次预热的时间
timeUnit：时间的单位，默认秒
batchSize：批处理大小，每次操作调用几次方法
*
*
* */
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 2 轮，每次 1s
@Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS) // 测试 5 轮，每次 3s
@Fork(1) // fork 1 个线程
//Scope.Benchmark：所有测试线程共享一个实例，测试有状态实例在多线程共享下的性能
//Scope.Group：同一个线程在同一个 group 里共享实例
//Scope.Thread：默认的 State，每个测试线程分配一个实例
@State(Scope.Thread) // 每个测试线程一个实例
public class HashMapCycle {
//静态代码块，在map添加数据
static Map<Integer, String> map = new HashMap() {{
// 添加数据
for (int i = 0; i < 10; i++) {
put(i, "val:" + i);
}
}};
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
/*.include(HashMapCycle.class.getSimpleName()) // 要导入的测试类
.output("/Users/admin/Desktop/jmh-map.log") // 输出测试结果的文件
.build();*/
.include(HashMapCycle.class.getSimpleName())// 要导入的测试类
//.output("/Users/sunyafei/Desktop/java/jmh-map.log") // 输出测试结果的文件
.result("result.json")//结果可直接在控制台打印
.resultFormat(ResultFormatType.JSON)
.build();
new Runner(opt).run(); // 执行测试
}
@Benchmark
public void entrySet() {
// 遍历
Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<Integer, String> entry = iterator.next();
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
}
@Benchmark
public void keySet() {
// 遍历
Iterator<Integer> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
Integer key = iterator.next();
System.out.println(key);
System.out.println(map.get(key));
}
}
@Benchmark
public void forEachEntrySet() {
// 遍历
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
}
@Benchmark
public void forEachKeySet() {
// 遍历
for (Integer key : map.keySet()) {
System.out.println(key);
System.out.println(map.get(key));
}
}
@Benchmark
public void lambda() {
// 遍历
map.forEach((key, value) -> {
System.out.println(key);
System.out.println(value);
});
}
@Benchmark
public void streamApi() {
// 单线程遍历
map.entrySet().stream().forEach((entry) -> {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
});
}
@Benchmark
public void parallelStreamApi() {
// 多线程遍历
map.entrySet().parallelStream().forEach((entry) -> {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
});
}
}
测试结果如下：
可以得出的结论是，除了并行循环的 parallelStream 性能比极高之外（多线程方式性能肯定比较高），其他方式的遍历方法在性能方面几乎没有任何差别。
安全性能测试（遍历删除）
进行了如下四种测试：
1.迭代器 EntrySet 遍历删除元素
2.在foreach中遍历EntrySet删除元素
3.在Lambda中遍历删除
4.在stream中遍历删除
//-----------------------------------------------------------
//1.迭代器 EntrySet 遍历删除元素
@Test
public void EntrySetTestDel(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<Integer, String> entry = iterator.next();
if (entry.getKey() == 1) {
// 删除
System.out.println("del:" + entry.getKey());
iterator.remove();
} else {
System.out.println("show:" + entry.getKey());
}
}
}
//del:1
//show:2
//show:3
//show:4
//show:5
//测试结果在entrySet中遍历删除是安全的，迭代器中循环删除数据安全
//2.ForEach EntrySet
//测试在foreach中遍历删除元素
@Test
public void forEachEntryTestDel(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
// 遍历
for (Map.Entry<Integer, String> entry : map.entrySet()) {
if (entry.getKey() == 1) {
// 删除
System.out.println("del:" + entry.getKey());
map.remove(entry.getKey());
} else {
System.out.println("show:" + entry.getKey());
}
}
}
/*
* 测试结果如下
* del:1
* java.util.ConcurrentModificationException
* */
//测试结果：For 循环中删除数据非安全。
//3.测试在Lambda中遍历删除
@Test
public void lambdaTestDel(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
//遍历删除
map.forEach((key,value)->{
if (key == 1) {
// 删除
System.out.println("del:" + key);
map.remove(key);
} else {
System.out.println("show:" + key);
}
});
}
/*
* 测试结果如下：
* java.util.ConcurrentModificationException
*
*
* */
//测试结果：Lambda 循环中删除数据非安全。
//3.1.测试在Lambda中遍历删除,正确的方式
@Test
public void lambdaTestDelRight(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
//遍历删除
// 根据 map 中的 key 去判断删除
map.keySet().removeIf(key -> key == 1);
map.forEach((key, value) -> {
System.out.println("show:" + key);
});
}
/*
* 测试结果如下：
* show:2
show:3
show:4
show:5
*
*
* */
// 从上面的代码可以看出，可以先使用 Lambda 的 removeIf 删除多余的数据，再进行循环是一种正确操作集合的方式。
//4.Streams API 单线程 遍历删除
@Test
public void streamsAPITestDel(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
map.entrySet().stream().forEach((entry) -> {
if (entry.getKey() == 1) {
System.out.println("del:" + entry.getKey());
map.remove(entry.getKey());
} else {
System.out.println("show:" + entry.getKey());
}
});
//测试结果：java.util.ConcurrentModificationException
//Stream 循环中删除数据非安全。
}
//4..Streams API 单线程 遍历删除,正确写法
@Test
public void streamsAPITestDelRight(){
// 创建并赋值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社群");
map.entrySet().stream().filter(m->1 != m.getKey()).forEach((entry)->{
if (entry.getKey() == 1) {
System.out.println("del:" + entry.getKey());
} else {
System.out.println("show:" + entry.getKey());
}
});
//测试结果：show:2
//show:3
//show:4
//show:5
//Stream 循环中删除数据非安全。
//从上面的代码可以看出，可以使用 Stream 中的 filter 过滤掉无用的数据，再进行遍历也是一种安全的操作集合的方式。
}
小结
我们不能在遍历中使用集合 map.remove() 来删除数据，这是非安全的操作方式，但我们可以使用迭代器的 iterator.remove() 的方法来删除数据，这是安全的删除集合的方式。同样的我们也可以使用 Lambda 中的 removeIf 来提前删除数据，或者是使用 Stream 中的 filter 过滤掉要删除的数据进行循环，这样都是安全的，当然我们也可以在 for 循环前删除数据在遍历也是线程安全的。
总结
本文我们讲了 HashMap 4 大类（迭代器、for、lambda、stream）遍历方式，以及具体的 7 种遍历方法，除了 Stream 的并行循环，其他几种遍历方法的性能差别不大，但从简洁性和优雅性上来看，Lambda 和 Stream 无疑是最适合的遍历方式。除此之外我们还从「安全性」方面测试了 4 大类遍历结果，从安全性来讲，我们应该使用迭代器提供的 iterator.remove() 方法来进行删除，这种方式是安全的在遍历中删除集合的方式，或者使用 Stream 中的 filter 过滤掉要删除的数据再进行循环，也是安全的操作方式。
总体来说，本文提供了 7 种方式肯定也不是最全的，只是想给读者在使用 HashMap 时多一种选择，然而选择那一种形式的写法，要综合：性能、安全性、使用环境的 JDK 版本以及优雅性和可读性等方面来综合考虑。
参考：https://mp.weixin.qq.com/s/d93H9TwJKSnpkSBMYJ7QWQ
1100
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
