整理的一份Map排序操作 根据key或value排序

一、通过自己实现Comparator接口排序

根据key进行排序

    /**
     * 对Map按key进行排序
     * @param map   等待排序的map
     * @param isAsc true: 升序，false: 降序
     * @return      排序后的map
     */
    public static Map<String, String> sortMapByStrKey(Map<String, String> map, boolean isAsc) {
        if (MapUtils.isEmpty(map)) {
            // 这样调用方法的地方就不用担心空指针了
            return Maps.newHashMap();
        }
        // TreeMap默认按key升序排序
        Map<String, String> sortMap = new TreeMap<>(new MapKeyComparator(isAsc));
        sortMap.putAll(map);
        return sortMap;
    }

    private static class MapKeyComparator implements Comparator<String> {
        private boolean isAsc;

        MapKeyComparator(boolean isAsc) {
            this.isAsc = isAsc;
        }

        @Override
        public int compare(String o1, String o2) {
            return isAsc ? o1.compareTo(o2) : o2.compareTo(o1);
        }
    }

二、通过stream.sorted()和list.sort()方法来排序

根据value进行排序

    /**
     * 对Map按value排序（升序）
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueAsc(Map<K, V> map) {
        if (MapUtils.isEmpty(map)) {
            // 这样调用方法的地方就不用担心空指针了
            return Maps.newHashMap();
        }
        // LinkedHashMap可以通过构造方法指定是按放入的顺序，还是get顺序 排序
        Map<K, V> result = Maps.newLinkedHashMap();
        Stream<Map.Entry<K, V>> st = map.entrySet().stream();
        st.sorted(Comparator.comparing(Map.Entry::getValue)).forEach(e -> result.put(e.getKey(), e.getValue()));
        return result;
    }

    /**
     * 对Map按value排序（降序）
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueDesc(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new LinkedList<>(map.entrySet());
        // 同理 o1， o2换一下就是升序排序了
        list.sort((o1, o2) -> (o2.getValue()).compareTo(o1.getValue()));

        Map<K, V> result = new LinkedHashMap<>();
        list.forEach(kvEntry -> result.put(kvEntry.getKey(), kvEntry.getValue()));
        return result;
    }

三、通过jdk8流式操作进行排序

根据key或value进行排序

    /**
     * 根据key对map进行排序
     *
     * @param map 等待排序的map
     * @param asc true: 升序，false: 降序
     * @param <K> key的类型
     * @param <V> value的类型
     * @return    排序后的map
     */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortMapByKey(Map<K, V> map, boolean asc) {
        Map<K, V> result = Maps.newLinkedHashMap();
        if (asc) {
            map.entrySet().stream().sorted(Map.Entry.comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

    /**
     * 根据value对map进行排序
     *
     * @param map 等待排序的map
     * @param asc true: 升序，false: 降序
     * @param <K> key的类型
     * @param <V> value的类型
     * @return    排序后的map
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortMapByValue(Map<K, V> map, boolean asc) {
        Map<K, V> result = Maps.newLinkedHashMap();
        if (asc) {
            map.entrySet().stream().sorted(Map.Entry.comparingByValue())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

小结

使用时可根据需要作出修改