如何对List＜Map＜String, Object＞＞进行排序

在我们的统计中经常会有List<Map<String, Object>>格式的数据，但是我们需要对这种数据进行排序，我们可以使用Comparator撰写工具类对其排序

1.对List＜Map＜String, Object＞＞进行排序

对于需要对Map集合某一键值进行排序，可以自己撰写如下代码，对我们的List＜Map＜String, Object＞＞进行排序，得到排序好的List＜Map＜String, Object＞＞，只需要传入需要排序的list以及需要排序的字段，即可完成排序

/**
 * @author wangli
 * @create 2022-08-18 17:51
 */
public class  SortUtil {
    /**
     * 对List<Map<String, Object>>中int类型的字段排序
     * @param data 包含key为sort,value为desc,asc的map
     * @param yList 需要排序的list
     * @param type 需要排序的字段
     * @return 返回排序后的List<Map<String, Object>>
     */
    public static List<Map<String, Object>> sortMap(Map<String, Object> data, List<Map<String, Object>> yList, String type) {
        if (Objects.equals(data.get("sort"), "asc")) {
            yList.sort(Comparator.comparingInt(o -> Integer.parseInt(o.get(type).toString())));
            return yList;
        } else {
            Collections.sort(yList, (o1, o2) -> Integer.parseInt(o2.get(type).toString()) - Integer.parseInt(o1.get(type).toString()));
        }
        return yList;
    }
    /**
     * 对List<Map<String, Object>>中double类型的字段排序
     * @param data 包含key为sort,value为desc,asc的map
     * @param yList 需要排序的list
     * @param type 需要排序的字段
     * @return 返回排序后的List<Map<String, Object>>
     */
    public static List<Map<String, Object>> sortDoubleMap(Map<String, Object> data, List<Map<String, Object>> yList, String type) {
        if (Objects.equals(data.get("sort"), "asc")) {
            yList.sort(Comparator.comparingDouble(o -> Double.parseDouble(o.get(type).toString())));
            return yList;
        } else {
            Collections.sort(yList, (o1, o2) -> {
                Double a = Double.parseDouble(o2.get(type).toString());
                Double b = Double.parseDouble(o1.get(type).toString());
                if (a > b) {
                    return 1;
                }
                return -1;
            });
        }
        return yList;
    }

}

创建测试方法，生成一些数据，对我们撰写的方法进行测试，测试demo如下

public class TestProject {
    @Test
    public void test1(){
        ArrayList<Map<String, Object>> maps = new ArrayList<>();
        for (int i = 0; i <3; i++) {
            HashMap<String, Object> map = new HashMap<>();
            map.put("count",i*2+1);
            maps.add(map);
        }
        HashMap<String, Object> data = new HashMap<>();
        data.put("sort","desc");
        maps.stream().forEach(System.out::println);
        List<Map<String, Object>> list = SortUtil.sortMap(data, maps, "count");
        maps.stream().forEach(System.out::println);
    }

}

 排序结果打印如下

2.对List＜List＜String＞＞进行排序

    /**
     * @param data 输入需要排序的参数
     * @param yList 需要排序的List<List<String>>
     * @param s 需要过滤不排序的信息
     * @param i list中需要排序的第几个字段
     * @return 排序后的List<List<String>>
     */
    public static List<List<String>> sortContainList(Map<String, Object> data, List<List<String>> yList,String s,int i) {
        if (Objects.equals(data.get("sort"), "asc")) {
            yList.sort(Comparator.comparingInt(o -> Integer.parseInt(o.get(i))));
            return yList;
        } else {
            Collections.sort(yList, (o1, o2) -> {
                if (o1.get(i).equals(s)||o2.get(i).equals(s)){
                    return 1;
                }else {
                    return Integer.parseInt(o2.get(i)) - Integer.parseInt(o1.get(i));
                }
            });
        }
        return yList;
    }

3.传入对象集合转换为List<Map<String,Object>>

我们在工作中有很多时候需要将List<User>转换为List<Map<String,Object>>这种格式的需求，所以我们可以调用如下方法，针对业务进行修改，完成转化过程。

    /**
     * 传入list对象转换为List<Map<String,Object>>
     * @param list 传入对象集合
     * @return 返回map集合
     */
    public static  List<Map<String,Object>> entityConvertMap(List<?> list){
        List<Map<String,Object>> l = new LinkedList<>();
        try {
            for(Object t : list){
                Map<String,Object> map = new HashMap<>();
                Method[] methods = t.getClass().getMethods();
                for (Method method : methods) {
                    if (method.getName().startsWith("get")) {
                        String name = method.getName().substring(3);
                        name = name.substring(0, 1).toLowerCase() + name.substring(1);
                        Object value = method.invoke(t);
                        if (value!=null&&!name.equals("version")&&!name.equals("class")){
                            map.put(name,value);
                        }
                    }
                }
                l.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return l;
    }

4.Map的value值排序

在工作中有很多地方需要对Map的value值进行排，我们只需要导入这个方法传入需要排序的Map获取排序好的Map即可

    // Map的value值降序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortDescend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return -compare;
            }
        });

        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }

    // Map的value值升序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortAscend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<Map.Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return compare;
            }
        });

        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }