一个List按照另一个List的数据顺序来排序

客官°小女子只卖身不卖艺 2023-10-07 23:35 65阅读 0赞

平时我们一般都是直接按照一定的规则，在sql查询返回结果的时候，就返回特定排列顺序的List结果。例如order by createtime desc； 这样的排序结果一般都是数据库中已有的字段的，比较好排序。 但是，有时候会有要求，一个list orderRegulation设置顺序，另一个list targetList按照规则排列自身的顺序。这样就很难在mysql中直接写出排序规则，直接输出，需要我们在代码中进行实现。 下面是我参考一些资料，做了部分排序算法的优化来输出我们想要的结果。 该排序适用于数据内容一致（类型一致），顺序不相同的情况。 targetList中多出来的数据，排在新的List数组的最后。  
示例代码如下：

public class ListOrder {
        
        public static void main(String[] args) {
        
     
            List<String> orderRegulation = Arrays.asList("G102", "G103", "G108", "29", "28", "25", "24", "G109", "G105", "26", "21");
            List<Posts> targetList = new ArrayList<Posts>();
     
            Posts post3 = new Posts();
            post3.setId("G102");
            post3.setName("xiaoli3");
            post3.setAge("23");
     
            Posts post2 = new Posts();
            post2.setId("G103");
            post2.setName("xiaoli2");
            post2.setAge("22");
     
            Posts post4 = new Posts();
            post4.setId("G109");
            post4.setName("xiaoli4");
            post4.setAge("25");
     
            Posts post7 = new Posts();
            post7.setId("G107");
            post7.setName("xiaoli7");
            post7.setAge("21");
     
            Posts post8 = new Posts();
            post8.setId("G101");
            post8.setName("xiaoli8");
            post8.setAge("26");
     
            Posts post5 = new Posts();
            post5.setId("G105");
            post5.setName("xiaoli5");
            post5.setAge("27");
     
            Posts post1 = new Posts();
            post1.setId("G104");
            post1.setName("xiaoli1");
            post1.setAge("29");
     
            Posts post6 = new Posts();
            post6.setId("G106");
            post6.setName("xiaoli6");
            post6.setAge("23");
     
            Posts post9 = new Posts();
            post9.setId("G106");
            post9.setName("xiaoli9");
            post9.setAge("25");
     
            Posts post10 = new Posts();
            post10.setId("G104");
            post10.setName("xiaoli10");
            post10.setAge("28");
     
            targetList.add(post1);
            targetList.add(post2);
            targetList.add(post3);
            targetList.add(post4);
            targetList.add(post5);
            targetList.add(post6);
            targetList.add(post7);
            targetList.add(post8);
            targetList.add(post9);
            targetList.add(post10);
            System.out.println("排列前的数据：");
            targetList.forEach(t -> System.out.print(t.getId() + t.getName() + "~" + t.getAge() + "  "));
            System.out.println();
     
            setListOrder(orderRegulation, targetList);
     
            System.out.println("排序的规则：");
            orderRegulation.forEach(t -> System.out.print(t + " "));
            System.out.println();
            System.out.println("排列后的数据：");
            targetList.forEach(t -> System.out.print(t.getId() + t.getName() + "~" + t.getAge() + " "));
     
        }
     
        //平时排序可使用其中一种，下面是综合两个条件排序
        public static void setListOrder(List<String> orderRegulation, List<Posts> targetList) {
        
            //按照Posts的Id来排序
            Collections.sort(targetList, ((o1, o2) -> {
        
                int io1 = orderRegulation.indexOf(o1.getId());
                int io2 = orderRegulation.indexOf(o2.getId());
     
                if (io1 != -1) {
        
                    io1 = targetList.size() - io1;
                }
                if (io2 != -1) {
        
                    io2 = targetList.size() - io2;
                }
     
                return io2 - io1;
            }));
     
            //按照Posts的age来排序
            Collections.sort(targetList, ((o1, o2) -> {
        
                int io1 = orderRegulation.indexOf(o1.getAge());
                int io2 = orderRegulation.indexOf(o2.getAge());
     
                if (io1 != -1) {
        
                    io1 = targetList.size() - io1;
                }
                if (io2 != -1) {
        
                    io2 = targetList.size() - io2;
                }
     
                return io2 - io1;
            }));
        }
    }

其中的Posts类包含内容很明

public class Posts {
        
        private String id;
        private String name;
        private String age;
     
        public String getId() {
        
            return id;
        }
     
        public void setId(String id) {
        
            this.id = id;
        }
     
        public String getName() {
        
            return name;
        }
     
        public void setName(String name) {
        
            this.name = name;
        }
     
        public String getAge() {
        
            return age;
        }
     
        public void setAge(String age) {
        
            this.age = age;
        }
    }

运行以后输出结果如下：  
![在这里插入图片描述][058447860eed4ffdbb167e21016d6a56.png_pic_center]

在这里，做了两次排序。 第一次是按照Posts的id进行排序，targetList 会根据 orderRegulation的顺序不同有个排序结果；第二次，又会在上述的排序结果的基础上，根据Posts的age进行新一轮的排序。 因此最后结果如上，首先根据第二轮的排序规则，再按照第一轮的规则，两种参考规则都不包含的数据在最后展示。

当然，如果你们的排序要求没有这么复杂，可以参考下面的示例来进行排序，注意：下面的排序结果未设置顺序的部分展示在最前面。

public class SetSort {
        
     
        /**
         * 设置顺序
         *
         * @Des 一个list orderRegulation设置顺序，另一个list targetList按照规则排列自身的顺序，
        如果targetList的数据比 orderRegulation的数据多，多出来的那部分数据，按照原来的顺序，且排在开头
        结果即 7 9 6 8（未设置顺序的部分） +  0 1 2 3 4 5（排序部分）
         @适用点： 1. 数据内容一致，只是顺序不同
         2. orderRegulation的数据内容 包含 targetList的内容
          * @param orderRegulation
         * @param targetList
         */
        public static void setListOrder(List<Integer> orderRegulation,  List<Integer> targetList){
        
            Collections.sort(targetList,((o1, o2) -> {
        
                int io1 = orderRegulation.indexOf(o1);
                int io2 = orderRegulation.indexOf(o2);
                return io1 - io2;
            }));
     
            System.out.println("规则数据：");
            orderRegulation.forEach(t-> System.out.print(t+" " ));
            System.out.println();
            System.out.println("排列后的数据：");
            targetList.forEach(t-> System.out.print(t+" " ));
        }
     
        public static void sortUp(List<Integer> list){
        
            if (null != list && !list.isEmpty()){
        
                Collections.sort(list, Comparator.comparingInt(x -> x));
     
                System.out.println("\n sortUp 小-大");
                list.forEach(t-> System.out.print(t+" " ));
            }
        }
     
        public static void sortDown(List<Integer> list){
        
            if (null != list && !list.isEmpty()){
        
                Collections.sort(list, (x, y)-> y - x );
     
                System.out.println("\n sortDown 大-小");
                list.forEach(t-> System.out.print(t+" " ));
            }
        }
     
        public static void main(String[] args) {
        
            List<Integer> orderRegulation = Arrays.asList(0,1,2,3,4,5);
            List<Integer> targetList  = Arrays.asList(1,3,5,7,9,2,4,6,8,0);
     
            SetSort.setListOrder(orderRegulation,targetList);
     
            sortUp(targetList);
     
            sortDown(targetList);
        }
    }

最后的运行结果截图如下：

![在这里插入图片描述][a48b47c181e8404a824c0a44d2b572b2.png_pic_center]

[058447860eed4ffdbb167e21016d6a56.png_pic_center]: https://img-blog.csdnimg.cn/058447860eed4ffdbb167e21016d6a56.png#pic_center
[a48b47c181e8404a824c0a44d2b572b2.png_pic_center]: https://img-blog.csdnimg.cn/a48b47c181e8404a824c0a44d2b572b2.png#pic_center