样式代码

//表明某个集合
List<类> rankList = new ArrayList<>();
//返回 对象集合以类属性一升序排序
rankList.stream().sorted(Comparator.comparing(类::属性一));

----返回 对象集合以类属性一降序排序 注意两种写法----
//先以属性一升序,而后对结果集进行属性一降序
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed());
//以属性一降序
rankList.stream().sorted(Comparator.comparing(类::属性一, Comparator.reverseOrder()));
//返回 对象集合以类属性一升序 属性二升序
rankList.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));

----返回 对象集合以类属性一降序 属性二升序 注意两种写法----
//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));
//先以属性一降序,再进行属性二升序
rankList.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));

----返回 对象集合以类属性一降序 属性二降序 注意两种写法----
//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));
//先以属性一降序,再进行属性二降序
rankList.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));

----返回 对象集合以类属性一升序 属性二降序 注意两种写法----
//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());
//先以属性一升序,再进行属性二降序
rankList.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));

// 1、按长度自然排序，即长度从小到大
 Arrays.stream(strArr).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
 // 2、按长度倒序，即长度从大到小
 Arrays.stream(strArr).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
 // 3、首字母倒序
 Arrays.stream(strArr).sorted(Comparator.reverseOrder()).forEach(System.out::println);
 // 4、首字母自然排序
 Arrays.stream(strArr).sorted(Comparator.naturalOrder()).forEach(System.out::println);

自定义比较器

public void streamSort(){
          List<DecrepitHouseInfo> addressList = data.toJavaList(DecrepitHouseInfo.class).stream().sorted(new Comparator<DecrepitHouseInfo>() {
               @Override
               public int compare(DecrepitHouseInfo o1, DecrepitHouseInfo o2) {
                    return o1.getType().compareTo(o2.getType());
               }
          }).collect(Collectors.toList());
          System.out.println(JSON.toJSON(addressList));
     }

lamda

@Test
     public void streamSort2(){
          List<DecrepitHouseInfo> addressList = data.toJavaList(DecrepitHouseInfo.class).stream().sorted((o1,o2)->{
               return o1.getType().compareTo(o2.getType());
          }).collect(Collectors.toList());
          System.out.println(JSON.toJSON(addressList));
     }

内置比较器

public void streamSort3(){
          List<DecrepitHouseInfo> addressList = data.toJavaList(DecrepitHouseInfo.class).stream()
                //.sorted(Comparator.comparing(DecrepitHouseInfo::getType).reversed())
                  .sorted(Comparator.comparing(DecrepitHouseInfo::getType))
                  .collect(Collectors.toList());
          System.out.println(JSON.toJSON(addressList));
     }

案例

数字排序

List<Student> students = new ArrayList<>();
Student student1 = new Student("六年级","Math","小张",1D);
students.add(student1);
Student student2 = new Student("三年级上","English","小钱",8D);
students.add(student2);
Student student3 = new Student("五年级","Chinese","小孙",6D);
students.add(student3);

倒序
List<Student> collect = students.stream().sorted(Comparator.comparing(Student::getMark).reversed()).collect(Collectors.toList());

控制台：
排序前：1.0|8.0|6.0|
排序后：8.0|6.0|1.0|

正序
List<Student> collect = students.stream().sorted(Comparator.comparing(Student::getMark)).collect(Collectors.toList());

控制台：
排序前：1.0|8.0|6.0|
排序后：1.0|6.0|8.0|

以中文排序

List<Student> students = new ArrayList<>();
Student student1 = new Student("六年级","Math","小张",1D);
students.add(student1);
Student student2 = new Student("三年级上","English","小钱",8D);
students.add(student2);
Student student3 = new Student("五年级","Chinese","小孙",6D);
students.add(student3);

List<Student> collect = students.stream().sorted(Comparator.comparing(Student::getGrade).reversed()).collect(Collectors.toList());

控制台：
排序前：六年级|三年级上|五年级|
排序后：六年级|五年级|三年级上|

List<Student> collect = students.stream().sorted(Comparator.comparing(Student::getGrade)).collect(Collectors.toList());

控制台：
排序前：六年级|三年级上|五年级|
排序后：三年级上|五年级|六年级|

排序字段为null时

List<Student> students = new ArrayList<>();
Student student1 = new Student("六年级","Math","小张",1D);
students.add(student1);
Student student2 = new Student("三年级上","English","小钱",8D);
students.add(student2);
Student student3 = new Student(null,"Chinese","小孙",6D);
students.add(student3);

List<Student> collect = students.stream().sorted(Comparator.comparing(Student::getGrade).reversed()).collect(Collectors.toList());

控制台：
Exception in thread "main" java.lang.NullPointerException
	at java.lang.String.compareTo(String.java:1155)
	at java.lang.String.compareTo(String.java:111)
	at java.util.Comparator.lambda$comparing$77a9974f$1(Comparator.java:469)
	at java.util.Collections$ReverseComparator2.compare(Collections.java:5185)
	at java.util.TimSort.countRunAndMakeAscending(TimSort.java:360)
	at java.util.TimSort.sort(TimSort.java:220)
	at java.util.Arrays.sort(Arrays.java:1512)
	at java.util.stream.SortedOps$SizedRefSortingSink.end(SortedOps.java:348)
	at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:483)
	at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472)
	at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
	at com.hbis.ttie.mal.rest.Test2.main(Test2.java:29)

先按照姓名升序,姓名相同则按年龄升序

list = list.sorted(Comparator.comparing(Student::getName).thenComparing(Student::getAge)).collect(Collectors.toList());

parallelStream