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

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

示例代码如下：

package demo.springboot.web;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * @author cx.hao
 * @date 2019/6/26 15:29
 */
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类包含内容很明显

package demo.springboot.web;

/**
 * @author cx.hao
 * @date 2019/6/6 11:46
 */
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;
    }
}

运行以后输出结果如下：

 是不是满足了上述的排序要求呢？

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

 

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

package demo.springboot.web;

import java.util.*;

/**
 * @author cx.hao
 * @date 2019/6/26 15:55
 */
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);
    }
}

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