List<Map>根据map字段排序

  1. 对map根据key进行正序/倒叙排序
  2. list根据指定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> list = initMapList();

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

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

    /**
     * List根据map字段排序
     *
     * @param list
     * @param feild 排序字段
     * @param sortTyp 排序方式 desc-倒序 asc-正序
     * @return
     */
    private static List> sortMapListByFeild(List> 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 sortMap(Map map, String sortTyp) {
        try {
            if (StringUtils.equals(sortTyp, "desc")) {

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

                Map 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 
     * @param 
     * @return
     */
	public static , V> Map sortByKey(Map map, boolean isDesc) {
        Map result = Maps.newLinkedHashMap();
        if (isDesc) {
            map.entrySet().stream().sorted(Map.Entry.comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

    private static List> initMapList() {
        List> lists = new ArrayList<>();

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

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

        Map 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,根据需要合理选取。

你可能感兴趣的:(java,工具类,java)