排序方法

List<类> list; 代表某集合
 
  
//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));


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

//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));


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

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

//返回 对象集合以类属性一升序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,对升序结果进行属性一降序,再进行属性二升序,对前面结果进行属性一降序属性二降序（优先按照属性一降序，属性一相等时再按照属性二降序）
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

通过以上例子我们可以发现

1. Comparator.comparing(类::属性一).reversed();

2. Comparator.comparing(类::属性一,Comparator.reverseOrder());

两种排序是完全不一样的,一定要区分开来

1、是得到排序结果后再排序,

2、是直接进行排序，很多人会混淆导致理解出错，2更好理解，建议使用2

实际例子:

有个Img类，有个排序号sort和创建时间createTime，要求先按照sort正序排列，然后按照createTime倒序排列

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateUtil;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Data
@ToString
public class Img {
    @ApiModelProperty(value = "id")
    private Integer id;
    @ApiModelProperty(value = "排序号")
    private Integer sort;
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    public static void main(String[] args) {
        List<Img> list = CollUtil.newArrayList();
        for (int i = 1; i <= 3; i++) {
            Img img = new Img();
            img.setId(i);
            img.setSort(i != 1 ? 2 : 1);
            img.setCreateTime(i == 1 ? DateUtil.offset(new Date(), DateField.MINUTE, 3) : i == 2 ? DateUtil.offset(new Date(), DateField.MINUTE, 1) : DateUtil.offset(new Date(), DateField.MINUTE, 2));
            list.add(img);
        }
        log.info("现有集合");
        list.stream().forEach(item -> System.out.println(item));
        log.info("使用reversed()排序");
        List<Img> imgList = list.stream().sorted(Comparator.comparing(Img::getSort).thenComparing(Img::getCreateTime).reversed()).collect(Collectors.toList());
        imgList.stream().forEach(item -> System.out.println(item));
        log.info("使用Comparator.reverseOrder()排序");
        List<Img> imgs = list.stream().sorted(Comparator.comparing(Img::getSort).thenComparing(Img::getCreateTime, Comparator.reverseOrder())).collect(Collectors.toList());
        imgs.stream().forEach(item -> System.out.println(item));
    }
}

打印结果

10:32:25.368 [main] INFO com.eternity.scrapy.modules.entity.Img - 现有集合
Img(id=1, sort=1, createTime=2022-02-09 10:35:25)
Img(id=2, sort=2, createTime=2022-02-09 10:33:25)
Img(id=3, sort=2, createTime=2022-02-09 10:34:25)
10:32:25.577 [main] INFO com.eternity.scrapy.modules.entity.Img - 使用reversed()排序
Img(id=3, sort=2, createTime=2022-02-09 10:34:25)
Img(id=2, sort=2, createTime=2022-02-09 10:33:25)
Img(id=1, sort=1, createTime=2022-02-09 10:35:25)
10:32:25.630 [main] INFO com.eternity.scrapy.modules.entity.Img - 使用Comparator.reverseOrder()排序
Img(id=1, sort=1, createTime=2022-02-09 10:35:25)
Img(id=3, sort=2, createTime=2022-02-09 10:34:25)
Img(id=2, sort=2, createTime=2022-02-09 10:33:25)

站在巨人肩膀上摘苹果

https://www.cnblogs.com/kuanglongblogs/p/11230250.html