Java中如何遍历Map集合-java教程-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<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 95);
        scores.put("Bob", 88);
        scores.put("Charlie", 92);

        System.out.println("--- 使用 entrySet() 和增强for循环 ---");
        for (Map.Entry<String, Integer> 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<String, Integer> ages = new HashMap<>();
        ages.put("David", 30);
        ages.put("Eve", 25);
        ages.put("Frank", 35);

        System.out.println("--- 使用 entrySet() 和迭代器 ---");
        Iterator<Map.Entry<String, Integer>> iterator = ages.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> 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<String, String> 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<String, Double> 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<String, String> 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<Map.Entry<K, V>>

登录后复制

，每个

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循环相当，甚至可能因为其内部的优化而略有优势。更重要的是，它提供了更简洁的语法，提升了代码的可读性。

集简云

软件集成平台，快速建立企业自动化与智能化

查看详情

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

entrySet()

登录后复制

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

如何在遍历Map时避免ConcurrentModificationException？

ConcurrentModificationException

登录后复制

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

add

登录后复制

、

remove

登录后复制

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

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

使用迭代器自身的

remove()

登录后复制

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

iterator.remove()

登录后复制

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

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

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

登录后复制

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

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

List<String> keysToRemove = new ArrayList<>();
for (Map.Entry<String, String> 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<String, Integer> products = new HashMap<>();
products.put("Apple", 10);
products.put("Banana", 5);
products.put("Orange", 12);

// 假设我们要移除库存小于10的产品
// 实际操作时，Map的entrySet()返回的Set可能不支持直接的removeIf
// 但我们可以通过流的方式实现类似效果
// 或者如上面提到的，先收集再移除
Map<String, Integer> 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遍历是瓶颈时，才需要进行更深入的优化。