在 Java 中遍历 HashMap 的5种最佳方式

已于 2022-06-08 18:02:47 修改
阅读量992 收藏 1
点赞数
分类专栏： Java 文章标签： java
于 2022-04-19 09:09:23 首次发布
原文链接：https://mp.weixin.qq.com/s/qlp5js074NpppM04Ugv2ag
版权

参考链接：

java 中 List 的5种遍历方式
Java 中 Set 的4中遍历方式
Java 中 Map 的5种遍历方式

在 Java 中遍历 HashMap 的5种最佳方式

2020-03-14 10:41·骇客与画家

原文地址：
https://www.javaguides.net/2020/03/5-best-ways-to-iterate-over-hashmap-in-java.html[1]

作者：Ramesh Fadatare[2]

翻译：高行行

在本文中，我们将通过示例讨论在 Java 上遍历 HashMap[3] 的五种最佳方法。

  1. 使用 Iterator 遍历 HashMap EntrySet
  2. 使用 Iterator 遍历 HashMap KeySet
  3. 使用 For-each 循环迭代 HashMap
  4. 使用 Lambda 表达式[4]遍历 HashMap
  5. 使用 Stream API[5] 遍历 HashMap

通过
https://www.javaguides.net/2018/07/java-8-lambda-expressions.html [6]了解有关 lambda 表达式的信息

1. 使用 Iterator 遍历 HashMap EntrySet

package com.java.tutorials.iterations;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

/**
 * 在 Java 中遍历 HashMap 的5种最佳方法
 * @author Ramesh Fadatare
 *
 */
public class IterateHashMapExample {
    public static void main(String[] args) {
        // 1. 使用 Iterator 遍历 HashMap EntrySet
        Map < Integer, String > coursesMap = new HashMap < Integer, String > ();
        coursesMap.put(1, "C");
        coursesMap.put(2, "C++");
        coursesMap.put(3, "Java");
        coursesMap.put(4, "Spring Framework");
        coursesMap.put(5, "Hibernate ORM framework");

        Iterator < Entry < Integer, String >> iterator = coursesMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry < Integer, String > entry = iterator.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

Output:

1
C
2
C++
3
Java
4
Spring Framework
5
Hibernate ORM framework

2. 使用 Iterator 遍历 HashMap KeySet

package com.java.tutorials.iterations;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * 在 Java 中遍历 HashMap 的5种最佳方法
 * @author Ramesh Fadatare
 *
 */
public class IterateHashMapExample {
    public static void main(String[] args) {
        Map < Integer, String > coursesMap = new HashMap < Integer, String > ();
        coursesMap.put(1, "C");
        coursesMap.put(2, "C++");
        coursesMap.put(3, "Java");
        coursesMap.put(4, "Spring Framework");
        coursesMap.put(5, "Hibernate ORM framework");

        // 2. 使用 Iterator 遍历 HashMap KeySet
        Iterator < Integer > iterator = coursesMap.keySet().iterator();
        while (iterator.hasNext()) {
            Integer key = iterator.next();
            System.out.println(key);
            System.out.println(coursesMap.get(key));
        }
    }
}

Output:

1
C
2
C++
3
Java
4
Spring Framework
5
Hibernate ORM framework

3. 使用 For-each 循环遍历 HashMap

package com.java.tutorials.iterations;

import java.util.HashMap;
import java.util.Map;

/**
 * 在 Java 中遍历 HashMap 的5种最佳方法
 * @author Ramesh Fadatare
 *
 */
public class IterateHashMapExample {
    public static void main(String[] args) {
        Map < Integer, String > coursesMap = new HashMap < Integer, String > ();
        coursesMap.put(1, "C");
        coursesMap.put(2, "C++");
        coursesMap.put(3, "Java");
        coursesMap.put(4, "Spring Framework");
        coursesMap.put(5, "Hibernate ORM framework");

        // 3. 使用 For-each 循环遍历 HashMap
        for (Map.Entry < Integer, String > entry: coursesMap.entrySet()) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

Output:

1
C
2
C++
3
Java
4
Spring Framework
5
Hibernate ORM framework

4. 使用 Lambda 表达式遍历 HashMap

package com.java.tutorials.iterations;

import java.util.HashMap;
import java.util.Map;

/**
 * 在 Java 中遍历 HashMap 的5种最佳方法
 * @author Ramesh Fadatare
 *
 */
public class IterateHashMapExample {
    public static void main(String[] args) {
        Map < Integer, String > coursesMap = new HashMap < Integer, String > ();
        coursesMap.put(1, "C");
        coursesMap.put(2, "C++");
        coursesMap.put(3, "Java");
        coursesMap.put(4, "Spring Framework");
        coursesMap.put(5, "Hibernate ORM framework");

        // 4. 使用 Lambda 表达式遍历 HashMap
        coursesMap.forEach((key, value) -> {
            System.out.println(key);
            System.out.println(value);
        });
    }
}

Output:

1
C
2
C++
3
Java
4
Spring Framework
5
Hibernate ORM framework

5. 使用 Stream API 遍历 HashMap

package com.java.tutorials.iterations;

import java.util.HashMap;
import java.util.Map;

/**
 * 在 Java 中遍历 HashMap 的5种最佳方法
 * @author Ramesh Fadatare
 *
 */
public class IterateHashMapExample {
    public static void main(String[] args) {
        Map < Integer, String > coursesMap = new HashMap < Integer, String > ();
        coursesMap.put(1, "C");
        coursesMap.put(2, "C++");
        coursesMap.put(3, "Java");
        coursesMap.put(4, "Spring Framework");
        coursesMap.put(5, "Hibernate ORM framework");

        // 5. 使用 Stream API 遍历 HashMap
        coursesMap.entrySet().stream().forEach((entry) - > {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
}

Output:

1
C
2
C++
3
Java
4
Spring Framework
5
Hibernate ORM framework

HashMap 的相关教程

  • 集合框架-HashMap 类[7]
  • 集合框架-LinkedHashMap 类[8]
  • 集合框架-TreeMap 类[9]
  • 集合框架-EnumMap[10]
  • 集合框架-WeakHashMap[11]
  • 集合框架-IdentityHashMap[12]

Java中List集合的遍历

1 Iterator迭代器

使用迭代器Iterator进行遍历，这是直接根据List集合的一种自动遍历方式；

import java.util.ArrayList;
 
public class Demo03 {
    public static void main(String[] args) {
        ArrayList<News> list = new ArrayList<News>();
　　　　
        list.add(new News(1,"list1","a"));
        list.add(new News(2,"list2","b"));
        list.add(new News(3,"list3","c"));
        list.add(new News(4,"list4","d"));
　　　
        Iterator<News> iter = list.iterator();
        while (iter.hasNext()) {
            News s = (News) iter.next();
            System.out.println(s.getId()+"  "+s.getTitle()+"  "+s.getAuthor());
        }
    }
}

-------------------------------------------
    /**
     *  iterator
     * 迭代器
     * @param list
     */
    public static void iteratorTest(List<Integer> list) {
        long before = System.currentTimeMillis();
        for (Iterator<Integer> iterator = list.iterator(); iterator.hasNext(); ) {
            iterator.next();
        }
        long after = System.currentTimeMillis();
        System.out.println("iterator for time=\t"  + (after - before));

        before = System.currentTimeMillis();
        /**
         * while 循环写法
         */
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            iterator.next();
        }
        after = System.currentTimeMillis();
        System.out.println("iterator while time=\t"  + (after - before));
    }

2 for循环

指定下标长度，使用List集合的size()方法，进行for循环遍历，这种遍历方式最基础；

import java.util.ArrayList;
 
public class Demo01 {
   /* for循环遍历List集合 */
　　public static void main(String[] args) {
　　　ArrayList<News> list = new ArrayList<News>();
　　　list.add(new News(1,"list1","a"));
　　　list.add(new News(2,"list2","b"));
　　　list.add(new News(3,"list3","c"));
　　　list.add(new News(4,"list4","d"));
　　　for (int i = 0; i < list.size(); i++) {
            News s = (News)list.get(i);
            System.out.println(s.getId()+"  "+s.getTitle()+"  "+s.getAuthor());
　　　}　　
   }
}

3 增强for

使用foreach遍历List，但不能对某一个元素进行操作（这种方法在遍历数组和Map集合的时候同样适用），这种遍历方式较为简洁；

import java.util.ArrayList;
 
public class Demo02 {
    /* foreach循环遍历List集合 */
    public static void main(String[] args) {
        ArrayList<News> list = new ArrayList<News>();
        list.add(new News(1,"list1","a"));
        list.add(new News(2,"list2","b"));
        list.add(new News(3,"list3","c"));
        list.add(new News(4,"list4","d"));
        for (News s : list) {
            System.out.println(s.getId()+"  "+s.getTitle()+"  "+s.getAuthor());
        }
    }
}

4 for-each(java8才支持)

/**
     *  foreach
     * foreach 最慢不推荐 java8 lambda
     * @param list
     */
    public static void forEachTest(List<Integer> list) {
        long before = System.currentTimeMillis();
        list.forEach(item -> {
             System.out.println(item);
        });
        long after = System.currentTimeMillis();
        System.out.println("list.forEach time=\t"  + (after - before));
    }

5 stream().forEach() 注意java8 才支持

 /**
     * stream foreach
     * stream foreach java8 特有
     * @param list
     */
    public static void streamForEachTest(List<Integer> list) {
        long before = System.currentTimeMillis();
        list.stream().forEach(item -> {
            System.out.println(item);
        });
        long after = System.currentTimeMillis();
        System.out.println("list.stream().forEach time=\t"  + (after - before));
    }

6 parallelStream().forEach() 注意java8 才支持

/**
     *  stream foreach
     * stream foreach java8 特有
     * @param list
     */
    public static void parallelStreamForEachTest(List<Integer> list) {
        long before = System.currentTimeMillis();
        list.parallelStream().forEach(item -> {
            System.out.println(item);
        });
        long after = System.currentTimeMillis();
        System.out.println("list.parallelStream().forEach time=\t"  + (after - before));
    }

Java 中 Set 的4中遍历方式

Set 和 List 遍历方式基本一致，Set 没有fori 的遍历方式

主测试方法

    @Test
    public void test(){
        Set<Integer> set = new HashSet<>();
        int n = 1000_0000;
        for (int i = 0; i < n; i++) {
            set.add(i);
        }

        System.out.println("======== 1 iterator ==========");
        iteratorTest(set);
        System.out.println("======== 2 增强for ==========");
        forBoostTest(set);
        System.out.println("======== 3 forEach 最耗时 java8 ==========");
        forEachTest(set);
        System.out.println("======== 4 stream forEach 比较耗时和增强for差不多 java8 ==========");
        streamForEachTest(set);
    }

测试结果

======== 1 iterator ==========
set.iterator() for time=    68
set.iterator() while time=    66

======== 2 增强for ==========
set.for Boost time=    75

======== 3 forEach 最耗时 java8 ==========
set.forEach time=    118

======== 4 stream forEach 比较耗时和增强for差不多 java8 ==========
set.stream().forEach() time=    71



1 迭代器方法   

   /**
     * 1 iterator
     * 迭代器
     * @param set
     */
    public static void iteratorTest(Set<Integer> set) {
        long before = System.currentTimeMillis();
        /**
         * for 循环写法
         */

        for (Iterator<Integer> iterator = set.iterator(); iterator.hasNext(); ) {
            iterator.next();
        }
        long after = System.currentTimeMillis();
        System.out.println("set.iterator() for time=\t"  + (after - before));

        before = System.currentTimeMillis();
        /**
         * while 循环写法
         */
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            iterator.next();
        }
        after = System.currentTimeMillis();
        System.out.println("set.iterator() while time=\t"  + (after - before));
    }



2 增强for

   /**
     * 
     * 增强for
     * @param set
     */
    public static void forBoostTest(Set<Integer> set) {
        long before = System.currentTimeMillis();
        for (int item : set) {
             System.out.println(item);
        }
        long after = System.currentTimeMillis();
        System.out.println("set.for Boost time=\t"  + (after - before));
    }


3 set.forEach 注意：java8 才支持

    /**
     *  foreach
     * foreach 最慢不推荐 java8 lambda
     * @param set
     */
    public static void forEachTest(Set<Integer> set) {
        long before = System.currentTimeMillis();
        set.forEach(item -> {
            System.out.println(item);
        });
        long after = System.currentTimeMillis();
        System.out.println("set.forEach time=\t"  + (after - before));
    }

4 set.stream().forEach 注意：java8 才支持

   /**
     *  stream foreach
     * stream foreach java8 特有
     * @param set
     */
    public static void streamForEachTest(Set<Integer> set) {
        long before = System.currentTimeMillis();
        set.stream().forEach(item -> {
            // System.out.println(item);
        });
        long after = System.currentTimeMillis();
        System.out.println("set.stream().forEach() time=\t"  + (after - before));
    }

Collection.isEmpty()检测空

消灭 Java 代码的“坏味道”

使用 Collection.size() 来检测空逻辑上没有问题，但是使用 Collection.isEmpty()使得代码更易读，并且可以获得更好的性能。任何 Collection.isEmpty() 实现的时间复杂度都是 O(1) ，但是某些 Collection.size() 实现的时间复杂度可能是 O(n) 。

反例：

if (collection.size() == 0) {
    ...
}

正例：

if (collection.isEmpty()) {
    ...
}

如果需要还需要检测 null ，可采用CollectionUtils.isEmpty(collection)和CollectionUtils.isNotEmpty(collection)。

集合初始化尽量指定大小

Java 的集合类用起来十分方便，但是看源码可知，集合也是有大小限制的。每次扩容的时间复杂度很有可能是 O(n) ，所以尽量指定可预知的集合大小，能减少集合的扩容次数。

反例：

int[] arr = new int[]{1, 2, 3};
List<Integer> list = new ArrayList<>();
for (int i : arr) {
    list.add(i);
}

正例：

int[] arr = new int[]{1, 2, 3};
List<Integer> list = new ArrayList<>(arr.length);
for (int i : arr) {
    list.add(i);
}

字符串拼接使用 StringBuilder 

一般的字符串拼接在编译期 java 会进行优化，但是在循环中字符串拼接， java 编译期无法做到优化，所以需要使用 StringBuilder 进行替换。

反例：

String s = "";
for (int i = 0; i < 10; i++) {
    s += i;
}

正例：

String a = "a";
String b = "b";
String c = "c";
String s = a + b + c; // 没问题，java编译器会进行优化
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
    sb.append(i);  // 循环中，java编译器无法进行优化，所以要手动使用StringBuilder
}

使用String.valueOf(value)代替""+value

当要把其它对象或类型转化为字符串时，使用 String.valueOf(value) 比""+value 的效率更高。

反例：

int i = 1;
String s = "" + i;

正例：

int i = 1;
String s = String.valueOf(i);

罗汉翔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HashMap遍历
09-13
讲述了hashmap的几种遍历方法，相当经典
使用多种方式实现遍历HashMap的方法
09-02
在性能方面，entrySet()通常被认为是最有效的方式，因为它避免了两次查找（一次获取键，一次获取值）。然而，对于大型HashMap，优化可能取决于具体的应用场景，例如是否需要保持遍历顺序等。 总结来说，遍历HashMap...
java系列-LinkedHashMap遍历
lostfish123的专栏
12-12 426
获取全局变量entrySet，如果为null，创建LinkedEntrySet。创建LinkedEntryIterator。
Java中HashMap的几种典型遍历方式
最新发布
一勺菠萝丶的博客
06-04 734
在Java中，HashMap是一种非常常用的数据结构。在管理键值对时，我们经常需要遍历整个HashMap。本文将展示几种典型的遍历方式，包括使用Java 8的Lambda表达式。如果你使用Java 8，由于该版本JDK支持Lambda表达式，可以采用第五种方式来遍历。如果你想使用泛型，可以参考方法三。如果你使用旧版JDK不支持泛型，可以参考方法四。
java 遍历linkedhashmap_遍历Java中Java LinkedHashMap的值
weixin_29690065的博客
03-01 1968
Java中使用迭代器来迭代LinkedHashMap的值。让我们首先创建LinkedHashMap-LinkedHashMapl=newLinkedHashMap();将一些元素添加到LinkedHashMap-l.put("1","Jack");l.put("2","Tom");l.put("3","Jimmy");l.put("4","Morgan");l.put("5","...
java集合之LinkedHashMap
qq_41820066的博客
09-21 2472
LinkedHashMap原理解析
如何遍历LinkedHashMap
zjcheer_up的专栏
11-06 2506
for(Entry entry : urlparametersLinkedHashMap.entrySet()) { System.out.println("%%%%%%%%%%%%%%%"); System.out.println(entry.getKey()+":"+entry.getValue()); }
Java Map遍历方式的选择
12-22
Java Map的遍历方式在实际应用中是一个重要的性能优化考虑因素。常见的遍历方式有三种：keySet、entrySet和values。很多开发者推荐使用entrySet，认为它比keySet更高效，因为entrySet能一次性获取键值对，避免了额外...
java中HashMap详解
07-04
HashMap是Java编程语言中一种非常重要的数据结构，它实现了Map接口，主要用于存储键值对。HashMap内部基于哈希表（Hash Table）实现，利用哈希函数将键映射到一个特定的位置，以便快速查找和插入元素。以下是HashMap...
Java 中的HashMap详解和使用示例_动力节点Java学院整理
08-30
HashMap是Java编程语言中常用的集合类之一，它提供了一种以键值对形式存储数据的方式。HashMap基于哈希表的数据结构实现，具有快速查找、插入和删除的特点。本文将详细介绍HashMap的基本概念、构造函数、数据结构...
深入理解Java中的HashMap的实现机制
09-03
Java中的HashMap是一种高效的数据结构，它实现了Map接口，允许存储键值对，并通过键进行快速查找。HashMap的核心机制是基于哈希表（也称为散列表）的原理，它利用哈希函数将键转换为数组索引，从而快速定位到对应的...
Java HashMap 如何正确遍历并删除元素的方法小结
08-25
主要介绍了Java HashMap 如何正确遍历并删除元素的方法小结,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java HashMap三种循环遍历方式及其性能对比实例分析
08-25
主要介绍了Java HashMap三种循环遍历方式及其性能对比,结合具体实例形式分析了Java HashMap三种循环遍历方式的实现方法、运行效率及性能优劣,需要的朋友可以参考下
遍历LinkedHashMap最快的方式
weixin_35755562的博客
01-11 2594
遍历 LinkedHashMap 的最快方式是使用迭代器(iterator)。可以使用 keySet() 方法或 entrySet() 方法获取迭代器。 例如： LinkedHashMap<Integer, String> map = new LinkedHashMap<>(); // 往map中添加元素 // 遍历方式1：使用keySet() for (Integer ...
JAVA 中HashMap的几种遍历方式
qq_36944952的博客
04-27 4354
JAVA 中HashMap的几种遍历方式 创建HashMap对象 Map<String, Integer> map = new HashMap<>(); map.put("手表", 1000); map.put("手机", 4000); map.put("牙刷", 200); map.put("耳机",1500); 1.通过遍历map的键的方式，使用键找值进行遍历。 现获取Map集合的全部键的Set集
LinkedHashMap for循环遍历
keep12moving的博客
05-15 7264
Map<String, Future<String[]>> futures = new LinkedHashMap<String, Future<String[]>>(); futures.put(Line_Num, executorService.submit(api)); for (Map.Entry<String, Future&lt...
_104_Java_以HashMap为例遍历Map以及LinkedHashMap
poiuyppp的博客
09-20 134
Map的常用方法   ---------------------------------------   ---------------------------------------    --------------------------------------- import java.util.Collection; import java.util.HashMap...
Java集合之LinkedHashMap
woaimx_1314的博客
05-28 4031
第一张图为LinkedHashMap整体结构图，第二张图专门把循环双向链表抽取出来，直观一点，注意该循环双向链表的头部存放的是最久访问的节点或最先插入的节点，尾部为最近访问的或最近插入的节点，迭代器遍历方向是从链表的头部开始到链表尾部结束，在链表尾部有一个空的header节点，该节点不存放key-value内容，为LinkedHashMap类的成员属性，循环双向链表的入口。每次访问都把访问的那个数据移到双向队列的尾部去，那么每次要淘汰数据的时候，双向队列最头的那个数据不就是最不常访问的那个数据了吗？
java 循环迭代map
zhang804633234的专栏
11-24 300
【代码】java 循环迭代map。
java中map遍历最好的方法
05-09
要了解 Java 中的 Map 遍历的最佳方法，首先需要理解 Java 中 Map 的概念。Map 是 Java 编程语言中实现映射（Mapping）的对象。与 List 的元素按照顺序存储不同，Map 存储的是键值对（Key-Value Pair），其中每个键只能出现一次。Java 中 Map 的实现有很多种，例如 HashMap、LinkedHashMap、TreeMap 等。Map 中的数据可以使用 key-value 的方式访问，这使得 Map 在 Java 中非常有用。 在实现 Map 遍历的过程中，Java 提供了多种方法，可以选择使用最适合自身需求的方法，具体如下： 1. 使用 for-each 循环遍历 Map：此方法是最常见的遍历 Map 的方式，可以使用 for-each 循环遍历 Map 中的所有元素，但不能同时访问 key 和 value。 代码示例： ``` Map<String, Integer> map = new HashMap<>(); for (Map.Entry<String, Integer> entry : map.entrySet()) { System.out.println(entry.getKey() + "：" + entry.getValue()); } ``` 2. 使用 Iterator 遍历 Map：通过使用 Iterator，我们可以同时访问 Map 中的 key 和 value。这种方法处理大量数据时更加有效，因为在处理数据时可以省略一些不必要的对象创建和销毁操作。 代码示例： ``` Map<String, Integer> map = new HashMap<>(); Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry<String, Integer> entry = iterator.next(); System.out.println(entry.getKey() + "：" + entry.getValue()); } ``` 3. 使用 Lambda 表达式遍历 Map：Lambda 表达式是 Java 8 中新增的特性，可以大大简化代码的编写。使用 Lambda 表达式遍历 Map，可以同时访问 key 和 value，但比起前两种方法来说代码量更加简洁。 代码示例： ``` Map<String, Integer> map = new HashMap<>(); map.forEach((key, value) -> { System.out.println(key + "：" + value); }); ``` 综上所述，以上三种方法都可以实现 Map 的遍历，可以根据具体需求选择最适合自身的方法。同时，为了提高效率，可以使用 Iterator 或 Lambda 表达式来遍历大量元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值