Java8 新特性之流式数据处理

忘是亡心i 2022-05-28 04:27 227阅读 0赞

这个流式处理可以在集合处理的时候提高性能，优化时可以采用，记录一下  
一. 流式处理简介  
在我接触到java8流式处理的时候，我的第一感觉是流式处理让集合操作变得简洁了许多，通常我们需要多行代码才能完成的操作，借助于流式处理可以在一行中实现。比如我们希望对一个包含整数的集合中筛选出所有的偶数，并将其封装成为一个新的List返回，那么在java8之前，我们需要通过如下代码实现：

List<Integer> evens = new ArrayList<>();
    for (final Integer num : nums) {
        if (num % 2 == 0) {
            evens.add(num);
        }
    }

通过java8的流式处理，我们可以将代码简化为：

List<Integer> evens = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());

先简单解释一下上面这行语句的含义，stream()操作将集合转换成一个流，filter()执行我们自定义的筛选处理，这里是通过lambda表达式筛选出所有偶数，最后我们通过collect()对结果进行封装处理，并通过Collectors.toList()指定其封装成为一个List集合返回。

由上面的例子可以看出，java8的流式处理极大的简化了对于集合的操作，实际上不光是集合，包括数组、文件等，只要是可以转换成流，我们都可以借助流式处理，类似于我们写SQL语句一样对其进行操作。java8通过内部迭代来实现对流的处理，一个流式处理可以分为三个部分：转换成流、中间操作、终端操作。如下图：  
![这里写图片描述][848293-20161103143545315-2110948414.png]

以集合为例，一个流式处理的操作我们首先需要调用stream()函数将其转换成流，然后再调用相应的中间操作达到我们需要对集合进行的操作，比如筛选、转换等，最后通过终端操作对前面的结果进行封装，返回我们需要的形式。

二. 中间操作  
我们定义一个简单的学生实体类，用于后面的例子演示：

复制代码  
public class Student \{

/** 学号 */
    private long id;
    
    private String name;
    
    private int age;
    
    /** 年级 */
    private int grade;
    
    /** 专业 */
    private String major;
    
    /** 学校 */
    private String school;
    
    // 省略getter和setter

\}  
复制代码  
复制代码  
// 初始化  
List students = new ArrayList() \{  
\{  
add(new Student(20160001, “孔明”, 20, 1, “土木工程”, “武汉大学”));  
add(new Student(20160002, “伯约”, 21, 2, “信息安全”, “武汉大学”));  
add(new Student(20160003, “玄德”, 22, 3, “经济管理”, “武汉大学”));  
add(new Student(20160004, “云长”, 21, 2, “信息安全”, “武汉大学”));  
add(new Student(20161001, “翼德”, 21, 2, “机械与自动化”, “华中科技大学”));  
add(new Student(20161002, “元直”, 23, 4, “土木工程”, “华中科技大学”));  
add(new Student(20161003, “奉孝”, 23, 4, “计算机科学”, “华中科技大学”));  
add(new Student(20162001, “仲谋”, 22, 3, “土木工程”, “浙江大学”));  
add(new Student(20162002, “鲁肃”, 23, 4, “计算机科学”, “浙江大学”));  
add(new Student(20163001, “丁奉”, 24, 5, “土木工程”, “南京大学”));  
\}  
\};  
复制代码  
2.1 过滤

过滤，顾名思义就是按照给定的要求对集合进行筛选满足条件的元素，java8提供的筛选操作包括：filter、distinct、limit、skip。

filter  
在前面的例子中我们已经演示了如何使用filter，其定义为：Stream filter(Predicate

List<Student> whuStudents = students.stream().filter(student -> "武汉大学".equals(student.getSchool())).collect(Collectors.toList());

distinct  
distinct操作类似于我们在写SQL语句时，添加的DISTINCT关键字，用于去重处理，distinct基于Object.equals(Object)实现，回到最开始的例子，假设我们希望筛选出所有不重复的偶数，那么可以添加distinct操作：

List evens = nums.stream()  
.filter(num -> num % 2 == 0).distinct()  
.collect(Collectors.toList());  
limit  
limit操作也类似于SQL语句中的LIMIT关键字，不过相对功能较弱，limit返回包含前n个元素的流，当集合大小小于n时，则返回实际长度，比如下面的例子返回前两个专业为土木工程专业的学生：

List<Student> civilStudents = students.stream().filter(student -> "土木工程".equals(student.getMajor())).limit(2).collect(Collectors.toList());

说到limit，不得不提及一下另外一个流操作：sorted。该操作用于对流中元素进行排序，sorted要求待比较的元素必须实现Comparable接口，如果没有实现也不要紧，我们可以将比较器作为参数传递给sorted(Comparator

List<Student> sortedCivilStudents = students.stream() .filter(student -> "土木工程".equals(student.getMajor())).sorted((s1, s2) -> s1.getAge() - s2.getAge()) .limit(2).collect(Collectors.toList());

skip  
skip操作与limit操作相反，如同其字面意思一样，是跳过前n个元素，比如我们希望找出排序在2之后的土木工程专业的学生，那么可以实现为：

List<Student> civilStudents = students.stream().filter(student -> "土木工程".equals(student.getMajor())).skip(2).collect(Collectors.toList());

通过skip，就会跳过前面两个元素，返回由后面所有元素构造的流，如果n大于满足条件的集合的长度，则会返回一个空的集合。

2.2 映射

在SQL中，借助SELECT关键字后面添加需要的字段名称，可以仅输出我们需要的字段数据，而流式处理的映射操作也是实现这一目的，在java8的流式处理中，主要包含两类映射操作：map和flatMap。

map  
举例说明，假设我们希望筛选出所有专业为计算机科学的学生姓名，那么我们可以在filter筛选的基础之上，通过map将学生实体映射成为学生姓名字符串，具体实现如下：

List<String> names = students.stream() .filter(student -> "计算机科学".equals(student.getMajor())).map(Student::getName).collect(Collectors.toList());

除了上面这类基础的map，java8还提供了mapToDouble(ToDoubleFunction

int totalAge = students.stream().filter(student -> "计算机科学".equals(student.getMajor())) .mapToInt(Student::getAge).sum();

通过将Student按照年龄直接映射为IntStream，我们可以直接调用提供的sum()方法来达到目的，此外使用这些数值流的好处还在于可以避免jvm装箱操作所带来的性能消耗。

flatMap  
flatMap与map的区别在于 flatMap是将一个流中的每个值都转成一个个流，然后再将这些流扁平化成为一个流 。举例说明，假设我们有一个字符串数组String\[\] strs = \{“java8”, “is”, “easy”, “to”, “use”\};，我们希望输出构成这一数组的所有非重复字符，那么我们可能首先会想到如下实现：

List<String[]> distinctStrs = Arrays.stream(strs)
                                    .map(str -> str.split(""))  // 映射成为Stream<String[]>
                                    .distinct()
                                    .collect(Collectors.toList());

在执行map操作以后，我们得到是一个包含多个字符串（构成一个字符串的字符数组）的流，此时执行distinct操作是基于在这些字符串数组之间的对比，所以达不到我们希望的目的，此时的输出为：

\[j, a, v, a, 8\]  
\[i, s\]  
\[e, a, s, y\]  
\[t, o\]  
\[u, s, e\]  
distinct只有对于一个包含多个字符的流进行操作才能达到我们的目的，即对Stream进行操作。此时flatMap就可以达到我们的目的：

List<String> distinctStrs = Arrays.stream(strs)
                                    .map(str -> str.split(""))  // 映射成为Stream<String[]>
                                    .flatMap(Arrays::stream)  // 扁平化为Stream<String>
                                    .distinct()
                                    .collect(Collectors.toList());

flatMap将由map映射得到的Stream

[848293-20161103143545315-2110948414.png]: /images/20220528/6a692897150f47198bad69cf5a7fbdfe.png