Java字段Stream排序常用方式

public class OrderTest {
    private String channelCode;
    private BigDecimal rate;
    // 省略 getter、setter、toString()、constructor
}

        List<OrderTest> orderTestList = new ArrayList<>();
        OrderTest z09 = new OrderTest("Z09", new BigDecimal("7.6677"));
        OrderTest B2C = new OrderTest("B2C", new BigDecimal("5.6666"));
        OrderTest Z04 = new OrderTest("Z04", new BigDecimal("4.3137"));
        OrderTest ALL = new OrderTest("ALL", new BigDecimal("4.3137"));
        OrderTest ALL1 = new OrderTest("ALL", new BigDecimal("4.5137"));
        // 演示多字段排序使用
        OrderTest z091 = new OrderTest("Z09", new BigDecimal("7.6671"));
        // 演示给 null 值排序用
        OrderTest z092 = new OrderTest("Z09", null);
        OrderTest B2C1 = new OrderTest("B2C", new BigDecimal("5.6666"));
        OrderTest Z041 = new OrderTest("Z04", null);
        orderTestList.add(z09);
        orderTestList.add(z091);
        orderTestList.add(B2C);
        orderTestList.add(Z04);
        orderTestList.add(ALL);
        orderTestList.add(ALL1);

        System.out.println("----------------------------------------------");
        System.out.println("只按照 channelCode 升序排序：");
        List<OrderTest> channelAsc =
                orderTestList.stream()
                        .sorted(Comparator.comparing(OrderTest::getChannelCode))
                        .collect(Collectors.toList());
        channelAsc.forEach(System.out::println);
        System.out.println("----------------------------------------------");
        System.out.println("只按照 channelCode 降序排序：");
        List<OrderTest> channelDesc =
                orderTestList.stream()
                        .sorted(Comparator.comparing(OrderTest::getChannelCode, Comparator.reverseOrder()))
                        .collect(Collectors.toList());
        channelDesc.forEach(System.out::println);

        System.out.println("----------------------------------------------");
        System.out.println("先按照 channelCode 升序，再按照 rate 升序排序：");
        List<OrderTest> channelCodeAscRateAscList =
                orderTestList.stream()
                        .sorted(Comparator.comparing(OrderTest::getChannelCode)
                                .thenComparing(OrderTest::getRate))
                        .collect(Collectors.toList());
        channelCodeAscRateAscList.forEach(System.out::println);

        System.out.println("----------------------------------------------");
        System.out.println("先按照 channelCode 升序，再按照 rate 升序排序，使用 reversed()：");
        List<OrderTest> channelCodeAscRateAscWithReversedList =
                orderTestList.stream()
                        .sorted(Comparator.comparing(OrderTest::getChannelCode)
                                .thenComparing(OrderTest::getRate).reversed())
                        .collect(Collectors.toList());
        channelCodeAscRateAscWithReversedList.forEach(System.out::println);

        System.out.println("----------------------------------------------");
        System.out.println("先按照 channelCode 升序，再按照 rate 降序排序：");
        List<OrderTest> channelCodeAscRateDescList =
                orderTestList.stream()
                        .sorted(Comparator.comparing(OrderTest::getChannelCode)
                                .thenComparing(OrderTest::getRate, Comparator.reverseOrder()))
                        .collect(Collectors.toList());
        channelCodeAscRateDescList.forEach(System.out::println);

        orderTestList.add(z092);
        orderTestList.add(B2C1);
        orderTestList.add(Z041);        

        System.out.println("----------------------------------------------");
        System.out.println("先按照 channelCode 升序，再按照 rate 降序并且 null 值放前面排序：");
        List<OrderTest> channelCodeAscRateDescNullFirstList = orderTestList.stream()
                .sorted(Comparator.comparing(OrderTest::getChannelCode)
                        .thenComparing(OrderTest::getRate, Comparator.nullsFirst(Comparator.reverseOrder())))
                .collect(Collectors.toList());
        channelCodeAscRateDescNullFirstList.forEach(System.out::println);

        System.out.println("----------------------------------------------");
        System.out.println("先按照 channelCode 升序，再按照 rate 降序并且 null 值放后面排序：");
        List<OrderTest> channelCodeAscRateDescNullLastList = orderTestList.stream()
                .sorted(Comparator.comparing(OrderTest::getChannelCode)
                        .thenComparing(OrderTest::getRate, Comparator.nullsLast(Comparator.reverseOrder())))
                .collect(Collectors.toList());
        channelCodeAscRateDescNullLastList.forEach(System.out::println);