HashMap 的 7 种遍历方式与性能分析

已于 2023-05-11 10:42:19 修改
阅读量767 收藏 2
点赞数
文章标签： java
于 2023-05-11 10:34:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ally441/article/details/130616285
版权

随着 JDK 1.8 Streams API 的发布，使得 HashMap 拥有了更多的遍历的方式，但应该选择那种遍历方式？反而成了一个问题。

本文先从 HashMap 的遍历方法讲起，然后再从性能、原理以及安全性等方面，来分析 HashMap 各种遍历方式的优势与不足，本文主要内容如下图所示：

HashMap遍历

HashMap遍历从大的方向来说，可分为以下4类：

  1. 迭代器（Iterator）方式遍历；

  2. For Each方式遍历；

  3. Lambda表达式遍历（JDK1.8+)

  4. Streams API遍历（JDK1.8+)

但每种类型下又有不同的实现方式，因此具体的遍历方式又可以分为以下 7 种：

  1. 使用迭代器(Iterator)EntrySet的方式进行遍历；

  2. 使用迭代器（Iterator)KeySet的方式进行遍历；

  3. 使用 For Each EntrySet 的方式进行遍历；

  4. 使用 For Each KeySet 的方式进行遍历；

  5. 使用 Lambda 表达式的方式进行遍历；

  6. 使用 Streams API 单线程的方式进行遍历；

  7. 使用 Streams API 多线程的方式进行遍历。

迭代器EntrySet

public class HashMapTest{
    public static void main(String[] args){
        // 创建并赋值 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());
        }
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

迭代器 KeySet

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 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));
        }
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

ForEach EntrySet

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 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.EntrySet<Integer,String> entry: map.entrySet()){
            System.out.print(entry.getKey());
            System.out.print(entry.getValue());
        }
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

ForEach KeySet

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 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));
        }
   }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

Lambda

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 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);
        });
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

Streams API 单线程

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 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);
        });
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

Streams API多线程

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 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);
        });
    }
}

以上程序的执行结果为：4 MyBatis framework 5 Java中文社群 1 Java 2 JDK 3 Spring Framework

性能测试

接下来我们使用Oracle官方提供的性能测试工具JMH(Java Microbenchmark Harness, JAVA 微基准测试套件)来测试一下这 7 种循环的性能。

首先，我们先要引入JMH框架，在pom.xml文件中添加如下配置：

<!--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>

然后编写测试代码，如下所示：

package com.example.hashmaptest;
​
import org.openjdk.jmh.annotations.*;
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;
​
/**
 * @author allycoding
 * @Date: 2022/8/8 21:37
 */
@BenchmarkMode(Mode.Throughput)//测试类型：吞吐量
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) //预热 2 轮，每次 1s
@Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS) //测试5轮，每次3s
@Fork(1) //fork 1个线程
@State(Scope.Thread) //每个测试线程一个实例
public class HashMapCycle {
​
    static Map<Integer, String> map = new HashMap(){
        {
            // 添加数据
            for(int i=0;i<10;i++){
                this.put(i,"val:"+i);
            }
        }
    };
​
    public static void main(String[] args) throws RunnerException {
        //启动基准测试
        Options opt = new OptionsBuilder()
                .include(HashMapCycle.class.getSimpleName()) //要导入的测试类
                .output("./jmh-map.log") //输出测试结果的文件
                .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());
        });
    }
​
}

所有被添加了 @Benchmark 注解的方法都会被测试，测试结果如下：

其中 Score 列表示平均执行时间， ± 符号表示误差。从以上结果可以看出，如果加上后面的误差值的话，可以得出的结论是，除了并行循环的 parallelStream 性能比极高之外（多线程方式性能肯定比较高），其他方式的遍历方法在性能方面几乎没有任何差别。

性能原理分析

要理解性能测试的结果，我们需要把所有遍历代码通过 javac，编译成字节码来看具体的原因，编译之后我们使用 Idea 打开字节码信息，内容如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
​
package com.example;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
​
public class HashMapTest {
    static Map<Integer, String> map = new HashMap() {
        {
            for(int var1 = 0; var1 < 2; ++var1) {
                this.put(var1, "val:" + var1);
            }
​
        }
    };
​
    public HashMapTest() {
    }
​
    public static void main(String[] var0) {
        entrySet();
        keySet();
        forEachEntrySet();
        forEachKeySet();
        lambda();
        streamApi();
        parallelStreamApi();
    }
​
    public static void entrySet() {
        Iterator var0 = map.entrySet().iterator();
​
        while(var0.hasNext()) {
            Entry var1 = (Entry)var0.next();
            System.out.println(var1.getKey());
            System.out.println((String)var1.getValue());
        }
​
    }
​
    public static void keySet() {
        Iterator var0 = map.keySet().iterator();
​
        while(var0.hasNext()) {
            Integer var1 = (Integer)var0.next();
            System.out.println(var1);
            System.out.println((String)map.get(var1));
        }
​
    }
​
    public static void forEachEntrySet() {
        Iterator var0 = map.entrySet().iterator();
​
        while(var0.hasNext()) {
            Entry var1 = (Entry)var0.next();
            System.out.println(var1.getKey());
            System.out.println((String)var1.getValue());
        }
​
    }
​
    public static void forEachKeySet() {
        Iterator var0 = map.keySet().iterator();
​
        while(var0.hasNext()) {
            Integer var1 = (Integer)var0.next();
            System.out.println(var1);
            System.out.println((String)map.get(var1));
        }
​
    }
​
    public static void lambda() {
        map.forEach((var0, var1) -> {
            System.out.println(var0);
            System.out.println(var1);
        });
    }
​
    public static void streamApi() {
        map.entrySet().stream().forEach((var0) -> {
            System.out.println(var0.getKey());
            System.out.println((String)var0.getValue());
        });
    }
​
    public static void parallelStreamApi() {
        map.entrySet().parallelStream().forEach((var0) -> {
            System.out.println(var0.getKey());
            System.out.println((String)var0.getValue());
        });
    }
}

从结果可以看出，除了 Lambda 和 Streams API 之外，通过迭代器循环和 for 循环的遍历的 EntrySet 最终生成的代码是一样的，他们都是在循环中创建了一个遍历对象 Entry ，如下所示：

public static void entrySet() {
    Iterator var0 = map.entrySet().iterator();
    while(var0.hasNext()) {
        Entry var1 = (Entry)var0.next();
        System.out.println(var1.getKey());
        System.out.println((String)var1.getValue());
    }
}
public static void forEachEntrySet() {
    Iterator var0 = map.entrySet().iterator();
    while(var0.hasNext()) {
        Entry var1 = (Entry)var0.next();
        System.out.println(var1.getKey());
        System.out.println((String)var1.getValue());
    }
}

而通过迭代器和 for 循环遍历的 KeySet 代码也是一样的，如下所示：

public static void keySet() {
    Iterator var0 = map.keySet().iterator();
    while(var0.hasNext()) {
        Integer var1 = (Integer)var0.next();
        System.out.println(var1);
        System.out.println((String)map.get(var1));
    }
} 
public static void forEachKeySet() {
    Iterator var0 = map.keySet().iterator();
    while(var0.hasNext()) {
        Integer var1 = (Integer)var0.next();
        System.out.println(var1);
        System.out.println((String)map.get(var1));
    }
}

可以看出 KeySet 在循环中创建了一个 Integer 的局部变量，并且值是从 map 对象中直接获取的。

所以通过字节码来看，使用 EntrySet 和 KeySet 代码差别不是很大，并不像网上说的那样 KeySet 的性能远不如 EntrySet，因此从性能的角度来说 EntrySet 和 KeySet 几乎是相近的，但从代码的优雅型和可读性来说，还是推荐使用 EntrySet。

安全性测试

从上面的性能测试结果和原理分析，我想大家应该选用那种遍历方式，已经心中有数的，而接下来我们就从「安全」的角度入手，来分析那种遍历方式更安全。

我们把以上遍历划分为四类进行测试：迭代器方式、For 循环方式、Lambda 方式和 Stream 方式，测试代码如下。

迭代器方式

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());
    }
}

以上程序的执行结果：

show:0

del:1

show:2

测试结果：迭代器中循环删除数据安全。

For循环方式

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());
  }
}

Lambda方式

map.forEach((key, value) -> {
    if (key == 1) {
        System.out.println("del:" + key);
        map.remove(key);
    } else {
        System.out.println("show:" + key);
    }
});

Lambda删除的正确方式：

map.forEach((key, value) -> {
    if (key == 1) {
        System.out.println("del:" + key);
        map.remove(key);
    } else {
        System.out.println("show:" + key);
    }
});

以上程序的执行结果：

show:0

show:2

从上面的代码可以看出，可以先使用 Lambda 的 removeIf 删除多余的数据，再进行循环是一种正确操作集合的方式。

Stream 方式

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());
    }
});

Stream循环的正确方式：

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:0

show:2

从上面的代码可以看出，可以使用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 版本以及优雅性和可读性等方面来综合考虑。

Ally441
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java HashMap三种循环遍历方式及其性能对比实例分析
08-25
Java HashMap三种循环遍历方式及其性能对比实例分析 Java HashMap是一种常用的数据结构，在Java编程中经常被使用。HashMap提供了三种循环遍历方式，即for each map.entrySet()、显示调用map.entrySet()的集合迭代器...
hashmap_use_in_JDK7.zip
04-20
7. **迭代器遍历**：HashMap的迭代器（`Iterator`）是弱一致性的，这意味着在遍历过程中，如果其他线程修改了HashMap（除了通过迭代器自身的`remove()`方法），则可能会看到不一致的结果。但不会抛出`...
C#中遍历hash表的四种方法
菜鸟的自我修养
05-28 3002
using System; using System.Collections; namespace HashtableExample { class Program { static Hashtable hashtable = new Hashtable(); static void Main(string[] args) { hashtable.Add("first","Beijing"); hashtable.Add("second","Sh.
HashMap的遍历方式大全
qq_35160479的博客
07-15 389
HashMap的遍历方式大全
Map集合 Stream流 File类
最新发布
Xiakeyi的博客
04-11 869
比如有如下案例：往HashMap集合中存储Student对象作为键，学生的家庭住址当做值。要求，当学生对象的姓名和年龄相同时就认为键重复。
hashmap用stream流操作_使用Java 8 Streams中的Stream的Hashmap来收集Map的价值
weixin_33508642的博客
01-14 243
你也可以这样public Map> getpartitionMap(List studentsList) {List> allPredicates = getAllPredicates();Predicate compositePredicate = allPredicates.stream().reduce(w -> true, Predicate::and)Map> ...
java Map 读写性能测试
阿昊的博客
04-02 966
探究同步情况下 Hashtable ，HashMap，ConcurrentHashMap 的读写效率
Java8 Map中新增的方法使用总结
weixin_34353714的博客
12-10 302
2019独角兽企业重金招聘Python工程师标准>>> ...
Java集合系列之HashMap源码分析
08-27
Java集合系列之HashMap源码分析 Java集合系列之HashMap源码分析是Java集合系列中的一篇非常重要的文章，它详细介绍了Java集合系列之HashMap源码，具有很高的参考价值。下面我们将对HashMap源码进行详细的分析。 ...
面试必考之HashMap源码分析与实现
03-01
面试中，HashMap的源码分析与实现是一个常见的考察点，因为它涉及到数据结构、并发处理和性能优化等多个核心领域。本篇文章将深入探讨HashMap的内部工作原理、关键特性以及其在实际应用中的考量因素。 HashMap基于...
Java HashMap实现原理分析（一）
09-07
Java HashMap是Java编程中常用的集合类之一，它提供了一种高效的方式来存储和检索键值对数据。HashMap的实现原理基于哈希表，它的核心是通过哈希函数将键（key）映射到一个数组的特定位置，从而实现快速访问。本文将...
Map遍历四种方式及其效率
weixin_42329561的博客
09-15 4587
Map遍历
Leetcode刷题知——哈希表可以遍历
物联黄同学的博客
01-30 1619
Leetcode刷题知——哈希表可以遍历 今天的每日一题很简单，但是通过这道题，我了解到在我此前不知道的知识点： 哈希表是可以遍历的！ 题目链接884. 两句话中的不常见单词 - 力扣（LeetCode） (leetcode-cn.com) 我的leetcode题解：遍历哈希表 - 两句话中的不常见单词 - 力扣（LeetCode） (leetcode-cn.com) 题目分析 题目要我们找到只出现过一次的单词！ 注意这个一次，包括了同一个字符串中 思路——哈希表 我们遍历字符串，如果遇到空格或者结尾，
HashMap遍历的四种方法
热门推荐
John的博客
01-22 11万+
方法1：使用For-Each迭代entries 这是最常见的方法，并在大多数情况下更可取的。当你在循环中需要使用Map的键和值时，就可以使用这个方法 Map map = new HashMap(); for(Map.Entry entry : map.entrySet()){ System.out.println("key = " + entry.getKey() + ", valu
ConcurrentHashMap 源码分析08函数篇之 forEach、 search详解
weixin_44245828的博客
12-09 2103
1. forEach(BiConsumer<? super K, ? super V> action) 使用 Traverser 类的 advance 方法获取下一元素，遍历直至获取到 null public void forEach(BiConsumer<? super K, ? super V> action) { if(action == null) throw new NullPointerException(); Node<K,V>[] t;
Lambda表达式对HashMap按值排序
aigezi_cdd的博客
10-12 1240
使用Lambda表达式对HashMap按value对象的时间属性进行降序排序 HashMap<Integer, User> userMap = new HashMap<>(); userMap.put(1,new User("张三",8,new Date().getTime())); userMap.put(2,new User("李四",10,new Date().getTime())); userMap.put(3,new User("王五",20,new Date().g
HashMap遍历方法，最新！！最全！！
qq_39163982的博客
06-23 281
HashMap遍历，最新！！最全！！
java 8 new hashmap_Java 8 lambda添加到Hashmap中的Hashmap中的列表中
weixin_33068055的博客
02-24 744
我有一个List< POJO>我想从中提取数据,我感兴趣的变量是：>环境：字符串>应用：字符串>吞吐量：双倍有7个Environment对象,每个Environment有18个Application对象,每个对象都有多个值.我正在尝试迭代List< POJO>并将这些值存储在Hashmap< Environment.ToString,Hashmap&...
map遍历的几种方式和效率问题
zajiayouzai的博客
07-05 2万+
一、map遍历的效率 先创建一个map，添加好数据： Map&lt;String, String&gt; map = new HashMap&lt;&gt;(); for (int i = 0; i &lt; 1000000; i++) { map.put(i + "", i + "AA"); } 1、keySet的for循环方式： //只获取key public static v...
性能优化手册-202004版1
08-03
1. 安全性：当你在调其他法时，如调些系统级操作指令之前，可能会有系列校验，如果是可 2. 性能：String 不可变之后就保证的 hash 值的唯性，这样它就

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值