HashMap的七种遍历方法以及性能、安全性分析

电玩女神 2022-12-27 01:53 174阅读 0赞

## 遍历方法： ##

import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    /*
     * @author 在下令狐
     */
    public class HashMapDemo {
        
    
    
        public static void main(String[] args) {
        
    
            Map<Integer, String> hashMap = new HashMap();
            hashMap.put(1, "Jack");
            hashMap.put(2, "Lucci");
            hashMap.put(3, "Jenny");
            hashMap.put(4, "Pony");
    
            iteratorByEntrySet(hashMap);
            iteratorByKeySet(hashMap);
            forEachByEntrySet(hashMap);
            forEachByKeySet(hashMap);
            forEachByLambda(hashMap);
            forEachByStream(hashMap);
            forEachByParallelStream(hashMap);
        }
    
        public static void iteratorByEntrySet(Map<Integer, String> hashMap) {
        
            System.out.println("iteratorByEntrySet : ");
            Iterator<Map.Entry<Integer, String>> iterator = hashMap.entrySet().iterator();
            while (iterator.hasNext()) {
        
                Map.Entry<Integer, String> entry = iterator.next();
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    
        public static void iteratorByKeySet(Map<Integer, String> hashMap) {
        
            System.out.println("iteratorByKeySet : ");
            Iterator<Integer> iterator = hashMap.keySet().iterator();
            while (iterator.hasNext()) {
        
                Integer key = iterator.next();
                System.out.println(key + " " + hashMap.get(key));
            }
        }
    
        public static void forEachByEntrySet(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByEntrySet : ");
            for (Map.Entry<Integer, String> entry : hashMap.entrySet()) {
        
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    
        public static void forEachByKeySet(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByKeySet : ");
            for (Integer key : hashMap.keySet()) {
        
                System.out.println(key + " " + hashMap.get(key));
            }
        }
    
        public static void forEachByLambda(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByLambda : ");
            hashMap.forEach((key, value) -> {
        
                System.out.println(key + " " + value);
            });
        }
    
        public static void forEachByStream(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByStream : ");
            hashMap.entrySet().stream().forEach((entry) -> {
        
                System.out.println(entry.getKey() + " " + entry.getValue());
            });
        }
    
        public static void forEachByParallelStream(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByParallelStream : ");
            hashMap.entrySet().parallelStream().forEach((entry) -> {
        
                System.out.println(entry.getKey() + " " + entry.getValue());
            });
        }
    }

## 性能分析： ##

*  需引入pom依赖

<dependency>
    		  <groupId>org.openjdk.jmh</groupId>
    		  <artifactId>jmh-generator-annprocess</artifactId>
    		  <version>1.20</version>
    	  </dependency>

import org.openjdk.jmh.annotations.*;
    import org.openjdk.jmh.runner.Runner;
    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;
    
    /*
     * Throughput: 整体吞吐量，例如“1秒内可以执行多少次调用”，单位是操作数/时间
     * AverageTime: 调用的平均时间，例如“每次调用平均耗时xxx毫秒”，单位是时间/操作数。
     * SampleTime: 随机取样，最后输出取样结果的分布，例如“99%的调用在xxx毫秒以内，99.99%的调用在xxx毫秒以内”
     * SingleShotTime: 以上模式都是默认一次 iteration 是 1s，唯有 SingleShotTime 是只运行一次。往往同时把 warmup 次数设为0，用于测试冷启动时的性能。
     */
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MILLISECONDS) // 输出的时间单位
    /*
     * Warmup 是指在实际进行 Benchmark 前先进行预热的行为。
     * 为什么需要预热？因为 JVM 的 JIT 机制的存在，如果某个函数被调用多次之后，JVM 会尝试将其编译成为机器码从而提高执行速度。
     * 为了让 Benchmark 的结果更加接近真实情况就需要进行预热。
     */
    @Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 2 轮，每次 1s
    @Measurement(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS) // 测试 10 轮，每次 3s
    /*
     * 进行 fork 的次数。如果 fork 数是2的话，则 JMH 会 fork 出两个进程来进行测试。
     */
    @Fork(1)
    /*
     * Scope.Thread：默认的 State，每个测试线程分配一个实例；
     * Scope.Benchmark：所有测试线程共享一个实例，用于测试有状态实例在多线程共享下的性能；
     * Scope.Group：每个线程组共享一个实例；
     */
    @State(Scope.Thread)
    public class HaskMapEfficiencyTest {
        
    
        static Map<Integer, String> hashMap = new HashMap() {
        {
        
            // 初始化数据
            for (int i = 0; i < 100; i++) {
        
                put(i, "value" + i);
            }
        }};
    
        public static void main(String[] args) {
        
            // 启动基准测试
            Options opt = new OptionsBuilder()
                    .include(HaskMapEfficiencyTest.class.getSimpleName()) // 要导入的测试类
                    .output("E:/JMH-HaskMapEfficiencyTest.log") // 输出测试结果的文件
                    .build();
            try {
        
                new Runner(opt).run(); // 执行测试
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    
        /*
         * 方法注解，表示该方法是需要进行 benchmark 的对象
         */
        @Benchmark
        public static void iteratorByEntrySet() {
        
            Iterator<Map.Entry<Integer, String>> iterator = hashMap.entrySet().iterator();
            while (iterator.hasNext()) {
        
                Map.Entry<Integer, String> entry = iterator.next();
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    
    
        @Benchmark
        public static void iteratorByKeySet() {
        
            Iterator<Integer> iterator = hashMap.keySet().iterator();
            while (iterator.hasNext()) {
        
                Integer key = iterator.next();
                System.out.println(key + " " + hashMap.get(key));
            }
        }
    
    
        @Benchmark
        public static void forEachByEntrySet() {
        
            for (Map.Entry<Integer, String> entry : hashMap.entrySet()) {
        
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    
    
        @Benchmark
        public static void forEachByKeySet() {
        
            for (Integer key : hashMap.keySet()) {
        
                System.out.println(key + " " + hashMap.get(key));
            }
        }
    
        @Benchmark
        public static void forEachByLambda() {
        
            hashMap.forEach((key, value) -> {
        
                System.out.println(key + " " + value);
            });
        }
    
        @Benchmark
        public static void forEachByStream() {
        
            hashMap.entrySet().stream().forEach((entry) -> {
        
                System.out.println(entry.getKey() + " " + entry.getValue());
            });
        }
    
        @Benchmark
        public static void forEachByParallelStream() {
        
            hashMap.entrySet().parallelStream().forEach((entry) -> {
        
                System.out.println(entry.getKey() + " " + entry.getValue());
            });
        }
    }

*  测试结果：

# JMH version: 1.20
    # VM version: JDK 1.8.0_131, VM 25.131-b11
    # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
    # VM options: -javaagent:D:\ideaIU\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=57820:D:\ideaIU\IntelliJ IDEA 2019.3.3\bin -Dfile.encoding=UTF-8
    # Warmup: 2 iterations, 1 s each
    # Measurement: 10 iterations, 3 s each
    # Timeout: 10 min per iteration
    # Threads: 1 thread, will synchronize iterations
    # Benchmark mode: Throughput, ops/time
    # Benchmark: com.demo.service.test.HaskMapEfficiencyTest.forEachByEntrySet
    
    # Run progress: 0.00% complete, ETA 00:03:44
    # Fork: 1 of 1
    # Warmup Iteration   1: 0.099 ops/ms
    # Warmup Iteration   2: 0.136 ops/ms
    Iteration   1: 0.134 ops/ms
    Iteration   2: 0.144 ops/ms
    Iteration   3: 0.135 ops/ms
    Iteration   4: 0.177 ops/ms
    Iteration   5: 0.110 ops/ms
    Iteration   6: 0.125 ops/ms
    Iteration   7: 0.106 ops/ms
    Iteration   8: 0.095 ops/ms
    Iteration   9: 0.094 ops/ms
    Iteration  10: 0.101 ops/ms
    
    
    Result "com.demo.service.test.HaskMapEfficiencyTest.forEachByEntrySet":
      0.122 ±(99.9%) 0.040 ops/ms [Average]
      (min, avg, max) = (0.094, 0.122, 0.177), stdev = 0.026
      CI (99.9%): [0.082, 0.162] (assumes normal distribution)
    
    
    # JMH version: 1.20
    # VM version: JDK 1.8.0_131, VM 25.131-b11
    # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
    # VM options: -javaagent:D:\ideaIU\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=57820:D:\ideaIU\IntelliJ IDEA 2019.3.3\bin -Dfile.encoding=UTF-8
    # Warmup: 2 iterations, 1 s each
    # Measurement: 10 iterations, 3 s each
    # Timeout: 10 min per iteration
    # Threads: 1 thread, will synchronize iterations
    # Benchmark mode: Throughput, ops/time
    # Benchmark: com.demo.service.test.HaskMapEfficiencyTest.forEachByKeySet
    
    # Run progress: 14.29% complete, ETA 00:03:22
    # Fork: 1 of 1
    # Warmup Iteration   1: 0.081 ops/ms
    # Warmup Iteration   2: 0.086 ops/ms
    Iteration   1: 0.099 ops/ms
    Iteration   2: 0.151 ops/ms
    Iteration   3: 0.102 ops/ms
    Iteration   4: 0.093 ops/ms
    Iteration   5: 0.169 ops/ms
    Iteration   6: 0.079 ops/ms
    Iteration   7: 0.137 ops/ms
    Iteration   8: 0.132 ops/ms
    Iteration   9: 0.123 ops/ms
    Iteration  10: 0.066 ops/ms
    
    
    Result "com.demo.service.test.HaskMapEfficiencyTest.forEachByKeySet":
      0.115 ±(99.9%) 0.049 ops/ms [Average]
      (min, avg, max) = (0.066, 0.115, 0.169), stdev = 0.033
      CI (99.9%): [0.066, 0.164] (assumes normal distribution)
    
    
    # JMH version: 1.20
    # VM version: JDK 1.8.0_131, VM 25.131-b11
    # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
    # VM options: -javaagent:D:\ideaIU\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=57820:D:\ideaIU\IntelliJ IDEA 2019.3.3\bin -Dfile.encoding=UTF-8
    # Warmup: 2 iterations, 1 s each
    # Measurement: 10 iterations, 3 s each
    # Timeout: 10 min per iteration
    # Threads: 1 thread, will synchronize iterations
    # Benchmark mode: Throughput, ops/time
    # Benchmark: com.demo.service.test.HaskMapEfficiencyTest.forEachByLambda
    
    # Run progress: 28.57% complete, ETA 00:02:49
    # Fork: 1 of 1
    # Warmup Iteration   1: 0.084 ops/ms
    # Warmup Iteration   2: 0.093 ops/ms
    Iteration   1: 0.133 ops/ms
    Iteration   2: 0.122 ops/ms
    Iteration   3: 0.097 ops/ms
    Iteration   4: 0.150 ops/ms
    Iteration   5: 0.118 ops/ms
    Iteration   6: 0.088 ops/ms
    Iteration   7: 0.111 ops/ms
    Iteration   8: 0.100 ops/ms
    Iteration   9: 0.116 ops/ms
    Iteration  10: 0.118 ops/ms
    
    
    Result "com.demo.service.test.HaskMapEfficiencyTest.forEachByLambda":
      0.115 ±(99.9%) 0.027 ops/ms [Average]
      (min, avg, max) = (0.088, 0.115, 0.150), stdev = 0.018
      CI (99.9%): [0.088, 0.142] (assumes normal distribution)
    
    
    # JMH version: 1.20
    # VM version: JDK 1.8.0_131, VM 25.131-b11
    # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
    # VM options: -javaagent:D:\ideaIU\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=57820:D:\ideaIU\IntelliJ IDEA 2019.3.3\bin -Dfile.encoding=UTF-8
    # Warmup: 2 iterations, 1 s each
    # Measurement: 10 iterations, 3 s each
    # Timeout: 10 min per iteration
    # Threads: 1 thread, will synchronize iterations
    # Benchmark mode: Throughput, ops/time
    # Benchmark: com.demo.service.test.HaskMapEfficiencyTest.forEachByParallelStream
    
    # Run progress: 42.86% complete, ETA 00:02:15
    # Fork: 1 of 1
    # Warmup Iteration   1: 0.100 ops/ms
    # Warmup Iteration   2: 0.101 ops/ms
    Iteration   1: 0.085 ops/ms
    Iteration   2: 0.105 ops/ms
    Iteration   3: 0.083 ops/ms
    Iteration   4: 0.083 ops/ms
    Iteration   5: 0.081 ops/ms
    Iteration   6: 0.081 ops/ms
    Iteration   7: 0.079 ops/ms
    Iteration   8: 0.083 ops/ms
    Iteration   9: 0.083 ops/ms
    Iteration  10: 0.081 ops/ms
    
    
    Result "com.demo.service.test.HaskMapEfficiencyTest.forEachByParallelStream":
      0.084 ±(99.9%) 0.011 ops/ms [Average]
      (min, avg, max) = (0.079, 0.084, 0.105), stdev = 0.007
      CI (99.9%): [0.073, 0.095] (assumes normal distribution)
    
    
    # JMH version: 1.20
    # VM version: JDK 1.8.0_131, VM 25.131-b11
    # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
    # VM options: -javaagent:D:\ideaIU\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=57820:D:\ideaIU\IntelliJ IDEA 2019.3.3\bin -Dfile.encoding=UTF-8
    # Warmup: 2 iterations, 1 s each
    # Measurement: 10 iterations, 3 s each
    # Timeout: 10 min per iteration
    # Threads: 1 thread, will synchronize iterations
    # Benchmark mode: Throughput, ops/time
    # Benchmark: com.demo.service.test.HaskMapEfficiencyTest.forEachByStream
    
    # Run progress: 57.14% complete, ETA 00:01:41
    # Fork: 1 of 1
    # Warmup Iteration   1: 0.078 ops/ms
    # Warmup Iteration   2: 0.088 ops/ms
    Iteration   1: 0.093 ops/ms
    Iteration   2: 0.111 ops/ms
    Iteration   3: 0.107 ops/ms
    Iteration   4: 0.100 ops/ms
    Iteration   5: 0.094 ops/ms
    Iteration   6: 0.095 ops/ms
    Iteration   7: 0.092 ops/ms
    Iteration   8: 0.133 ops/ms
    Iteration   9: 0.094 ops/ms
    Iteration  10: 0.098 ops/ms
    
    
    Result "com.demo.service.test.HaskMapEfficiencyTest.forEachByStream":
      0.102 ±(99.9%) 0.019 ops/ms [Average]
      (min, avg, max) = (0.092, 0.102, 0.133), stdev = 0.013
      CI (99.9%): [0.082, 0.121] (assumes normal distribution)
    
    
    # JMH version: 1.20
    # VM version: JDK 1.8.0_131, VM 25.131-b11
    # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
    # VM options: -javaagent:D:\ideaIU\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=57820:D:\ideaIU\IntelliJ IDEA 2019.3.3\bin -Dfile.encoding=UTF-8
    # Warmup: 2 iterations, 1 s each
    # Measurement: 10 iterations, 3 s each
    # Timeout: 10 min per iteration
    # Threads: 1 thread, will synchronize iterations
    # Benchmark mode: Throughput, ops/time
    # Benchmark: com.demo.service.test.HaskMapEfficiencyTest.iteratorByEntrySet
    
    # Run progress: 71.43% complete, ETA 00:01:07
    # Fork: 1 of 1
    # Warmup Iteration   1: 0.079 ops/ms
    # Warmup Iteration   2: 0.081 ops/ms
    Iteration   1: 0.118 ops/ms
    Iteration   2: 0.127 ops/ms
    Iteration   3: 0.084 ops/ms
    Iteration   4: 0.109 ops/ms
    Iteration   5: 0.084 ops/ms
    Iteration   6: 0.104 ops/ms
    Iteration   7: 0.108 ops/ms
    Iteration   8: 0.105 ops/ms
    Iteration   9: 0.094 ops/ms
    Iteration  10: 0.101 ops/ms
    
    
    Result "com.demo.service.test.HaskMapEfficiencyTest.iteratorByEntrySet":
      0.103 ±(99.9%) 0.021 ops/ms [Average]
      (min, avg, max) = (0.084, 0.103, 0.127), stdev = 0.014
      CI (99.9%): [0.083, 0.124] (assumes normal distribution)
    
    
    # JMH version: 1.20
    # VM version: JDK 1.8.0_131, VM 25.131-b11
    # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
    # VM options: -javaagent:D:\ideaIU\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=57820:D:\ideaIU\IntelliJ IDEA 2019.3.3\bin -Dfile.encoding=UTF-8
    # Warmup: 2 iterations, 1 s each
    # Measurement: 10 iterations, 3 s each
    # Timeout: 10 min per iteration
    # Threads: 1 thread, will synchronize iterations
    # Benchmark mode: Throughput, ops/time
    # Benchmark: com.demo.service.test.HaskMapEfficiencyTest.iteratorByKeySet
    
    # Run progress: 85.71% complete, ETA 00:00:33
    # Fork: 1 of 1
    # Warmup Iteration   1: 0.083 ops/ms
    # Warmup Iteration   2: 0.089 ops/ms
    Iteration   1: 0.096 ops/ms
    Iteration   2: 0.102 ops/ms
    Iteration   3: 0.131 ops/ms
    Iteration   4: 0.135 ops/ms
    Iteration   5: 0.117 ops/ms
    Iteration   6: 0.091 ops/ms
    Iteration   7: 0.093 ops/ms
    Iteration   8: 0.099 ops/ms
    Iteration   9: 0.110 ops/ms
    Iteration  10: 0.141 ops/ms
    
    
    Result "com.demo.service.test.HaskMapEfficiencyTest.iteratorByKeySet":
      0.112 ±(99.9%) 0.028 ops/ms [Average]
      (min, avg, max) = (0.091, 0.112, 0.141), stdev = 0.018
      CI (99.9%): [0.084, 0.139] (assumes normal distribution)
    
    
    # Run complete. Total time: 00:03:56
    
    Benchmark                                       Mode  Cnt  Score   Error   Units
    HaskMapEfficiencyTest.forEachByEntrySet        thrpt   10  0.122 ± 0.040  ops/ms
    HaskMapEfficiencyTest.forEachByKeySet          thrpt   10  0.115 ± 0.049  ops/ms
    HaskMapEfficiencyTest.forEachByLambda          thrpt   10  0.115 ± 0.027  ops/ms
    HaskMapEfficiencyTest.forEachByParallelStream  thrpt   10  0.084 ± 0.011  ops/ms
    HaskMapEfficiencyTest.forEachByStream          thrpt   10  0.102 ± 0.019  ops/ms
    HaskMapEfficiencyTest.iteratorByEntrySet       thrpt   10  0.103 ± 0.021  ops/ms
    HaskMapEfficiencyTest.iteratorByKeySet         thrpt   10  0.112 ± 0.028  ops/ms

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmczNTM5MzM1NDY_size_16_color_FFFFFF_t_70_pic_center]

## 安全性分析： ##

import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    public class HaskMapSecurityTest {
        
    
        public static void main(String[] args) {
        
    
            Map<Integer, String> hashMap = new HashMap();
            hashMap.put(1, "Jack");
            hashMap.put(2, "Lucci");
            hashMap.put(3, "Jenny");
            hashMap.put(4, "Pony");
    
            //iteratorByEntrySet(hashMap);
            //forEachByEntrySet(hashMap);
            //forEachByLambda(hashMap);
            forEachByStream(hashMap);
        }
    
        /*
         * 迭代器中循环删除数据安全
         */
        public static void iteratorByEntrySet(Map<Integer, String> hashMap) {
        
            System.out.println("iteratorByEntrySet : ");
            Iterator<Map.Entry<Integer, String>> iterator = hashMap.entrySet().iterator();
            while (iterator.hasNext()) {
        
                Map.Entry<Integer, String> entry = iterator.next();
                if (entry.getKey() == 1) {
        
                    System.out.println("已删除Key:" + entry.getKey());
                    iterator.remove();
                } else {
        
                    System.out.println("未删除Key:" + entry.getKey());
                }
            }
        }
    
        /*
         * For 循环中删除数据非安全
         */
        public static void forEachByEntrySet(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByEntrySet : ");
            for (Map.Entry<Integer, String> entry : hashMap.entrySet()) {
        
                if (entry.getKey() == 1) {
        
                    System.out.println("已删除Key:" + entry.getKey());
                    hashMap.remove(entry.getKey());
                } else {
        
                    System.out.println("未删除Key:" + entry.getKey());
                }
            }
        }
    
        /*
         * Lambda 中删除数据
         */
        public static void forEachByLambda(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByLambda : ");
            hashMap.keySet().removeIf(key -> key == 1);
            hashMap.forEach((key, value) -> {
        
                System.out.println("未删除Key:" + key);
            });
        }
    
        /*
         * Stream 中删除数据
         */
        public static void forEachByStream(Map<Integer, String> hashMap) {
        
            System.out.println("forEachByStream : ");
            hashMap.entrySet().stream().filter(m -> 1 != m.getKey()).forEach((entry) -> {
        
                if (entry.getKey() == 1) {
        
                    System.out.println("已删除Key:" + entry.getKey());
                } else {
        
                    System.out.println("未删除Key:" + entry.getKey());
                }
            });
        }
    }

*  迭代器中循环删除数据安全

iteratorByEntrySet : 
    已删除Key:1
    未删除Key:2
    未删除Key:3
    未删除Key:4

*  For 循环中删除数据非安全

forEachByEntrySet : 
    已删除Key:1
    Exception in thread "main" java.util.ConcurrentModificationException
    	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437)
    	at java.util.HashMap$EntryIterator.next(HashMap.java:1471)
    	at java.util.HashMap$EntryIterator.next(HashMap.java:1469)
    	at com.demo.service.test.HaskMapSecurityTest.forEachByEntrySet(HaskMapSecurityTest.java:45)
    	at com.demo.service.test.HaskMapSecurityTest.main(HaskMapSecurityTest.java:18)

*  Lambda 中正确删除数据方式

forEachByLambda : 
    未删除Key:2
    未删除Key:3
    未删除Key:4

*  Stream 中正确删除数据方式

forEachByStream : 
    未删除Key:2
    未删除Key:3
    未删除Key:4

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmczNTM5MzM1NDY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/3e07fc1e2dcf42b588a3f47775e3532e.png