Java 8：如何收集Map中所有具有相同最大值的键列表

问题描述

假设我们有一个map，其中包含键值对。我们的目标是找到所有值等于map中最大值的键。

示例Map:

final Map map = new HashMap<>();
map.put("first", 50);
map.put("second", 10);
map.put("third", 50);
map.put("fourth", 20);

对于上述示例，Map中的最大值是50。键"first"和"third"都对应这个最大值。因此，我们期望的输出是一个包含["first", "third"]的列表。

现有尝试的局限性：

直接使用stream().max(Map.Entry.comparingByValue()).map(Map.Entry::getKey)通常只能返回一个键，即使存在多个键拥有相同的最大值。例如，它可能返回"third"（取决于流的内部顺序），但会忽略"first"。这不符合我们收集所有最大值键的需求。

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

解决方案一：使用Java 8 Stream API

此方法利用Java 8的Stream API进行多步处理。核心思想是首先根据值对Map的条目进行分组，然后从这些分组中找出与最大值对应的键列表。

实现思路：

1. 将Map.Entry流转换为Map>，其中键是原始Map中的值，而值是所有对应这些值的键的列表。
2. 从这个新的Map中，找到键（即原始值）最大的那个条目。
3. 提取该条目中的值（即我们需要的键列表）。

代码示例：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*;

public class MaxKeysCollector {

    public static List getMaxKeysUsingStream(Map map) {
        return map.entrySet()
                .stream()
                // 步骤1: 按值分组。键是原始值，值是所有对应这些值的键的列表。
                // 例如: {50=[first, third], 10=[second], 20=[fourth]}
                .collect(groupingBy(Map.Entry::getValue, mapping(Map.Entry::getKey, toList())))
                .entrySet()
                .stream()
                // 步骤2: 找出新Map中键（即原始最大值）最大的条目。
                .max(Map.Entry.>comparingByKey())
                // 步骤3: 获取该条目的值，即包含所有最大值键的列表。
                .orElseThrow(() -> new IllegalStateException("Map cannot be empty to find max keys."))
                .getValue();
    }

    public static void main(String[] args) {
        final Map map = new HashMap<>();
        map.put("first", 50);
        map.put("second", 10);
        map.put("third", 50);
        map.put("fourth", 20);

        List maxKeys = getMaxKeysUsingStream(map);
        System.out.println("Stream API 方法获取的最大值键列表: " + maxKeys); // 预期输出: [first, third] 或 [third, first] (顺序不保证)
    }
}

代码解析：

• groupingBy(Map.Entry::getValue, mapping(Map.Entry::getKey, toList()))：这是核心操作。它首先将Map的条目按照它们的值（Map.Entry::getValue）进行分组。对于每个分组，它不是简单地收集Map.Entry，而是通过mapping(Map.Entry::getKey, toList())进一步处理，只收集键并将其放入一个列表中。
• max(Map.Entry.>comparingByKey())：在生成的新Map（Map>）上，我们再次创建一个流，并使用max操作符，通过比较键（即原始Map中的值）来找到最大的条目。
• orElseThrow().getValue()：如果Map不为空，max操作会返回一个Optional>>。orElseThrow()用于获取其内部值，然后getValue()提取出该条目中包含的键列表。

注意事项：

Bing图像创建器

必应出品基于DALL·E的AI绘图工具

下载

此方法涉及两次流迭代。第一次迭代用于分组，第二次迭代用于查找最大分组。虽然第二次迭代的Map通常会比原始Map小，但在数据量非常大的情况下，这可能会带来一定的性能开销。

解决方案二：单次迭代的命令式循环

对于追求极致性能的场景，一个传统的命令式循环通常是最高效的解决方案，因为它只需要对Map进行一次遍历。

实现思路：

1. 初始化一个空列表maxKeys来存储结果。
2. 初始化maxValue为Integer.MIN_VALUE，用于跟踪当前遇到的最大值。
3. 遍历Map的每个条目。
4. 对于每个条目：
   • 如果当前条目的值小于maxValue，则跳过（它不可能是最大值）。
   • 如果当前条目的值大于maxValue，说明我们找到了一个新的最大值。此时，需要清空maxKeys列表，因为之前收集的键不再是最大值对应的键。
   • 更新maxValue为当前条目的值。
   • 将当前条目的键添加到maxKeys列表中。

代码示例：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MaxKeysCollector {

    public static List getMaxKeysUsingLoop(Map map) {
        List maxKeys = new ArrayList<>();
        int maxValue = Integer.MIN_VALUE; // 初始化为最小值

        for (Map.Entry entry : map.entrySet()) {
            int currentValue = entry.getValue();
            String currentKey = entry.getKey();

            if (currentValue < maxValue) {
                // 当前值小于已知的最大值，跳过
                continue;
            }

            if (currentValue > maxValue) {
                // 找到了一个新的最大值，清空之前收集的键
                maxKeys.clear();
                maxValue = currentValue; // 更新最大值
            }
            // 如果 currentValue == maxValue，或者 currentValue > maxValue (清空后)，则添加当前键
            maxKeys.add(currentKey);
        }
        return maxKeys;
    }

    public static void main(String[] args) {
        final Map map = new HashMap<>();
        map.put("first", 50);
        map.put("second", 10);
        map.put("third", 50);
        map.put("fourth", 20);
        map.put("fifth", 60); // 添加一个更大的值测试

        List maxKeysLoop = getMaxKeysUsingLoop(map);
        System.out.println("命令式循环方法获取的最大值键列表: " + maxKeysLoop); // 预期输出: [fifth]

        final Map map2 = new HashMap<>();
        map2.put("first", 50);
        map2.put("second", 10);
        map2.put("third", 50);
        List maxKeysLoop2 = getMaxKeysUsingLoop(map2);
        System.out.println("命令式循环方法获取的最大值键列表 (原始示例): " + maxKeysLoop2); // 预期输出: [first, third]
    }
}

代码解析：

• maxValue = Integer.MIN_VALUE;：确保任何Map中的值都能被正确识别为大于或等于初始最大值。
• if (currentValue
• if (currentValue > maxValue) maxKeys.clear();：这是关键逻辑。当发现一个比当前maxValue更大的值时，意味着之前maxKeys中收集的所有键都不再是最大值对应的键了，因此需要清空列表。
• maxValue = currentValue;：更新maxValue为新的最大值。
• maxKeys.add(currentKey);：将当前键添加到maxKeys中。这个操作会在两种情况下发生：
  • currentValue等于maxValue（收集所有相同最大值的键）。
  • currentValue大于maxValue（在清空列表并更新maxValue之后，将新最大值对应的键添加进去）。

性能优势：

此方法只需要对Map进行一次迭代，因此在性能上通常优于Stream API的多步处理方法，尤其是在Map包含大量数据时。

总结与选择

本文提供了两种在Java 8中收集Map中所有具有相同最大值的键列表的方法：

1. Stream API方法： 简洁、声明性强，利用了groupingBy和max等高级Stream操作。代码可读性较高，但涉及多次迭代，可能在极端性能要求下略逊一筹。
2. 命令式循环方法： 性能最优，仅需单次迭代。逻辑清晰，易于理解其执行过程，适用于对性能有严格要求的场景。

在实际开发中，如果Map的数据量不是特别巨大，Stream API方法因其简洁性和声明性通常是更受欢迎的选择。但如果Map可能包含数十万甚至数百万条目，并且性能是首要考虑因素，那么单次迭代的命令式循环将是更明智的选择。