孔乙己：你知道遍历 Map 集合有几种方式吗？

Yang 分类：面试浏览：1776 评论：0 字体皮肤收藏左侧展开最后修改于： 2021/01/15 20:16:27

本文首发于[默烦的个人学习博客](https://mofan212.gitee.io/)，网站已开通评论功能，欢迎小伙伴们踩踩，但请遵循相应的规范哦。

> 迭代器遍历

使用 `entrySet` 遍历：

```java
/**
 * @author 默烦 2020/10/10
 */
public class MapTest {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "List");
        map.put(2, "Queue");
        map.put(3, "Dequeue");
        map.put(4, "Set");
        map.put(5, "Map");

Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println(entry.getKey()+ " ---> " + entry.getValue());
        }
    }
}
```

使用 `keySet` 遍历：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "List");
    map.put(2, "Queue");
    map.put(3, "Dequeue");
    map.put(4, "Set");
    map.put(5, "Map");

Iterator<Integer> iterator = map.keySet().iterator();
    while (iterator.hasNext()) {
        Integer next = iterator.next();
        System.out.println(next + " ---> " + map.get(next));
    }
}
```

> ForEach 遍历

如果使用的 IDE 是 IDEA，在使用迭代器进行遍历时，可以按照 IDE 的提示转换成 ForEach 遍历。

使用 `entrySet` 遍历：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "List");
    map.put(2, "Queue");
    map.put(3, "Dequeue");
    map.put(4, "Set");
    map.put(5, "Map");

for (Map.Entry<Integer, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + " ---> " + entry.getValue());
    }
}
```

使用 `keySet` 遍历：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "List");
    map.put(2, "Queue");
    map.put(3, "Dequeue");
    map.put(4, "Set");
    map.put(5, "Map");

for (Integer integer : map.keySet()) {
        System.out.println(integer + " ---> " + map.get(integer));
    }
}
```

> Lambda 表达式遍历

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "List");
    map.put(2, "Queue");
    map.put(3, "Dequeue");
    map.put(4, "Set");
    map.put(5, "Map");

map.forEach((integer, s) -> {
        System.out.println(integer + " ---> " + s);
    });
}
```

> Stream 流遍历

单线程遍历：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "List");
    map.put(2, "Queue");
    map.put(3, "Dequeue");
    map.put(4, "Set");
    map.put(5, "Map");

map.entrySet().stream().forEach(entry -> {
        System.out.println(entry.getKey() + " ---> " + entry.getValue());
    });
}
```

使用 Stream 流 **单线程** 遍历时，经过 IDEA 的智能提示可以变成 Lambda 表达式的遍历。

多线程遍历：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "List");
    map.put(2, "Queue");
    map.put(3, "Dequeue");
    map.put(4, "Set");
    map.put(5, "Map");

map.entrySet().parallelStream().forEach(entry -> {
        System.out.println(entry.getKey() + " ---> " + entry.getValue());
    });
}
```

> 编写一个方法将 Map 的 value 存入 List 并返回

以 `HashMap<Integer, String>`为例：

```java
private static List<String> getValueList (HashMap<Integer, String> map) {
    // 获取集合中所有 value，想遍历 value 使用 迭代器
    Collection<String> values = map.values();
    // 获取集合中所有 key
    // Set<Integer> integers = map.keySet();
    ArrayList<String> list = new ArrayList<>();
    for (String value : values) {
        list.add(value);
    }
    return list;
}
```

上述代码可以直接压缩成两行，瞬间变得优雅：

```java
private static List<String> getValueList (HashMap<Integer, String> map) {
    Collection<String> values = map.values();
    return new ArrayList<>(values);
}
```

> 删除 Map 中某个元素

迭代器方式删除：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    // 省略插入的元素
    
    Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<Integer, String> next = iterator.next();
        // 删除 key 为 1 的元素
        if (next.getKey() == 1){
            iterator.remove();
        } else {
            System.out.println(next.getKey() + " ---> " + next.getValue());
        }
    }
}
```

**注意：** For 循环中删除元素的方式不安全，因此不建议在 For 循环中删除 Map 中的元素！

Lambda 表达式方式删除：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
	// 省略插入的元素

// 删除 key 为 1 的元素
    map.keySet().removeIf(key -> key == 1);
    map.forEach((integer, s) -> {
        System.out.println(integer + " ---> " + s);
    });
}
```

Stream 流删除：

```java
public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
	// 省略插入的元素

map.entrySet().stream().filter(entry -> entry.getKey() != 1).forEach(entry -> {
        System.out.println(entry.getKey() + " ---> " + entry.getValue());
    });
}
```

> 总结

有这么多的遍历方式，应该选择哪种呢？

首先从性能出发，看看谁性能高。

**谁的性能最高？**

经过测试，除了使用并行循环的 `parallelStream` 性能比极高之外（毕竟是多线程），其他几种遍历在性能方面几乎没有差异。

**`KeySet` 的性能远不如 `EntrySet`？**

还可以将遍历的代码编译成字节码然后查看，会发现使用 `EntrySet` 和 `KeySet` 代码差别不是很大，`KeySet` 的性能并不是远不如 `EntrySet`，单从性能的角度来说 `EntrySet` 和 `KeySet` 几乎是相近的，但从代码的优雅型和可读性来说，还是推荐使用 `EntrySet` 更好！

**如何删除 Map 中的元素？**

从代码中看，除了使用 For 循环外删除元素，其他三种都是可以安全地删除 Map 中的元素的，但要论简洁和优雅，还是使用 Lambda 表达式和 Stream 流更加奈斯。

**到底如何选择？**

Lambda 表达式和 Stream 流是 JDK8 的新特性，如果使用 JDK8 建议使用这两种方式，在这两种方式中，又更加推荐使用 Stream 流，它使用 `parallelStream` 遍历 Map 时性能高，也能安全删除元素。

如果使用的 JDK 版本小于 8，推荐使用迭代器模式。

标签：Java

版权声明：本文为博主原创文章，遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明，KuangStudy,以学为伴，一生相伴！

本文链接：https://www.kuangstudy.com/bbs/1350052496332034049

总共已有 0 条评论

举报

广告或垃圾信息
辱骂
涉政或违法
抄袭
不合适内容

0/150

提交

取消

公众号

官方抖音

Copyright © 梅州学相伴网络科技有限公司粤ICP备 - 2020109190号



登录即代表你同意用户协议和隐私政策