List集合的合并和排序

List集合的合并和排序

本篇文章涉及到的基本知识点：List集合的合并，LocalDateTime类型数据的比较，Stream流的简单使用，Collections集合工具类的排序。

常规排序

使用List集合的默认排序方法

List<String> list = new LinkedList<String>();
        list.add("25");
        list.add("250");
        list.add("10");
        list.add("9");
        list.add("3");
        System.out.println("--------排序前---------");
        for (String s : list) {
            System.out.println(s);
        }
        Collections.sort(list);
        System.out.println("--------排序后---------");
        for (String s : list) {
            System.out.println(s);
        }

输出：
--------排序前---------
[25, 250, 10, 7, 1]
--------排序后---------
[10, 250, 25, 1, 7]

可以看到并没有按照我们预期中的结果进行排序，这是由于默认的排序方法是默认字符串的首字母的ASCII码大小进行排序的。想要达到预期的效果，我们需要自定义排序方式。

//升序排列
Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int i = Integer.parseInt(o1);
                int j = Integer.parseInt(o2);
                if (i > j){
                    return 1;
                } else if (i == j){
                    return 0;
                }else {
                    return -1;
                }
            }
        });
        System.out.println(list);

//降序排列
Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int i = Integer.parseInt(o1);
                int j = Integer.parseInt(o2);
                if (i > j){
                    return -1;
                } else if (i == j){
                    return 0;
                }else {
                    return 1;
                }
            }
        });
        System.out.println(list);

输出结果
升序：[3, 9, 10, 15, 123]
降序：[123, 15, 10, 9, 3]

不难看出，重写compare方法后，可以达到自定义排序规则的效果。compare方法中的两个参数中前者是当前元素，后者是下一个元素，当两者进行比较时，前者大于后者时返回1就会进行升序排列，也就是将两数的顺序调换。

对象List集合中的排序

LinkedList<Help> list = new LinkedList<>();
        list.add(new Help().setUserId(1));
        list.add(new Help().setUserId(7));
        list.add(new Help().setUserId(4));
        list.add(new Help().setUserId(6));
        System.out.println(list);
        Collections.sort(list, new Comparator<Help>() {
            @Override
            public int compare(Help o1, Help o2) {
                //升序排列
                if (o1.getUserId() > o2.getUserId()){
                    return 1;
                } else if (o1.getUserId() == o2.getUserId()){
                    return 0;
                } else {
                    return -1;
                }
            }
        });
        System.out.println(list);

关于集合中的对象排序，需要获取到可以排序的字段，重写compare方法将可以自定义排序规则的字段提取出来单独排序。

两个List集合合并并按集合中对象的属性排序

List<Help> list1 = new LinkedList<>();
        list1.add(new Help().setUserId(1));
        list1.add(new Help().setUserId(20));
        list1.add(new Help().setUserId(4));
        list1.add(new Help().setUserId(15));
        List<Help> list2 = new LinkedList<>();
        list2.add(new Help().setUserId(3));
        list2.add(new Help().setUserId(7));
        list2.add(new Help().setUserId(30));
        list2.add(new Help().setUserId(10));
        List<Help> list = new LinkedList<>();
        Stream.of(list1,list2).forEach(list::addAll);
        list.sort(Comparator.comparing(Help::getUserId));
        System.out.println(list);

输出结果
[Help(id=null, userId=1, status=null, teamId=null, team=null, user=null), Help(id=null, userId=3, status=null, teamId=null, team=null, user=null), Help(id=null, userId=4, status=null, teamId=null, team=null, user=null), Help(id=null, userId=7, status=null, teamId=null, team=null, user=null), Help(id=null, userId=10, status=null, teamId=null, team=null, user=null), Help(id=null, userId=15, status=null, teamId=null, team=null, user=null), Help(id=null, userId=20, status=null, teamId=null, team=null, user=null), Help(id=null, userId=30, status=null, teamId=null, team=null, user=null)]

可以发现已经按照给定的排序条件进行好了排序。其中使用Stream.of(list1,list2)方法生成了一个Stream流，然后通过forEach方法将合并好的流中的每一个对象都记录到之前声明好的List集合中，再然后通过sort对List集合进行排序。

List集合中对象的属性LocalDateTime类型进行排序

Object personage = redisTemplate.opsForHash().get(openid, "personage");
        Object cancel = redisTemplate.opsForHash().get(openid, "cancel");
        List<Message> messages1 = JSONUtil.toList(personage.toString(), Message.class);
        List<Message> messages2 = JSONUtil.toList(cancel.toString(), Message.class);
        LinkedList<Message> messages = (LinkedList<Message>) messages1;
        //合并两个List集合为一个
        Stream.of(messages1,messages2).forEach(messages::addAll);
        if (ObjectUtil.isNotNull(messages)){
            //排序
            Collections.sort(messages, new Comparator<Message>() {
                @Override
                public int compare(Message o1, Message o2) {
                    LocalDateTime createTime1 = o1.getCreateTime();
                    LocalDateTime createTime2 = o2.getCreateTime();
                    Integer flag = createTime1.isBefore(createTime2)?-1:1;
                    return flag;
                }
            });
        }

使用的JavaBean对象
    @Data
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@TableName("t_message")
@ApiModel(value="Message对象", description="")
public class Message implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "id")
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    private Integer askId;

    private Integer helpId;

    private LocalDateTime createTime;

    private Integer status;

    @TableField(exist = false)
    private User askUser;

    @TableField(exist = false)
    private User helpUser;

    @TableField(exist = false)
    private Help help;

}

原理与之前所说都是一样的，可以把这个当作一个练习自己试试