List＜Map＞根据map字段排序

1. 对map根据key进行正序/倒叙排序
2. 对list<map>根据指定map的key进行正序/倒叙排序

package yulisao.test;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.*;

/**
 * @author yulisao
 * @createDate 2022/3/20  0020下午 11:34
 */
public class MapListSort {

    public static void main(String[] args) {
        String sortTyp = "asc"; // desc-倒叙  asc-正序
        // 组装测试数据
        List<Map<String, Object>> list = initMapList();

        // 单个map排序
        Map<String, Object> map = list.get(0);
        Map<String, Object> sortMap = sortMap(map, sortTyp);
        // Map<String, Object> sortMap = sortByKey(map, false);
        for (Map.Entry<String, Object> entry : sortMap.entrySet()) {
            System.out.println("单个map排序"+sortTyp);
            System.out.println(entry.getKey());
        }

        // List<map>根据某个字段排序
        sortMapListByFeild(list, "age", sortTyp);
        System.out.println("按年纪取最大的一条数据，其姓名是：" + list.get(0).get("name"));
    }

    /**
     * List<Map>根据map字段排序
     *
     * @param list
     * @param feild 排序字段
     * @param sortTyp 排序方式 desc-倒序 asc-正序
     * @return
     */
    private static List<Map<String, Object>> sortMapListByFeild(List<Map<String, Object>> list, String feild, String sortTyp) {
        if (CollectionUtils.isNotEmpty(list)) {
            // 方法1
            list.sort((m1, m2) -> {
                if (StringUtils.equals(sortTyp, "desc")) {
                    return String.valueOf(m2.get(feild)).compareTo(String.valueOf(m1.get(feild)));
                } else {
                    return String.valueOf(m1.get(feild)).compareTo(String.valueOf(m2.get(feild)));
                }
            });

            // 方法2 也ok噢
            /*if (StringUtils.equals(sortTyp, "desc")) {
                Collections.sort(list, (m1, m2)-> String.valueOf(m2.get(feild)).compareTo(String.valueOf(m1.get(feild)))); // lamuda排序
            } else {
                Collections.sort(list, (m1, m2)-> String.valueOf(m1.get(feild)).compareTo(String.valueOf(m2.get(feild)))); // lamuda排序
            }*/
        }

        return list;
    }

    /**
     * map排序
     * @param map
     * @return
     */
    public static Map<String, Object> sortMap(Map<String, Object> map, String sortTyp) {
        try {
            if (StringUtils.equals(sortTyp, "desc")) {

                Set<String> sortSet = new TreeSet<>(Comparator.reverseOrder()); // 定义个倒叙的set
                sortSet.addAll(map.keySet()); // 获取全部key，添加后就自然倒序了

                Map<String, Object> resp = new LinkedHashMap<>();
                for (String key :sortSet) {
                    resp.put(key, map.get(key)); // 按顺序放入新map
                }

                return resp;
            } else {
                return new TreeMap<>(map); // TreeMap 本身就是正序的
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }
    
	/**
     * 根据map的key排序
     * @param map 待排序的map
     * @param isDesc 是否降序，true：降序，false：升序
     * @param <K>
     * @param <V>
     * @return
     */
	public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean isDesc) {
        Map<K, V> result = Maps.newLinkedHashMap();
        if (isDesc) {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

    private static List<Map<String, Object>> initMapList() {
        List<Map<String, Object>> lists = new ArrayList<>();

        Map<String, Object> map = new HashMap<>();
        map.put("name", "王五");
        map.put("age", 55);
        map.put("mobile", "15900001112");
        lists.add(map);

        Map<String, Object> map1 = new HashMap<>();
        map1.put("name", "李四");
        map1.put("age", 18);
        map1.put("mobile", "15900001111");
        lists.add(map1);

        Map<String, Object> map2 = new HashMap<>();
        map2.put("name", "赵六");
        map2.put("age", 58);
        map2.put("mobile", "13700001111");
        lists.add(map2);

        return lists;
    }
}

这个ListMap排序仍是借助jdk包里面的方法实现，同样的如果list的元素类型是字符串、javabean等等， 修改一下compareTo两边要比较的对象即可

至于map的排序

• HashMap是无序的。
• TreeMap是按照key升序的
• LinkedHashMap是按照插入的顺序展示的

Map可以=new 他们三者任意一个，如果要求按key自动排序就new TreeMap，要求按key自定义排序就new LinkedHashMap， 没要求就可以new HashMap，根据需要合理选取。