Java中如何遍历Map集合

P粉602998670

发布时间：2025-09-18 21:29:01

254人浏览过

来源于php中文网

原创

遍历Map主要有四种方式：使用entrySet()结合增强for循环或迭代器，适合需要键值对的场景，性能最优；使用keySet()仅遍历键，若需获取值会触发二次查找，性能略低；使用values()仅遍历值，适用于只关注值的场景；Java 8引入的forEach配合Lambda，语法简洁，可读性强。优先推荐entrySet()或forEach，既能高效访问键值对，又避免重复查找。若需在遍历中移除元素，必须使用Iterator的remove()方法，否则可能抛出ConcurrentModificationException；也可采用先收集待操作键再统一处理的策略。多线程环境下应选用ConcurrentHashMap以避免并发修改异常。选择方式时应根据实际需求权衡性能与可读性，同时注意不同Map实现的顺序特性与线程安全性。

java中如何遍历map集合

Java中遍历Map集合主要有几种方式，核心思路无非是获取Map的键集合、值集合或者键值对集合，然后逐一处理。在我看来，选择哪种方式，往往取决于你具体需要访问键、值还是两者兼顾，以及你使用的Java版本。理解它们的细微差别，能帮助我们写出更高效、更易读的代码。

解决方案

遍历Map集合，我们通常会用到以下几种策略：

1. 使用

entrySet()

遍历（推荐，尤其是需要键值对时）

这是最常见也最推荐的方式，因为它在一次迭代中就能获取键和值，避免了多次查找。

立即学习“Java免费学习笔记（深入）”；

增强for循环

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

public class MapIterationExample {
    public static void main(String[] args) {
        Map scores = new HashMap<>();
        scores.put("Alice", 95);
        scores.put("Bob", 88);
        scores.put("Charlie", 92);

        System.out.println("--- 使用 entrySet() 和增强for循环 ---");
        for (Map.Entry entry : scores.entrySet()) {
            String name = entry.getKey();
            Integer score = entry.getValue();
            System.out.println(name + " 的分数是: " + score);
        }
    }
}

这种方式直观且高效，特别适合需要同时处理键和值的情况。

使用迭代器（Iterator） 当你需要在遍历过程中安全地移除元素时，迭代器是必不可少的。

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

public class MapIterationWithIterator {
    public static void main(String[] args) {
        Map ages = new HashMap<>();
        ages.put("David", 30);
        ages.put("Eve", 25);
        ages.put("Frank", 35);

        System.out.println("--- 使用 entrySet() 和迭代器 ---");
        Iterator> iterator = ages.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = iterator.next();
            String name = entry.getKey();
            Integer age = entry.getValue();
            System.out.println(name + " 的年龄是: " + age);

            // 示例：如果年龄小于30，移除
            if (age < 30) {
                iterator.remove(); // 安全移除当前元素
            }
        }
        System.out.println("移除后的Map: " + ages);
    }
}

2. 使用

keySet()

遍历（仅需要键时）

如果你只关心Map中的键，或者打算通过键去获取值，可以使用

keySet()

。

增强for循环

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

public class MapKeySetIteration {
    public static void main(String[] args) {
        Map capitals = new HashMap<>();
        capitals.put("France", "Paris");
        capitals.put("Germany", "Berlin");
        capitals.put("Italy", "Rome");

        System.out.println("--- 使用 keySet() 和增强for循环 ---");
        for (String country : capitals.keySet()) {
            String capital = capitals.get(country); // 再次查找值
            System.out.println(country + " 的首都是: " + capital);
        }
    }
}

值得注意的是，

capitals.get(country)

在每次循环中都会执行一次查找操作。对于

HashMap

来说，这个操作的平均时间复杂度是O(1)，但如果Map非常大或者在性能敏感的场景，这可能会比直接使用

entrySet()

略慢一点。

3. 使用

values()

遍历（仅需要值时）

当你只需要Map中的所有值，而对键不感兴趣时，

values()

方法是最佳选择。

增强for循环

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

public class MapValuesIteration {
    public static void main(String[] args) {
        Map productPrices = new HashMap<>();
        productPrices.put("Laptop", 1200.0);
        productPrices.put("Mouse", 25.0);
        productPrices.put("Keyboard", 75.0);

        System.out.println("--- 使用 values() 和增强for循环 ---");
        for (Double price : productPrices.values()) {
            System.out.println("产品价格: " + price);
        }
    }
}

4. Java 8

forEach

方法（现代Java推荐）

Java 8引入的

forEach

方法配合Lambda表达式，为Map遍历提供了一种更简洁、更函数式的风格。

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

public class MapForEachIteration {
    public static void main(String[] args) {
        Map settings = new HashMap<>();
        settings.put("theme", "dark");
        settings.put("language", "en_US");
        settings.put("notifications", "true");

        System.out.println("--- 使用 Java 8 forEach ---");
        settings.forEach((key, value) -> {
            System.out.println("设置项: " + key + ", 值: " + value);
        });
    }
}

这种方式非常优雅，特别适合于简单的处理逻辑。

遍历Map时，哪种方法性能最优？

这是一个很实际的问题，尤其是在处理大量数据时。在我看来，笼统地说“哪种最优”可能有点绝对，因为这取决于你的具体需求和Map的实现。但通常情况下，我们可以给出一些倾向性的建议。

如果你需要同时访问Map中的键和值，那么使用

entrySet()

并结合增强for循环或Java 8的
forEach
方法通常是最高效的。原因很简单：

entrySet()

返回的是

Set>

，每个

Entry

对象都直接包含了键和值。这样，在遍历过程中，你不需要再通过键去Map中进行二次查找（比如

map.get(key)

），从而减少了潜在的开销。对于

HashMap

这种内部基于哈希表实现的Map，

get(key)

操作的平均时间复杂度虽然是O(1)，但在循环中重复执行，其常数因子累加起来也可能变得显著。

相比之下，如果使用

keySet()

遍历，然后通过

map.get(key)

来获取值，虽然代码可能看起来更直观，但每次

get

操作都会涉及哈希计算和可能的链表遍历（在哈希冲突时），这无疑会增加总体的执行时间。对于

TreeMap

这种基于红黑树实现的Map，

get

操作的时间复杂度是O(logN)，那么

keySet().get(key)

的方式性能劣势会更加明显。

而

values()

方法则只关注值，如果你真的只需要值，那它无疑是最直接且最高效的。

Java 8的

forEach

方法在内部实现上通常也做了优化，它的性能表现通常与

entrySet()

的增强for循环相当，甚至可能因为其内部的优化而略有优势。更重要的是，它提供了更简洁的语法，提升了代码的可读性。

松果AI写作

专业全能的高效AI写作工具

下载

所以，我的建议是：如果需要键值对，优先考虑

entrySet()

或Java 8的
forEach
；如果只关注键，用
keySet()
；只关注值，用
values()
。在绝大多数情况下，这种选择已经足够优化性能，除非你面临极端性能瓶颈，才需要深入到JIT编译器的行为甚至JVM层面去分析。

如何在遍历Map时避免ConcurrentModificationException？

ConcurrentModificationException

是Java集合框架中一个常见的“陷阱”，它通常发生在你尝试在迭代一个集合（包括Map的键集、值集或入口集）的同时，又通过集合自身的

add

、

remove

等方法修改它的结构时。这就像你一边看书一边撕掉书页，自然会乱套。

避免这种异常，有几种行之有效的方法：

使用迭代器自身的

remove()

方法：如果你需要在遍历过程中移除当前迭代到的元素，那么必须使用迭代器提供的

iterator.remove()

方法。这个方法是唯一在迭代过程中安全修改集合的方式。它会正确地更新迭代器的内部状态，避免抛出异常。

Map studentScores = new HashMap<>();
studentScores.put("Alice", 85);
studentScores.put("Bob", 60);
studentScores.put("Charlie", 90);

Iterator> entryIterator = studentScores.entrySet().iterator();
while (entryIterator.hasNext()) {
    Map.Entry entry = entryIterator.next();
    if (entry.getValue() < 70) {
        System.out.println("移除不及格学生: " + entry.getKey());
        entryIterator.remove(); // 安全移除
    }
}
System.out.println("剩余学生: " + studentScores);

先收集，后修改：如果你的修改操作不仅仅是移除当前元素，或者你需要在遍历结束后再进行批量修改，那么一个非常稳妥的策略是：在遍历时，将需要修改（添加、删除）的键或键值对收集到一个临时的集合中，待遍历完成后，再根据这个临时集合对原Map进行操作。

Map userPreferences = new HashMap<>();
userPreferences.put("theme", "light");
userPreferences.put("font_size", "medium");
userPreferences.put("status", "active");
userPreferences.put("old_feature", "true");

List keysToRemove = new ArrayList<>();
for (Map.Entry entry : userPreferences.entrySet()) {
    if (entry.getKey().startsWith("old_")) {
        keysToRemove.add(entry.getKey());
    }
}

for (String key : keysToRemove) {
    userPreferences.remove(key); // 遍历结束后批量移除
}
System.out.println("更新后的偏好设置: " + userPreferences);

使用
```
ConcurrentHashMap
```
：如果你的Map需要在多线程环境下被并发修改，并且你希望迭代器能够容忍这些修改，那么
```
java.util.concurrent.ConcurrentHashMap
```
是你的首选。
```
ConcurrentHashMap
```
的迭代器是“弱一致性”（weakly consistent）的，这意味着它们反映了在某个时间点Map的状态，并且能够容忍在其创建后发生的并发修改，而不会抛出
```
ConcurrentModificationException
```
。当然，这可能意味着迭代器不会反映所有最新的修改。

Java 8的

removeIf

方法：虽然

Map

本身没有

removeIf

，但它的

entrySet()

、

keySet()

和

values()

返回的集合视图可能支持。例如，如果你想基于某个条件移除Map中的条目，可以考虑将

entrySet()

转换为流，或者在某些情况下，如果Map实现支持，可以使用

entrySet()

上的

removeIf

。

// 这种方式需要Map的EntrySet支持removeIf，并非所有Map都直接支持
// 更通用的做法是先收集，后移除
Map products = new HashMap<>();
products.put("Apple", 10);
products.put("Banana", 5);
products.put("Orange", 12);

// 假设我们要移除库存小于10的产品
// 实际操作时，Map的entrySet()返回的Set可能不支持直接的removeIf
// 但我们可以通过流的方式实现类似效果
// 或者如上面提到的，先收集再移除
Map updatedProducts = products.entrySet().stream()
                                        .filter(entry -> entry.getValue() >= 10)
                                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
System.out.println("更新后的产品: " + updatedProducts);

对于Map，更直接的移除操作通常还是通过迭代器或先收集后修改。

Map遍历的常见误区和最佳实践是什么？

在Map遍历这件事情上，虽然看起来简单，但一些小习惯或误解可能导致代码效率低下或出现运行时错误。

常见误区：

在遍历时直接修改Map（非迭代器
```
remove()
```
）：这是最常见的错误，直接在增强for循环或使用普通for循环时调用
```
map.put()
```
或
```
map.remove()
```
，几乎必然导致
```
ConcurrentModificationException
```
。很多人可能觉得“我只是加了一个元素，应该没事吧？”或者“我只是删除了一个元素”，但只要改变了Map的结构，风险就存在。
过度使用
```
keySet()
```
然后
map.get(key)
：正如前面所说，如果你需要键和值，
```
entrySet()
```
通常是更优的选择。在循环内部反复调用
```
map.get(key)
```
，尤其是在
```
HashMap
```
中，虽然平均O(1)，但如果哈希冲突严重或Map非常大，累积的开销会变得可观。我见过一些代码，即使只需要键值对，也习惯性地用
```
keySet()
```
，这其实是浪费了一些性能。
对Map的迭代顺序有不切实际的期望：
```
HashMap
```
和
```
HashTable
```
不保证元素的迭代顺序，每次运行甚至每次调用
```
keySet()
```
或
```
entrySet()
```
都可能得到不同的顺序。如果你需要保持插入顺序，应该使用
```
LinkedHashMap
```
；如果需要自然排序（按键），则使用
```
TreeMap
```
。不理解这一点，可能会在调试时感到困惑。
忽略线程安全问题：在多线程环境中，如果多个线程同时遍历并修改同一个
```
HashMap
```
、
```
TreeMap
```
或
```
LinkedHashMap
```
，即使不抛出
```
ConcurrentModificationException
```
，也可能导致数据不一致或逻辑错误。在这种情况下，必须使用
```
ConcurrentHashMap
```
或其他同步机制。

最佳实践：

优先使用
```
entrySet()
```
或Java 8的
forEach
：当我需要同时访问键和值时，这几乎是我的默认选择。它们提供了最佳的性能和良好的可读性。
```
forEach
```
尤其适合那些简短、直接的处理逻辑。
根据需求选择最合适的遍历方式：
- 需要键值对：
```
entrySet()
```
  或
```
forEach
```
  。
- 只需要键：
```
keySet()
```
  。
- 只需要值：
```
values()
```
  。
- 需要在遍历中安全移除当前元素：
```
entrySet()
```
  结合迭代器
```
remove()
```
  。
修改Map时，先收集后处理：如果需要在遍历Map时进行复杂的修改（添加、删除多个元素，或者根据某些条件修改值），最安全、最清晰的做法是先遍历Map，将所有需要修改的键或值收集到一个临时集合中，然后待遍历完成后，再根据这个临时集合对原Map进行操作。这避免了在迭代过程中修改Map结构带来的风险。
考虑Map的实现特性：
- ```
HashMap
```
  ：无序，性能通常最好。
- ```
LinkedHashMap
```
  ：保持插入顺序，性能略低于
```
HashMap
```
  。
- ```
TreeMap
```
  ：按键的自然顺序或自定义比较器排序，性能通常是O(logN)，适合需要有序遍历的场景。
- ```
ConcurrentHashMap
```
  ：线程安全，弱一致性迭代器，适合并发环境。
代码可读性优先，性能优化次之（除非有瓶颈）：虽然我们讨论了性能，但在大多数业务应用中，Map的规模不足以让这些细微的性能差异成为瓶颈。因此，首先考虑代码的清晰度和可维护性。只有在性能分析确实指出Map遍历是瓶颈时，才需要进行更深入的优化。