文章目录

• 前言
• 假设业务场景
• 排序前的准备
• 正序排序
• • 1、数据集合的判空 Optional.isPresent()
  • 2、使用sort排序
  • 3、将排序后的数据流转换为list
• 你以为这样就完了？
• 倒序排序

前言

之前，针对Stream链式编程中的几个方法做了大致的说明。详情可以参考：

JDK 1.8 新特性之Stream 详解个人笔记

但实际业务中，总会存在很多复杂的思维，需要使用到Stream，此时玩的不熟练总感觉无从下手。

今后开始写几种常用的逻辑方式。

假设业务场景

在数据查询出来后，需要针对集合中的数据信息，按照某一字段进行正序或倒序排序。

排序前的准备

创建一个数据元类，并填充数据做一个指定对象的数据集合。

class Users{
    private String userName;
    private String password;

    public Users(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    public String getUserName() {
        return userName;
    }

    @Override
    public String toString() {
        return "Users{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

测试数据集合如下：

List<Users> users = Arrays.asList(new Users("xj5", "555")
                , new Users("xj2", "2222")
                , new Users("xj1", "1111")
                , new Users("xj3", "3333"));

正序排序

Stream中的排序，通常会使用到其中的sort()方法，接下来就按步骤进行数据排序操作。

1、数据集合的判空 Optional.isPresent()

从数据库等其他方式获取到的数据，并非就一定存在。虽然在本次定义了测试数据集合，但为了代码逻辑的健壮性，则需要经过如下操作处理。

System.out.println("-----> " + Optional.ofNullable(null).isPresent());
System.out.println("-----> " + Optional.ofNullable(new ArrayList<>()).isPresent());

执行后的结果：

-----> false
-----> true

所以，上面的数据集合可以进行下列操作。

Optional.ofNullable(users).orElse(new ArrayList<Users>())

当然也可以通过Optional.ofNullable(集合别名).isPresent()判断集合是否存在，再通过返回 boolean 判断是否继续向下执行链式编程代码。

2、使用sort排序

使用sort排序时，如果其中是对象，则还需要使用一个Comparator.comparing()的方法转换。

Optional.ofNullable(users)
        .orElse(new ArrayList<Users>())
        .stream()
        .sorted(Comparator.comparing(Users::getUserName))

3、将排序后的数据流转换为list

List<Users> collect = Optional.ofNullable(users)
                .orElse(new ArrayList<Users>())
                .stream()
                .sorted(Comparator.comparing(Users::getUserName))
                .collect(Collectors.toList());

执行后，日志输出如下信息：

[Users{userName='xj1', password='1111'},
 Users{userName='xj2', password='2222'}, 
 Users{userName='xj3', password='3333'}, 
 Users{userName='xj5', password='555'}]

你以为这样就完了？

Optional.ofNullable只是判断传递的参数是否为null，如果传递的参数是对象，则还需要注意对象中的每个属性的数据是否为null。

看一个反例，如果其中某个对象的值是null时，会出现什么样的情况？

package xj.test.streams;

import java.util.*;
import java.util.stream.Collectors;

public class Test6 {
    public static void main(String[] args) {
        List<Users> users = Arrays.asList(new Users("xj5", "555")
                , new Users("xj2", "2222")
                , new Users("xj1", "1111")
                , new Users("xj3", "3333")
                , new Users(null,"null"));

        List<Users> collect = Optional.ofNullable(users)
                .orElse(new ArrayList<Users>())
                .stream()
                .sorted(Comparator.comparing(Users::getUserName))
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}

此处出现空指针的问题，在于Comparator.comparing中的数据元，存在空的问题，报错！

解决方式也很简单，将需要排序的字段，在sort操作之前可以进行一次过滤，如下：

public class Test6 {
    public static void main(String[] args) {
        List<Users> users = Arrays.asList(new Users("xj5", "555")
                , new Users("xj2", "2222")
                , new Users("xj1", "1111")
                , new Users("xj3", "3333")
                , new Users(null,"null"));

        List<Users> collect = Optional.ofNullable(users)
                .orElse(new ArrayList<Users>())
                .stream()
                .filter(x->Objects.nonNull(x) && x.getUserName() != null)
                .sorted(Comparator.comparing(Users::getUserName))
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}

成功解决！

倒序排序

倒序排序操作并不是很复杂，只需要在排序的Comparator.comparing(Users::getUserName)后，将结果使用reversed()反转一下就可以实现。如下所示：

public class Test6 {
    public static void main(String[] args) {
        List<Users> users = Arrays.asList(new Users("xj5", "555")
                , new Users("xj2", "2222")
                , new Users("xj1", "1111")
                , new Users("xj3", "3333")
                , new Users(null,"null"));

        List<Users> collect = Optional.ofNullable(users)
                .orElse(new ArrayList<Users>())
                .stream()
                .filter(x->Objects.nonNull(x) && x.getUserName() != null)
                .sorted(Comparator.comparing(Users::getUserName).reversed())
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}