在 Java 8 中获取 Map 中所有最大值对应的键列表教程

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

// 只能获取一个最大值对应的键
final String maxKey = map.entrySet()
    .stream()
    .max(Map.Entry.comparingByValue())
    .map(Map.Entry::getKey)
    .orElse(null);

System.out.println(maxKey); // 可能会输出 "third" 或 "first"，取决于内部迭代顺序

// 返回所有键，按值降序排列
final List<String> keysInDescending = map.entrySet()
    .stream()
    .sorted(Map.Entry.<String,Integer>comparingByValue().reversed())
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());

System.out.println(keysInDescending); // 输出 [third, first, second]

import java.util.List;
import java.util.Map;
import java.util.HashMap;
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<String> getMaxKeysUsingStreams(Map<String, Integer> map) {
        if (map == null || map.isEmpty()) {
            return List.of(); // 返回空列表或抛出异常，取决于业务需求
        }

        return map.entrySet()
                .stream()
                // 1. 按值进行分组：Map<Integer, List<String>>
                // 键是值（Integer），值是所有映射到该值的键列表（List<String>）
                .collect(groupingBy(Map.Entry::getValue, mapping(Map.Entry::getKey, toList())))
                .entrySet()
                .stream()
                // 2. 找到分组Map中键（即原始值）最大的那个条目
                .max(Map.Entry.comparingByKey())
                // 3. 如果Map为空，orElseThrow()会抛出NoSuchElementException。
                // 更好的做法是处理Optional为空的情况，例如返回一个空列表。
                .orElseThrow(() -> new IllegalStateException("Map is empty or contains no entries."))
                // 4. 获取该最大条目中的值，即对应的键列表
                .getValue();
    }

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

        List<String> maxKeys = getMaxKeysUsingStreams(map);
        System.out.println("Stream API 方案结果: " + maxKeys); // 输出: Stream API 方案结果: [first, third] (顺序可能不同)
    }
}

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

public class MaxKeysCollectorOptimized {

    public static List<String> getMaxKeysOptimized(Map<String, Integer> map) {
        List<String> maxKeys = new ArrayList<>();
        int maxValue = Integer.MIN_VALUE; // 初始化为Integer的最小值，确保任何Map值都能被正确比较

        if (map == null || map.isEmpty()) {
            return maxKeys; // 返回空列表
        }

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            int currentValue = entry.getValue();

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

            if (currentValue > maxValue) {
                // 发现了一个新的更大的值
                maxKeys.clear(); // 清空之前收集的键，因为它们不再是最大值
                maxValue = currentValue; // 更新最大值
            }
            // 如果 currentValue == maxValue，则将当前键添加到列表中
            // 如果 currentValue > maxValue，在清空后，也需要将当前键添加
            maxKeys.add(entry.getKey());
        }
        return maxKeys;
    }

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

        List<String> maxKeys = getMaxKeysOptimized(map);
        System.out.println("单次迭代优化方案结果: " + maxKeys); // 输出: 单次迭代优化方案结果: [first, third] (顺序可能不同)
    }
}