java List集合排序方式

1.使用直接上代码

package com.demo;

import cn.hutool.core.date.DateTime;
import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.*;
import java.util.stream.Collectors;

public class DemoCollectionsSortMain {

    public static void main(String[] args) {
        //初始化collectionsList集合
        List<NodeList> collectionsList = initializeListNodeTest();
        //1.用 Collections.sort 重写compare函数进行排序
        sortNodeList(collectionsList);
        System.out.println("===============================================================");

        //初始化streamList集合
        List<NodeList> streamList = initializeListNodeTest();
        //2.使用stream流排序
        streamSortNodeList(streamList);
        System.out.println("===============================================================");

        //初始化streamMoreList集合
        List<NodeList> streamMoreList = initializeListNodeTest();
        //2.使用stream流多个属性排序
        streamSortMoreNodeList(streamMoreList);

    }

    /**
     * 1.使用 Collections.sort 重写compare函数
     * @param list
     */
    public static void sortNodeList(List<NodeList> list){
        //1.第一种排序方式
        Collections.sort(list, new Comparator<NodeList>() {
            @Override
            public int compare(NodeList o1, NodeList o2) {
                Integer o1Disp = o1.getDisp();
                Integer o2Disp = o2.getDisp();
                //如果排序字段相同，则使用 dateTime 时间排序
                if(o1Disp == o2Disp) {
                    DateTime t1 = o1.getDateTime();
                    DateTime t2 = o2.getDateTime();
                    return t2.compareTo(t1);
                } else {
                    return Integer.compare(o1Disp, o2Disp);
                }
            }
        });

        //遍历排序后的List
        list.forEach(f->{
            System.out.println(f.getDisp()+"    "+f.getDateTime());
        });
    }

    /**
     * 2.使用 stream 流排序
     * 使用 disp 排序
     * 使用流的方式排序，需要考虑到排序字段有可能为null,添加Comparator.nullsLast(Integer::compareTo)) 防止null抛出异常
     * @param list
     */
    public static void streamSortNodeList(List<NodeList> list){
        //1.使用流的方式排序，需要考虑到排序字段有可能为null,添加Comparator.nullsLast(Integer::compareTo)) 防止null抛出异常
        List<NodeList> newList = list.stream()
                .sorted(Comparator.comparing(NodeList::getDisp,Comparator.nullsLast(Integer::compareTo)))
                .collect(Collectors.toList());
        //遍历排序后的List
        newList.forEach(f->{
            System.out.println(f.getDisp()+"   |  "+f.getDateTime());
        });
    }

    /**
     * 3.使用 stream 流 多个属性字段 排序
     * 使用多个属性字段进行排序
     * 使用流的方式排序，需要考虑到排序字段有可能为null,添加Comparator.nullsLast(Integer::compareTo)) 防止null抛出异常
     * @param list
     */
    public static void streamSortMoreNodeList(List<NodeList> list){
        //1.多个属性字段使用流的方式排序，需要考虑到排序字段有可能为null,添加Comparator.nullsLast(Integer::compareTo)) 防止null抛出异常
        List<NodeList> newList = list.stream()
                .sorted(Comparator.comparing(NodeList::getDisp,Comparator.nullsLast(Integer::compareTo))
                        .thenComparing(NodeList::getDateTime,Comparator.nullsLast(Date::compareTo)))
                .collect(Collectors.toList());
        //遍历排序后的List
        newList.forEach(f->{
            System.out.println(f.getDisp()+"   |  "+f.getDateTime());
        });
    }

    /**
     * 初始化 NodeTest 列表
     * @return
     */
    public static List<NodeList> initializeListNodeTest(){
        DateTime t1 = new DateTime("2024-07-04 13:29:58");
        DateTime t2 = new DateTime("2024-07-04 13:29:23");
        DateTime t3 = new DateTime("2024-07-04 13:29:19");
        DateTime t4 = new DateTime("2024-07-04 13:29:45");
        List<NodeList> list = new ArrayList<>();
        NodeList test1 = new NodeList(0,t1);
        NodeList test2 = new NodeList(0,t2);
        NodeList test3 = new NodeList(2,t3);
        NodeList test4 = new NodeList(0,t4);
        list.add(test1);
        list.add(test2);
        list.add(test3);
        list.add(test4);
        return list;
    }

}

@Data
@AllArgsConstructor
class NodeList{
    private Integer disp; //排序字段
    private DateTime dateTime; //排序字段
}