登录
首页 >  文章 >  java教程

Java遍历Map的四种方法详解

时间：2026-01-21 12:36:44 352浏览 收藏

最近发现不少小伙伴都对文章很感兴趣，所以今天继续给大家介绍文章相关的知识，本文《Java遍历Map的几种方式》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

遍历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()遍历（推荐，尤其是需要键值对时）

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

  • 增强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>，每个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等方法修改它的结构时。这就像你一边看书一边撕掉书页，自然会乱套。

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

  1. 使用迭代器自身的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);

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

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

  4. 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遍历这件事情上，虽然看起来简单，但一些小习惯或误解可能导致代码效率低下或出现运行时错误。

常见误区：

  1. 在遍历时直接修改Map（非迭代器remove()）：这是最常见的错误，直接在增强for循环或使用普通for循环时调用map.put()或map.remove()，几乎必然导致ConcurrentModificationException。很多人可能觉得“我只是加了一个元素，应该没事吧？”或者“我只是删除了一个元素”，但只要改变了Map的结构，风险就存在。

  2. 过度使用keySet()然后map.get(key)：正如前面所说，如果你需要键和值，entrySet()通常是更优的选择。在循环内部反复调用map.get(key)，尤其是在HashMap中，虽然平均O(1)，但如果哈希冲突严重或Map非常大，累积的开销会变得可观。我见过一些代码，即使只需要键值对，也习惯性地用keySet()，这其实是浪费了一些性能。

  3. 对Map的迭代顺序有不切实际的期望：HashMap和HashTable不保证元素的迭代顺序，每次运行甚至每次调用keySet()或entrySet()都可能得到不同的顺序。如果你需要保持插入顺序，应该使用LinkedHashMap；如果需要自然排序（按键），则使用TreeMap。不理解这一点，可能会在调试时感到困惑。

  4. 忽略线程安全问题：在多线程环境中，如果多个线程同时遍历并修改同一个HashMap、TreeMap或LinkedHashMap，即使不抛出ConcurrentModificationException，也可能导致数据不一致或逻辑错误。在这种情况下，必须使用ConcurrentHashMap或其他同步机制。

最佳实践：

  1. 优先使用entrySet()或Java 8的forEach：当我需要同时访问键和值时，这几乎是我的默认选择。它们提供了最佳的性能和良好的可读性。forEach尤其适合那些简短、直接的处理逻辑。

  2. 根据需求选择最合适的遍历方式：

    • 需要键值对：entrySet() 或 forEach。
    • 只需要键：keySet()。
    • 只需要值：values()。
    • 需要在遍历中安全移除当前元素：entrySet()结合迭代器remove()。

  3. 修改Map时，先收集后处理：如果需要在遍历Map时进行复杂的修改（添加、删除多个元素，或者根据某些条件修改值），最安全、最清晰的做法是先遍历Map，将所有需要修改的键或值收集到一个临时集合中，然后待遍历完成后，再根据这个临时集合对原Map进行操作。这避免了在迭代过程中修改Map结构带来的风险。

  4. 考虑Map的实现特性：

    • HashMap：无序，性能通常最好。
    • LinkedHashMap：保持插入顺序，性能略低于HashMap。
    • TreeMap：按键的自然顺序或自定义比较器排序，性能通常是O(logN)，适合需要有序遍历的场景。
    • ConcurrentHashMap：线程安全，弱一致性迭代器，适合并发环境。

  5. 代码可读性优先，性能优化次之（除非有瓶颈）：虽然我们讨论了性能，但在大多数业务应用中，Map的规模不足以让这些细微的性能差异成为瓶颈。因此，首先考虑代码的清晰度和可维护性。只有在性能分析确实指出Map遍历是瓶颈时，才需要进行更深入的优化。

总而言之，理解不同遍历方式的特点和它们背后的Map实现机制，能让我们在日常开发中更加游刃有余，写出既健壮又高效的代码。

今天关于《Java遍历Map的四种方法详解》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！

前往漫画官网入口并下载 ➜
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>