对 LinkedHashMap
使用链式调用
最直接的方法是使用链式调用，将 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<String, Integer> playersSkillsPoints = new LinkedHashMap<>();
playersSkillsPoints.put("Alice", 100);
playersSkillsPoints.put("Bob", 50);
playersSkillsPoints.put("Charlie", 100);
playersSkillsPoints.put("David", 75);
playersSkillsPoints.put("Eve", 50);
Map<String, Integer> sortedMap = playersSkillsPoints.entrySet().stream()
.sorted(Map.Entry.<String, Integer>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));
}
}代码解释：
- playersSkillsPoints.entrySet().stream(): 将 Map 转换为 Stream。
- sorted(Map.Entry.
comparingByValue(Comparator.reverseOrder()).thenComparing(Map.Entry.comparingByKey())): 这是排序的核心部分。 - Map.Entry.
comparingByValue(Comparator.reverseOrder()): 首先按照 Value 降序排序。 关键在于 的显式类型声明，帮助编译器正确推断类型。 Comparator.reverseOrder() 确保降序排列。 - .thenComparing(Map.Entry.comparingByKey()): 如果 Value 相同，则按照 Key 升序排序。
- Map.Entry.
- collect(Collectors.toMap(...)): 将排序后的 Stream 收集回一个 Map。 LinkedHashMap::new 确保排序后的顺序被保留。
注意事项：
立即学习“Java免费学习笔记（深入）”；
- 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<String, Integer> playersSkillsPoints = new LinkedHashMap<>();
playersSkillsPoints.put("Alice", 100);
playersSkillsPoints.put("Bob", 50);
playersSkillsPoints.put("Charlie", 100);
playersSkillsPoints.put("David", 75);
playersSkillsPoints.put("Eve", 50);
Comparator<Map.Entry<String, Integer>> valueComparator = Map.Entry.comparingByValue(Comparator.reverseOrder());
Comparator<Map.Entry<String, Integer>> keyComparator = Map.Entry.comparingByKey();
Map<String, Integer> 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));
}
}代码解释：
- Comparator
> valueComparator = Map.Entry.comparingByValue(Comparator.reverseOrder());: 创建一个按照 Value 降序排序的 Comparator。 - Comparator
> keyComparator = Map.Entry.comparingByKey();: 创建一个按照 Key 升序排序的 Comparator。 - sorted(valueComparator.thenComparing(keyComparator)): 使用 thenComparing 方法将两个 Comparator 组合起来。 先使用 valueComparator 排序，如果 Value 相同，则使用 keyComparator 排序。
总结：
这两种方法都可以实现按照 Value 降序、Key 升序排序 Map 的需求。 链式调用更简洁，但可读性稍差。 先创建 Comparator 再组合的方式更易于阅读和维护，尤其是在排序逻辑复杂的情况下。 选择哪种方法取决于个人偏好和代码的复杂程度。 关键在于理解 comparingByValue、comparingByKey 和 thenComparing 方法的用法，以及如何使用 Stream API 进行排序。
