关于【hashmap怎么遍历】，java的hashmap怎么遍历，今天乾乾小编给您分享一下，如果对您有所帮助别忘了关注本站哦。
内容导航：1、hashmap怎么遍历：HashMap 的 7 种遍历方式与性能分析！2、hashmap怎么遍历，java的hashmap怎么遍历1、hashmap怎么遍历：HashMap 的 7 种遍历方式与性能分析！
作者：Java中文社群
随着 JDK 1.8 Streams API 的发布，使得 HashMap 拥有了更多的遍历的方式，但应该选择那种遍历方式？反而成了一个问题。
本文先从 HashMap 的遍历方法讲起，然后再从性能、原理以及安全性等方面，来分析 HashMap 各种遍历方式的优势与不足，本文主要内容如下图所示：
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
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数组的每个元素。
1. 协助扩容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的扩容机制。
2. 遍历方式跟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。
3. 计数机制为了能够记录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怎么遍历（种遍历方式与性能分析）》的所有内容，希望对您能有所帮助！更多的知识请继续关注《犇涌向乾》百科知识网站：！