针对集合排序，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的写法，相当于 setterOrder 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);}
}