HashMap 的好几种遍历方式

心已赠人 2024-03-23 13:16 51阅读 0赞

不多bb，直接上代码

import com.google.common.base.Stopwatch;
    import org.junit.Test;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.concurrent.TimeUnit;
    import java.util.function.Consumer;
    import java.util.function.Function;
    import java.util.function.Predicate;
    import java.util.function.Supplier;
    
    /**
     * HashMap 的好几种遍历方式
     * @author Administrator
     */
    public class HashMapTraversal {
        
    
        /**
         * 优点：使用迭代器遍历entrySet()可以遍历所有的键值对，遍历过程中可以使用迭代器的remove()方法删除元素，不会导致并发修改异常。
         * 同时遍历过程中也不会影响HashMap的结构。
         * 
         * 缺点：使用迭代器遍历entrySet()需要手动创建迭代器，并且遍历过程需要显式地判断迭代器是否有下一个元素，代码较为繁琐。
         */
        @Test
        public void testIterator() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // 迭代器遍历entrySet()
            System.out.println("迭代器遍历entrySet():");
            Stopwatch stopwatch = Stopwatch.createStarted();
            // 调用HashMap的entrySet()方法获取包含所有键值对的Set视图，
            // 然后调用Set的iterator()方法返回一个迭代器对象，用于依次遍历Set中的每个键值对。
            Iterator<Entry<String, String>> iterator = map.entrySet().iterator();
            // hasNext()方法用于判断迭代器中是否还有下一个元素或键值对，如果有，则返回true；否则返回false
            while (iterator.hasNext()) {
        
                // next()方法则用于获取迭代器中的下一个元素或键值对，并将迭代器的指针移动到下一个位置。
                Entry<String, String> entry = iterator.next();
                System.out.println(entry.getKey() + " : " + entry.getValue());
                /**
                 * 如果在使用迭代器遍历Map对象时，使用Map对象自带的remove()方法删除元素，可能会出现ConcurrentModificationException异常。
                 * 这是因为在使用迭代器遍历Map对象时，迭代器会维护一个计数器modCount，用于记录Map对象的修改次数。
                 * 当使用Map对象自带的remove()方法删除元素时，计数器modCount的值会增加，但是迭代器中记录的计数器值不会改变。
                 * 因此，当迭代器再次调用next()方法获取下一个元素时，会发现计数器的值已经发生变化，于是就会抛出ConcurrentModificationException异常。
                 *
                 * 为了避免这种情况发生，可以在使用迭代器遍历Map对象时，使用迭代器自带的remove()方法删除元素。
                 * 因为在使用迭代器自带的remove()方法删除元素时，迭代器会更新计数器modCount的值，
                 * 从而避免了ConcurrentModificationException异常的发生。
                 */
                // map.remove(entry.getKey()); X
                //if ("第二个key".equals(entry.getKey())) {
        
                //    // map.remove(entry.getKey()); X
                //    iterator.remove(); // 删除当前键值对 ✓
                //}
            }
    
            System.out.printf("运行时间 %d",stopwatch.elapsed(TimeUnit.MILLISECONDS));
        }
    
        /**
         * 优点：使用迭代器遍历keySet()可以遍历所有的键，代码较为简单。
         * 
         * 缺点：使用迭代器遍历keySet()只能遍历键，无法同时获取对应的值，如果需要获取值，则需要通过键获取值，效率较低。另外，在遍历过程中如果删除元素，可能会导致并发修改异常。
         */
        @Test
        public void testKeySet() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // 迭代器遍历keySet()
            System.out.println("迭代器遍历keySet():");
            // map.keySet()返回的是一个Set集合，包含了map中所有的key。
            // 通过调用iterator()方法，可以得到该集合的迭代器，用于遍历集合中的元素。
            Iterator<String> iterator = map.keySet().iterator();
            while (iterator.hasNext()) {
        
                String key = iterator.next();
                System.out.println(key + " : " + map.get(key));
            }
        }
    
        /**
         * 优点：使用迭代器遍历values()可以遍历所有的值，代码较为简单。
         * 
         * 缺点：使用迭代器遍历values优点：()只能遍历值，无法同时获取对应的键，如果需要获取键，则需要通过值查找对应的键，效率较低。
         * 另外，在遍历过程中如果删除元素，可能会导致并发修改异常。
         */
        @Test
        public void testValues() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // 迭代器遍历values()
            System.out.println("迭代器遍历values():");
            // map.values()返回的是一个Collection集合，包含了map中所有的value。
            // 通过调用iterator()方法，可以得到该集合的迭代器，用于遍历集合中的元素。
            Iterator<String> iterator = map.values().iterator();
            while (iterator.hasNext()) {
        
                String value = iterator.next();
                System.out.println(value);
            }
        }
    
        /**
         * 优点：使用foreach循环遍历entrySet()代码简单，易于理解。
         * 
         * 缺点：使用foreach循环遍历entrySet()只能遍历所有的键值对，无法针对单个元素进行操作，例如删除某个元素。
         */
        @Test
        public void testEntrySet() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // foreach循环遍历entrySet()
            System.out.println("foreach循环遍历entrySet():");
            // map.entrySet()返回的是一个Set集合，包含了map中所有的key-value对。
            // 由于Set集合实现了Iterable接口，因此可以使用for-each循环遍历集合中的元素。
            for (Entry<String, String> entry : map.entrySet()) {
        
                System.out.println(entry.getKey() + " : " + entry.getValue());
            }
        }
    
        /**
         * 优点：使用foreach循环遍历keySet()代码简单，易于理解。
         * 
         * 缺点：使用foreach循环遍历keySet()只能遍历所有的键，无法同时获取对应的值，如果需要获取值，则需要通过键获取值，效率较低。
         */
        @Test
        public void testForeachKeySet() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // foreach循环遍历keySet()
            System.out.println("foreach循环遍历keySet():");
            // map.keySet()返回的是一个Set集合，包含了map中所有的key。
            // 由于Set集合实现了Iterable接口，因此可以使用for-each循环遍历集合中的元素。
            for (String key : map.keySet()) {
        
                System.out.println(key + " : " + map.get(key));
            }
        }
    
        /**
         * 优点：使用foreach循环遍历values()代码简单，易于理解。
         * 
         * 缺点：使用foreach循环遍历values()只能遍历所有的值，无法同时获取对应的键，如果需要获取键，则需要通过值查找对应的键，效率较低。
         */
        @Test
        public void testForeachValues() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // foreach循环遍历values()
            System.out.println("foreach循环遍历values():");
            // map.values()返回的是一个Collection集合，包含了map中所有的value。
            // 由于Collection集合实现了Iterable接口，因此可以使用for-each循环遍历集合中的元素。
            for (String value : map.values()) {
        
                System.out.println(value);
            }
        }
    
        /**
         * 优点：Java 8 Stream遍历代码简洁，易于理解，可以结合Lambda表达式使用。
         * 
         * 缺点：Java 8 Stream遍历需要先将Map转换为Set或List，而转换过程需要额外的开销。
         */
        @Test
        public void testStream() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // Java 8 Stream
            System.out.println("Java 8 Stream:");
            // 调用entrySet()方法获取HashMap中所有键值对的Set集合。然后，使用stream()方法将Set集合转化为Stream流。
            // 接着，调用forEach()方法，传入一个Lambda表达式，对Stream流中的每一个元素执行相应的操作。
            map.entrySet().stream().forEach(entry -> {
        
                System.out.println(entry.getKey() + " : " + entry.getValue());
            });
            // 这段代码与使用Stream API的代码非常相似，但是它不是使用Stream API。
            // 它使用了HashMap中的entrySet()方法，该方法返回一个Set集合，其中包含HashMap中的所有键值对（Entry对象）。
            // 然后，使用forEach()方法遍历Set集合中的所有Entry对象，对每个Entry对象执行相应的操作。
            // 代码更加简洁明了，但是由于没有使用Stream API，可能在某些场景下效率稍低。
            map.entrySet().forEach(entry -> {
        
                System.out.println(entry.getKey() + " : " + entry.getValue());
            });
            // 使用Lambda表达式对HashMap中的每一个键值对（Entry对象）进行操作。
            // forEach()方法接受一个BiConsumer接口类型的参数，该接口定义了一个accept()方法，
            // 接受两个参数（一个key和一个value），并对它们进行操作。
            // 在Lambda表达式中，使用箭头符号“->”将accept()方法的实现与参数列表连接起来。
            map.forEach((key, value) -> System.out.println(key + " : " + value));
        }
    
        /**
         * 优点：parallelStream遍历可以充分利用多核CPU的性能，提高遍历速度。
         * 
         * 缺点：parallelStream遍历需要先将Map转换为Set或List，而转换过程需要额外的开销。同时，由于并行操作需要对数据进行分割和合并，因此在某些场景下可能会比串行遍历更慢。
         */
        @Test
        public void testParallelStream() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // parallelStream遍历
            System.out.println("parallelStream遍历:");
            // 这段代码与前面介绍的map.entrySet().stream().forEach()基本相同，只不过使用了parallelStream()方法，将遍历操作并行化处理。
            //
            // parallelStream()方法是Java 8中添加的方法，用于将Stream中的元素分成多个部分，并在多个处理器上并行执行操作。
            // 这种并行处理能够提高代码的性能，特别是当需要处理大量数据时。
            map.entrySet().parallelStream().forEach(entry -> {
        
                System.out.println(entry.getKey() + " : " + entry.getValue());
            });
        }
    
        /**
         * 使用函数式接口遍历
         */
        @Test
        public void testFunctional() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // 使用函数式接口遍历
            System.out.println("使用函数式接口遍历:");
            // 创建了一个Consumer实例action，它用于将HashMap的每个键值对打印出来。
            Consumer<Entry<String, String>> action = entry -> {
        
                System.out.println(entry.getKey() + " : " + entry.getValue());
            };
            // 使用entrySet().forEach()方法遍历map，并将action作为参数传递给forEach()方法，以便执行对每个键值对的操作。
            map.entrySet().forEach(action);
    
        }
    
        /**
         * 使用Predicate、Function、Supplier遍历
         */
        @Test
        public void testPredicate() {
        
            Map<String, String> map = new HashMap<>(4);
            map.put("第一个key", "第一个value");
            map.put("第二个key", "第二个value");
            map.put("第三个key", "第三个value");
    
            // 使用Predicate、Function、Supplier遍历
            System.out.println("使用Predicate、Function、Supplier遍历:");
            // 创建一个Predicate接口实例predicate，其作用是过滤以key结尾的键值对。
            Predicate<Entry<String, String>> predicate = entry -> entry.getKey().endsWith("key");
            // 创建一个Function接口实例function，其作用是将符合条件的键值对转换为字符串
            Function<Entry<String, String>, String> function = entry -> "key=" + entry.getKey() + ", value=" + entry.getValue();
            // 创建一个Supplier接口实例supplier，其作用是提供一个空的StringBuilder实例来存储转换后的字符串
            Supplier<StringBuilder> supplier = StringBuilder::new;
            // 通过stream()方法将HashMap转换为Stream，并依次使用filter()方法对符合条件的键值对进行过滤，
            // 使用map()方法将符合条件的键值对转换为字符串，
            // 最后使用collect()方法将转换后的字符串拼接起来
            StringBuilder result = map.entrySet().stream()
                    .filter(predicate)
                    .map(function)
                    .collect(supplier, StringBuilder::append, StringBuilder::append);
            System.out.println(result.toString());
    
        }
    }