Java8 集合Map/list排序_java8 list<map>排序-优快云博客

本文链接：https://blog.youkuaiyun.com/WLPJLP/article/details/115395383

该博客展示了在Java8中如何使用Lambda表达式对Map按key和value进行正序和倒序排序，以及对List进行排序，简化了之前自定义比较器的复杂过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在java8之前排序一般是使用内部类自定义排序的方式实现的，在java8中使用lambda实现，示例如下：

@SuppressWarnings("ALL")
public class MyCollectionUtils {

    private MyCollectionUtils() {
    }

    /**
     * map根据key正序
     *
     * @param map 数据集合
     * @param <K> key 类型
     * @param <V> value 类型
     * @return 排序后的结果
     */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map) {
        return map.entrySet().stream().sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (m1, m2) -> m1, LinkedHashMap::new));
    }

    /**
     * map根据key倒序
     *
     * @param map 数据集合
     * @param <K> key 类型
     * @param <V> value 类型
     * @return 排序后的结果
     */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKeyReversed(Map<K, V> map) {
        return map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (m1, m2) -> m1, LinkedHashMap::new));
    }

    /**
     * map根据value正序
     *
     * @param map 数据集合
     * @param <K> key 类型
     * @param <V> value 类型
     * @return 排序后的结果
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
        return map.entrySet().stream().sorted(Map.Entry.comparingByValue())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (m1, m2) -> m1, LinkedHashMap::new));
    }

    /**
     * map根据value倒序
     *
     * @param map 数据集合
     * @param <K> key 类型
     * @param <V> value 类型
     * @return 排序后的结果
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueReversed(Map<K, V> map) {
        return map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue().reversed())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (m1, m2) -> m1, LinkedHashMap::new));
    }

    /**
     * list数据排序(正序)
     *
     * @param elements
     * @param <T>
     * @return
     */
    public static <T, U extends Comparable<? super U>> Iterable<? extends T> sortIterable(Collection<? extends T> collection,
                                                                                          Function<? super T, ? extends U> keyExtractor) {
        return collection.stream().sorted(Comparator.comparing(keyExtractor)).collect(Collectors.toList());
    }

    /**
     * list数据排序(倒序序)
     *
     * @param elements
     * @param <T>
     * @return
     */
    public static <T, U extends Comparable<? super U>> Iterable<? extends T> sortIterableReversed(Collection<? extends T> collection,
                                                                                                  Function<? super T, ? extends U> keyExtractor) {
        return collection.stream().sorted(Comparator.comparing(keyExtractor).reversed()).collect(Collectors.toList());
    }
}