排序 (1) : map排序

最新推荐文章于 2024-04-07 10:48:45 发布

转载最新推荐文章于 2024-04-07 10:48:45 发布 · 403 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://blog.youkuaiyun.com/ecjtuhq/article/details/83303106

文章标签：

#排序 #map

Java 专栏收录该内容

66 篇文章

订阅专栏

本文详细介绍如何在Java中对Map集合进行排序，包括按key、value排序的方法，支持字符串和数字类型的排序，同时提供了升序和降序的实现方式。

参考 :

https://blog.youkuaiyun.com/ecjtuhq/article/details/83303106

https://www.cnblogs.com/avivahe/p/5657070.html

注 : 数字类型使用String类型排序无效


import java.util.*;

/**
 * @Auther: liyue
 * @Date: 2019/2/25 11:08
 * @Description: map排序
 */
public class MapSortUtil {

    public static final String DESC = "desc";

    public static final String ASC = "asc";

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        /*map.put("5", "s1");
        map.put("3", "s3");
        map.put("1", "s5");
        map.put("2", "s4");
        map.put("6", "s6");
        map.put("4", "s2");*/

        map.put("m1", "1");
        map.put("m2", "3");
        map.put("m3", "5");
        map.put("m4", "4");
        map.put("m5", "6");
        map.put("m6", "2");

        sortByValueIgnoreCase(map, ASC).forEach((k, v) -> {
            System.err.println(k + ":" + v);
        });
    }

    /**
     * 根据key排序
     *
     * @param map
     * @param rule : asc(升序),desc(降序)
     * @return
     */
    public static Map<String, String> sortByKey(Map<String, String> map, String rule) {
        if (map == null || map.isEmpty()) {
            return null;
        }

        Map<String, String> sortMap = null;
        if (rule.equalsIgnoreCase(ASC)) {
            sortMap = new TreeMap<>((str1, str2) -> str1.compareTo(str2));
        } else {
            sortMap = new TreeMap<>((str1, str2) -> str2.compareTo(str1));
        }
        sortMap.putAll(map);
        return sortMap;
    }


    /**
     * 根据key排序(忽略大小写)
     *
     * @param rule : asc(升序),desc(降序)
     * @param map
     * @return
     */
    public static Map<String, String> sortByKeyIgnoreCase(Map<String, String> map, String rule) {
        if (map == null || map.isEmpty()) {
            return null;
        }

        Map<String, String> sortMap = null;
        if (rule.equalsIgnoreCase(ASC)) {
            sortMap = new TreeMap<>((str1, str2) -> str1.toLowerCase().compareTo(str2.toLowerCase()));
        } else {
            sortMap = new TreeMap<>((str1, str2) -> str2.toLowerCase().compareTo(str1.toLowerCase()));
        }
        sortMap.putAll(map);
        return sortMap;
    }

    /**
     * 根据value排序
     *
     * @param oriMap
     * @param rule   : asc(升序),desc(降序)
     * @return
     */
    public static Map<String, String> sortByValue(Map<String, String> oriMap, String rule) {
        if (oriMap == null || oriMap.isEmpty()) {
            return null;
        }

        Map<String, String> sortedMap = new LinkedHashMap<>();
        List<Map.Entry<String, String>> entryList = new ArrayList<>(oriMap.entrySet());
        if (rule.equalsIgnoreCase(ASC)) {
            Collections.sort(entryList, (me1, me2) -> me1.getValue().compareTo(me2.getValue()));
        } else {
            Collections.sort(entryList, (me1, me2) -> me2.getValue().compareTo(me1.getValue()));
        }

        Iterator<Map.Entry<String, String>> iterator = entryList.iterator();
        Map.Entry<String, String> tmpEntry;
        while (iterator.hasNext()) {
            tmpEntry = iterator.next();
            sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
        }
        return sortedMap;
    }

    /**
     * 根据value排序(忽略大小写)
     *
     * @param oriMap
     * @param rule   : asc(升序),desc(降序)
     * @return
     */
    public static Map<String, String> sortByValueIgnoreCase(Map<String, String> oriMap, String rule) {
        if (oriMap == null || oriMap.isEmpty()) {
            return null;
        }

        Map<String, String> sortedMap = new LinkedHashMap<>();
        List<Map.Entry<String, String>> entryList = new ArrayList<>(oriMap.entrySet());
        if (rule.equalsIgnoreCase(ASC)) {
            Collections.sort(entryList, (me1, me2) -> me1.getValue().toLowerCase().compareTo(me2.getValue().toLowerCase()));
        } else {
            Collections.sort(entryList, (me1, me2) -> me2.getValue().toLowerCase().compareTo(me1.getValue().toLowerCase()));
        }

        Iterator<Map.Entry<String, String>> iterator = entryList.iterator();
        Map.Entry<String, String> tmpEntry;
        while (iterator.hasNext()) {
            tmpEntry = iterator.next();
            sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
        }
        return sortedMap;
    }


    /**
     * 根据value排序(数字)
     *
     * @param oriMap
     * @param rule   : asc(升序),desc(降序)
     * @return
     */
    public static Map<String, Integer> sortByValueInteger(Map<String, Integer> oriMap, String rule) {
        if (oriMap == null || oriMap.isEmpty()) {
            return null;
        }

        Map<String, Integer> sortedMap = new LinkedHashMap<>();
        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(oriMap.entrySet());
        if (rule.equalsIgnoreCase(ASC)) {
            Collections.sort(entryList, (me1, me2) -> me1.getValue().compareTo(me2.getValue()));
        } else {
            Collections.sort(entryList, (me1, me2) -> me2.getValue().compareTo(me1.getValue()));
        }

        Iterator<Map.Entry<String, Integer>> iterator = entryList.iterator();
        Map.Entry<String, Integer> tmpEntry;
        while (iterator.hasNext()) {
            tmpEntry = iterator.next();
            sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
        }
        return sortedMap;
    }


    /**
     * 根据key排序(数字)
     *
     * @param map
     * @param rule : asc(升序),desc(降序)
     * @return
     */
    public static Map<Integer, String> sortByKeyInteger(Map<Integer, String> map, String rule) {
        if (map == null || map.isEmpty()) {
            return null;
        }

        Map<Integer, String> sortMap = null;
        if (rule.equalsIgnoreCase(ASC)) {
            sortMap = new TreeMap<>((str1, str2) -> str1.compareTo(str2));
        } else {
            sortMap = new TreeMap<>((str1, str2) -> str2.compareTo(str1));
        }
        sortMap.putAll(map);
        return sortMap;
    }
}

END。