Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】

针对集合排序，java8可以用Stream流的sorted()进行排序。
示例Bean
以下我们会使用这个Bean来做示例。

public class Order {

    private String weight;

    private Double price;

    private String dateStr;

    //忽略getter、setter、构造方法、toString
}

字段排序
首先是比较器 Comparator，形式如下：

Comparator<对象的类名> comparator = Comparator.comparing(对象的类名::get方法名, 升序或降序)

1. 排序常用的api：
naturalOrder()表示自然排序(一般是升序)，数字的自然顺序是数字顺序，字符串按字母顺序排序，日期按时间顺序排序。
reverseOrder()表示 降序。
nullsLast()表示如果属性为null，就放到最后面。
nullsFirst()表示如果属性为null，就放到最前面。
升序如下：
naturalOrder()表示自然排序(一般是升序)，没有处理属性的null值，排序时可能会空指针

Comparator<Order> comparator1 = Comparator.comparing(Order::getDateStr, Comparator.naturalOrder());
List<Order> orderList1 = list.stream().sorted(comparator1).collect(Collectors.toList());
等同于 List<Order> orderList1 = list.stream().sorted(Comparator.comparing(Order::getDateStr)).collect(Collectors.toList());
System.out.println("orderList1："+orderList1);

降序如下:

Comparator.reverseOrder()表示 降序，没有处理属性的null值，排序时可能会空指针
Comparator<Order> comparator2 = Comparator.comparing(Order::getDateStr, Comparator.reverseOrder());
List<Order> orderList2 = list.stream().sorted(comparator2).collect(Collectors.toList());
System.out.println("orderList2："+orderList2);

Comparator.nullsLast()表示如果属性为null，就放到最后面，Comparator.nullsFirst()表示如果属性为null，就放到最前面。

Comparator<Order> comparator3 =  Comparator.comparing(Order::getDateStr, Comparator.nullsLast(naturalOrder()) );
List<Order> orderList3 = list.stream().sorted(comparator3).collect(Collectors.toList());
System.out.println("orderList3："+orderList3);

2.java8多字段排序
有时我们还需要对多个字段进行排序。
多个字段排序，先对第一个排序字段排序，当第一个排序字段相同时，会使用第二个排序字段进行排序。

多字段排序的api
多个字段排序的格式

Comparator<对象的类名> comparator = Comparator.comparing(对象的类名::方法名1, 升序或降序)
		.thenComparing(Comparator.comparing(对象的类名::方法名2, 升序或降序));

如果是三个以上的字段排序，就继续用 thenComparing 连接。

示例如下：
先按第一个字段降序，再按第二个字段降序，如果属性为null，就放到最后面。

Comparator<Order> comparator5 = Comparator.comparing(Order::getDateStr, Comparator.nullsLast(Comparator.reverseOrder()))
        .thenComparing(Order::getPrice, Comparator.nullsLast(Comparator.reverseOrder()));
List<Order> orderList5 = list.parallelStream().sorted(comparator5).collect(Collectors.toList());
System.out.println("orderList5："+ orderList5);

reversed()和Comparator.reverseOrder()的区别：
Comparator.comparing(对象的类名::属性的方法名).reversed();
Comparator.comparing(对象的类名::属性的方法名,Comparator.reverseOrder());

reversed()是得到排序结果后再反转，
Comparator.reverseOrder()是对属性按照降序进行排序，
reversed()在多字段排序时，很容易混乱，不建议使用。
Comparator.reverseOrder()更好理解，也更好用些。

public class SortedDemo {

    /**
     * naturalOrder()表示自然排序(一般是升序)，
     * Comparator.reverseOrder()表示 降序。
     *
     * nullsLast()表示如果属性为null，就放到最后面。
     * nullsFirst()表示如果属性为null，就放到最前面。
     *
     */
    public static void order() {
        //设置 order对象属性，以下是lombok的写法，相当于 setter
        Order order1=Order.builder().dateStr("2021-10-01 00:00:00").price(33.3).build();
        Order order2=Order.builder().dateStr("2021-10-01 00:00:00").price(1.3).build();
        Order order3=Order.builder().dateStr("2021-10-01 00:00:00").price(55.3).build();
        Order order4=Order.builder().dateStr("2021-12-01 00:00:00").price(55.3).build();
        //添加null测试
        Order order5=Order.builder().dateStr(null).price(null).build();

        List<Order> list= new ArrayList<>();
        list.add(order1);
        list.add(order2);
        list.add(order3);
        list.add(order4);
        list.add(order5);

        // ==========================================================================
        //naturalOrder()表示自然排序(一般是升序)，没有处理null，排序时可能会空指针
        Comparator<Order> comparator1 = Comparator.comparing(Order::getDateStr, Comparator.naturalOrder());
//        List<Order> orderList1 = list.stream().sorted(comparator1).collect(Collectors.toList());
//        System.out.println("orderList1："+orderList1);

        // ==========================================================================
        //Comparator.reverseOrder表示 降序，没有处理null，排序时可能会空指针
        Comparator<Order> comparator2 = Comparator.comparing(Order::getDateStr, Comparator.reverseOrder());
//        List<Order> orderList2 = list.stream().sorted(comparator2).collect(Collectors.toList());
//        System.out.println("orderList2："+orderList2);

        // ==========================================================================

        //Comparator.nullsLast表示如果属性为null，就放到最后面
        Comparator<Order> comparator3 =  Comparator.comparing(Order::getDateStr, Comparator.nullsLast(naturalOrder()) );
        List<Order> orderList3 = list.stream().sorted(comparator3).collect(Collectors.toList());
//        System.out.println("orderList3："+orderList3);

        // ==========================================================================

        //nullsFirst表示如果属性为null，就放到最前面。
        Comparator<Order> comparator4 = Comparator.comparing(Order::getDateStr, Comparator.nullsFirst(Comparator.reverseOrder()));
        List<Order> orderList4 = list.stream().sorted(comparator4).collect(Collectors.toList());
//        System.out.println("orderList4："+ orderList4);

        // ==========================================================================

        //先按第一个字段降序，再按第二个字段降序，如果属性为null，就放到最后面。
        //输出： [Order(price=55.3, dateStr=2021-12-01 00:00:00),
        //Order( price=55.3, dateStr=2021-10-01 00:00:00),
        //Order(price=33.3, dateStr=2021-10-01 00:00:00),
        //Order(price=1.3, dateStr=2021-10-01 00:00:00)]

        Comparator<Order> comparator5 = Comparator.comparing(Order::getDateStr, Comparator.nullsLast(Comparator.reverseOrder()))
                .thenComparing(Order::getPrice, Comparator.nullsLast(Comparator.reverseOrder()));
        List<Order> orderList5 = list.parallelStream().sorted(comparator5).collect(Collectors.toList());
        System.out.println("orderList5："+ orderList5);
    }
}