Java 8+：高效获取Map中所有最大值对应的键列表

问题描述与常见误区

在java开发中，我们经常需要处理键值对数据，例如map。一个常见的需求是找出所有具有最大值的键。例如，给定一个map：

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

我们期望的输出是["first", "third"]，因为这两个键都关联着最大值50。

然而，初学者在使用Java 8 Stream API时，可能会尝试以下方法：

1. 获取单个最大值键：

   final String maxKey = map.entrySet()
       .stream()
       .max(Map.Entry.comparingByValue())
       .map(Map.Entry::getKey)
       .orElse(null);
   System.out.println(maxKey); // 输出可能是 "third" (取决于Stream内部顺序)

   这种方法只会返回一个具有最大值的键，因为它在遇到第一个最大值时可能就完成了比较，无法收集所有相同最大值的键。

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

2. 按值降序排序所有键：

   final List keysInDescending = map.entrySet()
       .stream()
       .sorted(Map.Entry.comparingByValue().reversed())
       .map(Map.Entry::getKey)
       .collect(Collectors.toList());
   System.out.println(keysInDescending); // 输出: [third, first, second]

   这种方法虽然能将所有键按值降序排列，但仍需要进一步处理才能提取出所有最大值对应的键，效率不高且不直观。

显然，以上方法都无法直接满足获取所有最大值键的需求。接下来，我们将介绍两种有效的解决方案。

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

此方法利用Stream API的强大功能，通过两次Stream操作实现目标。核心思想是首先将Map中的Entry按值进行分组，得到一个Map>，其中键是原始值，值是所有具有该值的键列表。然后，从这个分组后的Map中找出键（即原始值）最大的那个Entry，其值就是我们所需的最大值键列表。

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.groupingBy;
import static java.util.stream.Collectors.mapping;
import static java.util.stream.Collectors.toList;

public class MaxKeysCollector {

    public static List getMaxKeysUsingStream(Map map) {
        if (map == null || map.isEmpty()) {
            return new ArrayList<>(); // 或抛出异常，根据业务需求
        }

        return map.entrySet()
                .stream()
                // 步骤1: 按值分组，将相同值的键收集到列表中
                // 结果是 Map>，例如 {10=[second], 50=[first, third]}
                .collect(groupingBy(Map.Entry::getValue, mapping(Map.Entry::getKey, toList())))
                .entrySet()
                .stream()
                // 步骤2: 从分组后的Map中，找出键（即原始值）最大的那个Entry
                .max(Map.Entry.comparingByKey())
                // 如果Map为空或分组后为空，则抛出异常或返回默认值
                .orElseThrow(() -> new IllegalStateException("Map should not be empty"))
                .getValue(); // 获取该最大值Entry的值，即所有最大值对应的键列表
    }

    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); // 输出: Stream API 结果: [first, third] (顺序可能不同)
    }
}

代码解析：

1. map.entrySet().stream(): 创建一个Entry的Stream。
2. collect(groupingBy(Map.Entry::getValue, mapping(Map.Entry::getKey, toList()))): 这是核心步骤。
   • groupingBy(Map.Entry::getValue): 根据Entry的值进行分组。
   • mapping(Map.Entry::getKey, toList()): 在每个分组内部，将Entry的键映射并收集到一个List中。
   • 最终得到一个Map>，例如{10=[second], 50=[first, third], 20=[fourth]}。
3. .entrySet().stream(): 将上一步得到的Map再次转换为Entry的Stream。
4. .max(Map.Entry.comparingByKey()): 找出这个Stream中键（即原始值）最大的那个Entry。例如，它会找到Map.Entry>中键为50的那个Entry。
5. .orElseThrow().getValue(): 获取找到的最大值Entry的值，即List，其中包含了所有与最大值关联的键。orElseThrow()用于处理Map为空的情况，实际应用中可以替换为更友好的错误处理或返回空列表。

注意事项：

• 此方法涉及两次Stream操作，理论上会遍历数据两次。但第二次遍历的Map通常比原始Map小，因此性能影响可能不显著。
• 代码可读性较高，充分利用了Java 8 Stream API的声明式编程风格。

解决方案二：单次迭代的传统循环方法

对于追求极致性能的场景，或者在Java 8以下版本，传统的for循环方法可能更优，因为它只需要一次迭代即可完成任务。

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; // 初始化最大值为整型最小值

        if (map == null || map.isEmpty()) {
            return maxKeys;
        }

        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; // 更新最大值
            }

            // 如果当前值等于或大于已知的最大值，则将当前键添加到列表中
            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);

        List maxKeys = getMaxKeysUsingLoop(map);
        System.out.println("传统循环 结果: " + maxKeys); // 输出: 传统循环 结果: [first, third] (顺序可能不同)
    }
}

代码解析：

1. List maxKeys = new ArrayList();: 初始化一个空列表用于存储最大值对应的键。
2. int maxValue = Integer.MIN_VALUE;: 初始化一个变量maxValue为Integer的最小值，确保任何Map中的值都能被正确比较。
3. for (Map.Entry entry : map.entrySet()): 遍历Map中的每一个Entry。
4. 条件判断逻辑：
   • if (currentValue
   • if (currentValue > maxValue): 如果当前Entry的值大于当前已知的maxValue，这表示我们找到了一个新的更大的最大值。此时，需要清空maxKeys列表（因为之前的键不再是最大值），并更新maxValue。
   • maxKeys.add(currentKey): 如果当前Entry的值等于或大于当前的maxValue（在currentValue > maxValue分支处理后，这里的maxValue已经是最新的），则将当前键添加到maxKeys列表中。

性能优势：

• 此方法仅进行一次Map遍历，效率通常高于Stream API的两阶段处理。
• 内存使用也相对较低，因为它不需要创建中间的Map>。

总结与选择建议

选择建议：

• 对于大多数日常应用，推荐使用Stream API结合groupingBy的方法。 它的代码更简洁、更具声明性，且在现代JVM上性能通常足够好。
• 如果Map包含的数据量非常巨大，或者对性能有极致要求，应优先考虑传统循环方法。 它避免了中间集合的创建和多次迭代，从而减少了开销。

理解这两种方法及其优缺点，能帮助开发者根据具体的项目需求和性能考量，做出明智的技术选择。