Java的stream流使用sorted方法对列表元素进行排序

应用场景

List<InterviewResultExcelDTO> sortedInterviewResultExcelDTOList = interviewResultExcelDTOList.stream()
                            .sorted(Comparator.comparing(InterviewResultExcelDTO::getCity)
                                    .thenComparing(InterviewResultExcelDTO::getInterviewDate, Comparator.nullsLast(Comparator.naturalOrder()))
                                    .thenComparing(InterviewResultExcelDTO::getInterviewTime, Comparator.nullsLast(Comparator.naturalOrder())))
                            .toList();

方法签名

    Stream<T> sorted(Comparator<? super T> comparator);

如上述签名所示, sorted方法的形参为一个函数式接口：比较器Comparator;

比较器Comparator的使用

比较器可以由静态工厂方法生成，这里重点介绍一下生成比较器中的comparing以及thenComparing方法：

• Comparator.comparing(Function…):
  • 介绍： 得到一个比较器，这个比较器对传入的Function实例得到的Comparable对象进行排序，且具有传入的Comparable对象的排序规则。
  • 方法签名以及实现：

  public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
              Function<? super T, ? extends U> keyExtractor)
      {
          Objects.requireNonNull(keyExtractor);
          return (Comparator<T> & Serializable)
              (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
     }
  

• Comparator.comparing(Function…, Comparator…)
  • 介绍：得到一个比较器，这个比较器对传入的Function实例得到的对象进行排序，排序规则由传入的一个Comparator对象的实现方法另外定义。
  • 方法签名以及实现：

  public static <T, U> Comparator<T> comparing(
          Function<? super T, ? extends U> keyExtractor,
          Comparator<? super U> keyComparator)
  {
      Objects.requireNonNull(keyExtractor);
      Objects.requireNonNull(keyComparator);
      return (Comparator<T> & Serializable)
          (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                            keyExtractor.apply(c2));
  }
  

• Comparator.thenComparing(Function…):
  • 介绍： 当使用当前的比较器定义的规则比较出现相同结果时，则生成并返回另一个比较器，该比较器具有传入的Function实例得到的Comparable对象的排序规则
  • 方法签名以及实现：

  default <U extends Comparable<? super U>> Comparator<T> thenComparing(
          Function<? super T, ? extends U> keyExtractor)
  {
      return thenComparing(comparing(keyExtractor));
  }
  

• Comparator.thenComparing(Function…, Comparator…)
  • 介绍：当使用当前的比较器定义的规则比较出现相同结果时，则生成并返回另一个比较器，这个比较器对传入的Function实例得到的对象进行排序，排序规则由传入的一个Comparator对象的实现方法另外定义。
  • 方法签名以及实现：

  default <U> Comparator<T> thenComparing(
          Function<? super T, ? extends U> keyExtractor,
          Comparator<? super U> keyComparator)
  {
      return thenComparing(comparing(keyExtractor, keyComparator));
  }