java8 使用stream进行排序(多字段排序、升序、降序)

文章包含“标题”、“发布时间”、“是否推荐”、“是否置顶”四个属性。

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Article {
    /**
     * 文章标题
     */
    private String title;
    /**
     * 发布时间
     */
    private String releaseTime;
    /**
     * 是否推荐：Y 推荐；N 不推荐
     */
    private String recommend;
    /**
     * 是否置顶: Y 置顶；N 不置顶
     */
    private String top;
}

测试代码

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

public class Demo {

    public static void main(String[] args) {
        List<Article> list = init();
        sort(list);
        sort2(list);
    }

    /**
     * 初始化数据
     * @return
     */
    private static List<Article> init(){
        List<Article> list = new ArrayList<>();
        list.add(new Article("文章一","2021-11-01","Y","Y"));
        list.add(new Article("文章二","2021-11-02","Y","Y"));
        list.add(new Article("文章三","2021-11-01","Y","N"));
        list.add(new Article("文章一","2021-11-02","Y","N"));
        list.add(new Article("文章一","2021-11-01","N","Y"));
        list.add(new Article("文章一","2021-11-02","N","Y"));
        list.add(new Article("文章一","2021-11-01","N","N"));
        list.add(new Article("文章一","2021-11-02","N","N"));
        return list;
    }
    ....
}

排序方法

/**
     * 按照推荐、置顶、发布时间来排序
     * @param list
     */
private static void sort(List<Article> list){
    List<Article> sortList = list.stream()
            // 【X】
            .sorted(Comparator.comparing(Article::getRecommend,Comparator.reverseOrder())
                    // 【Y】
                    .thenComparing(Article::getTop,Comparator.reverseOrder())
                    // 【Z】
                    .thenComparing(Article::getReleaseTime,Comparator.reverseOrder()))
            .collect(Collectors.toList());
    sortList.stream().forEach(System.out::println);
}
//        运行结果：
//        Article(title=文章二, releaseTime=2021-11-02, recommend=Y, top=Y)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=Y, top=Y)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=Y, top=N)
//        Article(title=文章三, releaseTime=2021-11-01, recommend=Y, top=N)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=N, top=Y)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=N, top=Y)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=N, top=N)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=N, top=N)

• 【X】：优先使用recommend字段排序，并且使用降序排列(Comparator.reverseOrder()),在结果中的体现是前四篇文章的recommend为‘Y’,后四篇的recommend为‘N’

• 【Y】：之后再使用top字段排序，并且使用降序排列(Comparator.reverseOrder()), 在结果中的体现是recommend相同的文章中，前两篇文章的top为‘Y’, 后两篇文章的top为‘N’

• 【Z】：最后使用发布时间字段进行排序，并且使用降序排列(Comparator.reverseOrder())

两种倒序方式

Comparator.comparing(类::属性,Comparator.reverseOrder()）

/**
     * 按照推荐、置顶、发布时间来排序
     * @param list
     */
private static void sort(List<Article> list){
    List<Article> sortList = list.stream()
            // 【X】
            .sorted(Comparator.comparing(Article::getRecommend,Comparator.reverseOrder())
                    // 【Y】
                    .thenComparing(Article::getTop,Comparator.reverseOrder())
                    // 【Z】
                    .thenComparing(Article::getReleaseTime,Comparator.reverseOrder()))
            .collect(Collectors.toList());
    sortList.stream().forEach(System.out::println);
}
//        运行结果：
//        Article(title=文章二, releaseTime=2021-11-02, recommend=Y, top=Y)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=Y, top=Y)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=Y, top=N)
//        Article(title=文章三, releaseTime=2021-11-01, recommend=Y, top=N)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=N, top=Y)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=N, top=Y)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=N, top=N)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=N, top=N)

以传入的字段进行倒序排列

• 【X】：这里就类似于mysql中的 order by recommend desc

• 【Y】：结合【X】就是order by recommend desc, top desc

Comparator.comparing(Article::getRecommend,Comparator.reverseOrder()).reversed()

private static void sort2(List<Article> list){
    List<Article> sortList = list.stream()
            .sorted(Comparator.comparing(Article::getRecommend,Comparator.reverseOrder())
                    .thenComparing(Article::getTop,Comparator.reverseOrder())
                    .thenComparing(Article::getReleaseTime,Comparator.reverseOrder()).reversed()) // 【X】
            .collect(Collectors.toList());
    sortList.stream().forEach(System.out::println);
}
//        运行结果：
//        Article(title=文章一, releaseTime=2021-11-01, recommend=N, top=N)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=N, top=N)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=N, top=Y)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=N, top=Y)
//        Article(title=文章三, releaseTime=2021-11-01, recommend=Y, top=N)
//        Article(title=文章一, releaseTime=2021-11-02, recommend=Y, top=N)
//        Article(title=文章一, releaseTime=2021-11-01, recommend=Y, top=Y)
//        Article(title=文章二, releaseTime=2021-11-02, recommend=Y, top=Y)

• 【X】：这里的reversed()是将之前的排序进行整个倒序，可以发现这个方法的运行结果和上一个运行方法的运行结果是完全相反的