Java Map 按照 Value 降序、Key 升序排序

对 LinkedHashMap 排序，先按 Value 降序，再按 Key 升序，是常见的排序需求。通过本文，你将掌握如何使用 Java 8 的 Stream API 和 Comparator 接口来实现这种复杂的排序逻辑。

使用链式调用

最直接的方法是使用链式调用，将 comparingByValue() 和 comparingByKey() 方法结合起来。关键在于显式指定泛型类型，帮助编译器进行类型推断。

import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class MapSort {

    public static void main(String[] args) {
        LinkedHashMap playersSkillsPoints = new LinkedHashMap<>();
        playersSkillsPoints.put("Alice", 100);
        playersSkillsPoints.put("Bob", 50);
        playersSkillsPoints.put("Charlie", 100);
        playersSkillsPoints.put("David", 75);
        playersSkillsPoints.put("Eve", 50);

        Map sortedMap = playersSkillsPoints.entrySet().stream()
                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())
                        .thenComparing(Map.Entry.comparingByKey()))
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (e1, e2) -> e1,
                        LinkedHashMap::new
                ));

        sortedMap.forEach((key, value) -> System.out.println(key + " : " + value));
    }
}

代码解释：

1. playersSkillsPoints.entrySet().stream(): 将 Map 转换为 Stream。
2. sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()).thenComparing(Map.Entry.comparingByKey())): 这是排序的核心部分。
   • Map.Entry.comparingByValue(Comparator.reverseOrder()): 首先按照 Value 降序排序。 关键在于 的显式类型声明，帮助编译器正确推断类型。 Comparator.reverseOrder() 确保降序排列。
   • .thenComparing(Map.Entry.comparingByKey()): 如果 Value 相同，则按照 Key 升序排序。
3. collect(Collectors.toMap(...)): 将排序后的 Stream 收集回一个 Map。 LinkedHashMap::new 确保排序后的顺序被保留。

注意事项：

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

析稿Ai写作

科研人的高效工具：AI论文自动生成，十分钟万字，无限大纲规划写作思路。

下载

• Collectors.toMap 方法需要提供一个 merge 函数 (e1, e2) -> e1 来处理 key 冲突的情况。 在此示例中，由于 Key 是唯一的，因此简单地选择第一个值即可。
• 确保使用 LinkedHashMap 来保持排序后的顺序。

先创建 Comparator 再组合

另一种方法是先创建单独的 Comparator，然后再将它们组合起来。 这种方法更易于阅读和维护，尤其是在排序逻辑比较复杂的情况下。

import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class MapSort {

    public static void main(String[] args) {
        LinkedHashMap playersSkillsPoints = new LinkedHashMap<>();
        playersSkillsPoints.put("Alice", 100);
        playersSkillsPoints.put("Bob", 50);
        playersSkillsPoints.put("Charlie", 100);
        playersSkillsPoints.put("David", 75);
        playersSkillsPoints.put("Eve", 50);

        Comparator> valueComparator = Map.Entry.comparingByValue(Comparator.reverseOrder());
        Comparator> keyComparator = Map.Entry.comparingByKey();

        Map sortedMap = playersSkillsPoints.entrySet().stream()
                .sorted(valueComparator.thenComparing(keyComparator))
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (e1, e2) -> e1,
                        LinkedHashMap::new
                ));

        sortedMap.forEach((key, value) -> System.out.println(key + " : " + value));
    }
}

代码解释：

1. Comparator> valueComparator = Map.Entry.comparingByValue(Comparator.reverseOrder());: 创建一个按照 Value 降序排序的 Comparator。
2. Comparator> keyComparator = Map.Entry.comparingByKey();: 创建一个按照 Key 升序排序的 Comparator。
3. sorted(valueComparator.thenComparing(keyComparator)): 使用 thenComparing 方法将两个 Comparator 组合起来。 先使用 valueComparator 排序，如果 Value 相同，则使用 keyComparator 排序。

总结：

这两种方法都可以实现按照 Value 降序、Key 升序排序 Map 的需求。 链式调用更简洁，但可读性稍差。 先创建 Comparator 再组合的方式更易于阅读和维护，尤其是在排序逻辑复杂的情况下。 选择哪种方法取决于个人偏好和代码的复杂程度。 关键在于理解 comparingByValue、comparingByKey 和 thenComparing 方法的用法，以及如何使用 Stream API 进行排序。