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

「爱情、让人受尽委屈。」 2023-10-02 20:41 66阅读 0赞

在我们的统计中经常会有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);
        }
    
    }

排序结果打印如下

![8651200aa7bf4810873ab6eecea07318.png][]

#### 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;
        }

[8651200aa7bf4810873ab6eecea07318.png]: https://img-blog.csdnimg.cn/8651200aa7bf4810873ab6eecea07318.png