关于【hashmap怎么遍历】，java的hashmap怎么遍历，今天乾乾小编给您分享一下，如果对您有所帮助别忘了关注本站哦。

1、hashmap怎么遍历：HashMap 的 7 种遍历方式与性能分析！

作者：Java中文社群

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

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

HashMap 遍历

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

1. 迭代器（Iterator）方式遍历；
2. For Each 方式遍历；
3. Lambda 表达式遍历（JDK 1.8+）;
4. Streams API 遍历（JDK 1.8+）。

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

1. 使用迭代器（Iterator）EntrySet 的方式进行遍历；
2. 使用迭代器（Iterator）KeySet 的方式进行遍历；
3. 使用 For Each EntrySet 的方式进行遍历；
4. 使用 For Each KeySet 的方式进行遍历；
5. 使用 Lambda 表达式的方式进行遍历；
6. 使用 Streams API 单线程的方式进行遍历；
7. 使用 Streams API 多线程的方式进行遍历。

接下来我们来看每种遍历方式的具体实现代码。

1.迭代器 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中文社群

2.迭代器 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中文社群

3.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.Entry<Integer, String> entry : map.entrySet()) { System.out.println(entry.getKey()); System.out.println(entry.getValue()); } }}

以上程序的执行结果为：

1

Java

2

JDK

3

Spring Framework

4

MyBatis framework

5

Java中文社群

4.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.println(key); System.out.println(map.get(key)); } }}

以上程序的执行结果为：

1

Java

2

JDK

3

Spring Framework

4

MyBatis framework

5

Java中文社群

5.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.println(key); System.out.println(value); }); }}

以上程序的执行结果为：

1

Java

2

JDK

3

Spring Framework

4

MyBatis framework

5

Java中文社群

6.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.entrySet().stream().forEach((entry) -> { System.out.println(entry.getKey()); System.out.println(entry.getValue()); }); }}

以上程序的执行结果为：

1

Java

2

JDK

3

Spring Framework

4

MyBatis framework

5

Java中文社群

7.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.entrySet().parallelStream().forEach((entry) -> { System.out.println(entry.getKey()); System.out.println(entry.getValue()); }); }}

以上程序的执行结果为：

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><!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-generator-annprocess --><dependency> <groupId>org.openjdk.jmh</groupId> <artifactId>jmh-generator-annprocess</artifactId> <version>1.23</version> <scope>provided</scope></dependency>

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

@BenchmarkMode(Mode.AverageTime) // 测试完成时间@OutputTimeUnit(TimeUnit.NANOSECONDS)@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 2 轮，每次 1s@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 测试 5 轮，每次 3s@Fork(1) // fork 1 个线程@State(Scope.Thread) // 每个测试线程一个实例public class HashMapCycleTest { static Map<Integer, String> map = new HashMap() {{ // 添加数据 for (int i = 0; i < 100; 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(); 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(); Integer k = entry.getKey(); String v = entry.getValue(); } } @Benchmark public void forEachEntrySet() { // 遍历 for (Map.Entry<Integer, String> entry : map.entrySet()) { Integer k = entry.getKey(); String v = entry.getValue(); } } @Benchmark public void keySet() { // 遍历 Iterator<Integer> iterator = map.keySet().iterator(); while (iterator.hasNext()) { Integer k = iterator.next(); String v = map.get(k); } } @Benchmark public void forEachKeySet() { // 遍历 for (Integer key : map.keySet()) { Integer k = key; String v = map.get(k); } } @Benchmark public void lambda() { // 遍历 map.forEach((key, value) -> { Integer k = key; String v = map.get(k); }); } @Benchmark public void streamApi() { // 单线程遍历 map.entrySet().stream().forEach((entry) -> { Integer k = entry.getKey(); String v = entry.getValue(); }); } public void parallelStreamApi() { // 多线程遍历 map.entrySet().parallelStream().forEach((entry) -> { Integer k = entry.getKey(); String v = entry.getValue(); }); }}

所有被添加了 @Benchmark 注解的方法都会被测试，因为 parallelStream 为多线程版本性能一定是最好的，所以就不参与测试了，其他 6 个方法的测试结果如下：

其中 Score 列表示平均执行时间， ± 符号表示误差。从以上结果可以看出，两个 entrySet 的性能相近，并且执行速度最快，接下来是 stream ，然后是两个 keySet，性能最差的是 lambda 表达式。

注：以上结果基于测试环境：JDK 1.8 / Mac mini (2018) / Idea 2020.1

小结

因此我们应该尽量使用迭代器或 for 循环的 entrySet 遍历，或者是 stream 的方式。

性能原理分析

要理解性能测试的结果，我们需要把所有遍历代码通过 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 对象中直接获取的。

所以通过上面测试结果可以看出，无论是通过迭代器方式还是 for 循环方式，最终的测试结果 EntrySet 的两个方法的性能都是相似的，而 KeySet 也是同理。

安全性测试

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

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

1.迭代器方式

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

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

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

以上程序的执行结果：

测试结果：For 循环中删除数据非安全。

3.Lambda 方式

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

以上程序的执行结果：

测试结果：Lambda 循环中删除数据非安全。

Lambda 删除的正确方式：

// 根据 map 中的 key 去判断删除map.keySet().removeIf(key -> key == 1);map.forEach((key, value) -> { System.out.println("show:" + key);});

以上程序的执行结果：

show:0

show:2

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

4.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 循环中删除数据非安全。

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 种遍历方法，综合性能和安全性来看，我们应该尽量使用迭代器 entrySet 的遍历方式，或者是 stream filter 的方式来遍历 HashMap。

来源：掘金 链接：https://juejin.im/post/5ea91e67e51d454dc87f1add

2、hashmap怎么遍历，java的hashmap怎么遍历

Java高级程序员必备的ConcurrentHashMap深度实现原理：扩容、遍历与计数

作者：吴潇

职位：Java高级工程师

原创声明

这是本人署名原创文章，未经许可不支持转载且请勿抄袭。本公众号的所有文章均原创。为了容易理解和记忆，文章以图解为主、代码为辅。如果您感兴趣，欢迎关注！

ConcurrentHashMap是大多数Java程序员经常使用的集合类，它的实现原理经常出现在很多Java技术面试中，在工作中也时而用到，有必要掌握。在之前的一篇公众号文章中，我们分析了ConcurrentHashMap部分实现原理，涉及到内部数据结构、get操作和put操作这3个方面。基本上，掌握这3点基本可以应付大多数面试和工作需求了。如果你对ConcurrentHashMap的实现原理还有浓厚兴趣，想要进一步了解的话，本文适合你阅读。

在这篇文章中，我们将分析ConcurrentHashMap的以下性能优化措施：

1. 协助搬运（针对resize的优化）

2. 如何遍历

3. 计数器

约定：后文中table指的是ConcurrentHashMap最外层数组，bin指table数组的每个元素。

ConcurrentHashMap中最耗时的操作莫过于扩容（resize），所以对扩容操作进行优化能在很大程度上提高性能，而这个优化手段就是让并发执行put操作的线程协助搬运bin中的Node，把数据项从老数组转移到新数组，从而加速resize操作。具体方案是：在执行put操作的线程中，第一个发现需要扩容的线程负责分配新数组、开始转移部分Node，每次处理一个bin；此后，其他发现有resize正在进行中的线程参与到转移Node工作；其他也在执行put操作但不参与转移工作的线程继续执行原来的put操作（先在原数组中找到bin，如果遇到FowardingNode，则在新数组中插入）；执行get操作的线程不参与转移工作，遇到FordwardingNode则到新数组查询。

这种方式相对于JDK 1.7 ConcurrentHashMap的Segment机制有很大性能提升（在JDK1.7的ConcurrentHashMap中，put遇到扩容，只会阻塞等待，直到扩容完成再继续），因为其他并发访问的线程分摊了部分扩容工作。

具体怎么转移：参与转移的线程通过transferIndex字段声明自己要转移哪些bin。同时，为了防止这些线程所转移的bin有重叠的，转移线程会在sizeCtl变量中保存一个stamp提供区分的作用。为了不影响正在对ConcurrentHashMap进行遍历操作的线程，转移工作从最后一个bin开始（table.length -1），逐步往前处理，直到处理完第1个。每转移完成一个bin或正在转移当前bin，这里的位置就被放入一个FordwardingNode。因为转移Node操作需要较长时间，FordwardingNode让其他执行put/get/遍历操作的线程可以继续访问。

ConcurrentHashMap的扩容操作需多个put线程密切配合，且需考虑遍历线程、get线程、及其他不参与搬运的put的线程执行，其中还涉及到sizectl和transferIndex等控制变量的取值和判断，机制比较复杂将在下一篇文章中分析，如果感兴趣请关注本公众号以及时了解ConcurrentHashMap的扩容机制。

跟HashMap一样，ConcurrentHashMap也支持遍历操作，主要实现位于Traverser类（这个类也是ConcurrentHashMap内部所有iterator的基类）。因为ConcurrentHashMap默认不提供全表加锁特性，所以在遍历过程中，如果有新key value被存入，并且这个新key value存入的是已经访问过的bin，那么这个新key value不会被访问到。这是符合ConcurrentHashMap设计目标的，不是bug。

假如没有扩容操作，那么遍历操作非常简单，即直接从第1个bin开始，访问其中的Node，直到访问完最后一个bin，如下图所示。

在此基础上，为了与扩容操作并发执行，遍历操作这样执行：

1） 依然是从前往后逐个访问每个bin，

2） 如果遇到FordwardingNode，则把当前table引用、当前bin的访问位置和当前table总长度保存到table stack中，然后跳转到FordwardingNode所指向的新table，

3） 当前的索引index保持不变，在新table中按这个index访问（因为map每次扩容都是大小扩展为原来的2倍，每个Node在新table中的索引要么保持不变要么后移），

4） 访问完新table中的index位置的bin之后，再访问index baseSize这个位置上的bin (baseSize是老table的总长度)；

5） 从table stack还原出之前的table引用、index访问位置和table总长度，继续向后遍历。

这样就可以在有扩容操作也在进行的条件下，同时支持遍历操作，且保证每个Node只被访问一次。因为Node在老table和新table之间有固定对应关系，用这个条件保证。

没错，原来位于同一个bin的节点，在扩容以后只可能位于2个bin中，你可以尝试几个hash值测试一下（ps. 这或许是一道很有挑战性的考试题）。

另外，还需要注意：

1） ConcurrentHashMap迭代器不支持并发访问，如果不小心让多个线程并发访问从ConcurrentHashMap创建的同一个iterator，那么遍历提前结束，导致不能访问到所有元素。

2）如果你查看ConcurrentHashMap的源码，有一处很恶心的错误（耗费了我很多时间才把它揪出来）。首先，Traverser类的构造函数如下：

注意这3个参数。然后是Traverser的子类：

到目前为止还没什么问题，但是再往下继承，问题来了：

看出问题了吗？子类中的index和size跟父类的index和size彻底交换了。不知道这是不是JDK的一个恶作剧还是一个bug。找来JDK 10的源码查看，发现这里的bug已经被修复了。虽然大家一直在使用JDK，但是它的确是包含bug的，而分析它的代码不仅能帮助你更好的使用，也可以避免踩到bug。

为了能够记录ConcurrentHashMap中的key-value个数，ConcurrentHashMap在它的内部实现了一个类似于LongAdder的高性能计数器（不了解LongAdder的同学，请阅读此文），但略有不同，比直接使用AtomicLong来进行计数的性能高出很多。与AtomicLong的不同点是，ConcurrentHashMap计数机制可以间接感知到线程竞争性，尽量减少CounterCell创建。

这里再简单说明一下LongAdder是如何相对于AtomicLong提高性能的，如下图所示。

上图已基本说明LongAdder提高性能的核心思想了，即把对一个原子变量的写入拆分到多个原子变量，这样就用空间换取了时间性能。更进一步，上图中只把一个AtomicLong替换成了3个AtomicLong。这个拆分个数是固定的，当并发访问的负载进一步提高，又会有性能瓶颈。因此，JDK 为了把LongAdder的未来改进空间全部榨干，引入了在这几年很火的"弹性扩展"思想，让拆分数量根据CPU核数和并发负载动态扩展，如下图所示。

这样JDK并发包中的一个不起眼的计数器也具备了强大的扩展性能，所以LongAdder的实现原理也是非常值得学习的，建议看完本文去研究一下。

本文关键词：hashmap的遍历方式都有哪些?，hashmap遍历foreach，hashmap遍历并删除元素，遍历hashmap的三种方式，hashmap的遍历方法。这就是关于《hashmap怎么遍历，java的hashmap怎么遍历（种遍历方式与性能分析）》的所有内容，希望对您能有所帮助！更多的知识请继续关注《犇涌向乾》百科知识网站：http://www.029ztxx.com！