Java 8 Stream API 引入和使用

引入流

流是什么

流是Java API的新成员，它允许你以声明性的方式处理数据集合。可以看成遍历数据集的高级迭代。流可以透明地并行处理，无需编写多线程代码。我们先简单看一下使用流的好处。下面两段代码都是用来返回年龄小于14岁的初中生的姓名，并按照年龄排序。

假如我们有下面Student实体类

@Data
public class Student {
    private String name;
    private int age;
    private boolean member;
    private Grade grade;
    public Student() {
    }
    public Student(String name, int age, boolean member, Grade grade) {
        this.name = name;
        this.age = age;
        this.member = member;
        this.grade = grade;
    }
    public enum Grade{
        JUNIOR_ONE,JUNIOR_TWO,JUNIOR_THREE
    }
}

Java 8之前的实现方式：

List<Student> students = Arrays.asList(
        new Student("张初一", 13, false, Student.Grade.JUNIOR_ONE),
        new Student("李初二", 14, false, Student.Grade.JUNIOR_TWO),
        new Student("孙初三", 15, false, Student.Grade.JUNIOR_THREE),
        new Student("王初一", 12, false, Student.Grade.JUNIOR_ONE),
        new Student("钱初二", 14, false, Student.Grade.JUNIOR_TWO),
        new Student("周初三", 16, false, Student.Grade.JUNIOR_THREE));
List<Student> resultStudent = new ArrayList<>(); //垃圾变量，一次性的中间变量
//foreach循环，根据条件筛选元素
for (Student student : students) {
    if (student.getAge() < 14) {
        resultStudent.add(student);
    }
}
//匿名类，给元素排序
Collections.sort(resultStudent, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return Integer.compare(o1.getAge(), o2.getAge());
    }
});
List<String> resultName = new ArrayList<>();
//foreach循环，获取元素属性
for (Student student : resultStudent) {
    resultName.add(student.getName());
}

Java 8流的实现方式：

List<String> resultName = students.stream()
        .filter(student -> student.getAge() < 14) //年龄筛选
        .sorted(Comparator.comparing(Student::getAge)) //年龄排序
        .map(Student::getName) //提取姓名
        .collect(Collectors.toList());//将提取的姓名保存在List中

为了利用多核架构并行执行这段代码，只需要把stream()替换成parallelStream()即可。

通过对比两段代码之后，Java8流的方式有几个显而易见的好处。

代码是以声明性的方式写的：说明想要做什么（筛选小于14岁的学生）而不是去说明怎么去做（循环、if）
将几个基础操作链接起来，表达复杂的数据处理流水线（filter->sorted->map->collect）,同时保持代码清晰可读。

总结一下，Java 8的Stream API带来的好处：

声明性-更简洁，更易读
可复合-更灵活
可并行-性能更好

流简介

流到底是什么？简单定义：“从支持数据处理操作的源生成的元素序列”，下面剖析这个定义。

元素序列：像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序值。集合讲的是数据，流讲的是计算。
源：流使用一个提供数据的源，如集合、数组或输入/输出资源。
数据处理操作：流的数据处理功能之处类似于数据库的操作，以及函数式编程语言中的常用操作，如filter、map、reduce、find、match、sort等。流的操作可以顺序执行，也可以并行执行。
流水线：很多流的操作会返回一个流，这样多个操作就可以链接起来，形成一个流水线。可以看成数据库式查询。
内部迭代：于迭代器显示迭代的不同，流的迭代操作是在背后进行的。

看一段代码，更好理解这些概念

List<String> resultName = students.stream() //从列表中获取流
        .filter(student -> student.getAge() < 16) //操作流水线：筛选
        .map(Student::getName) //操作流水线：提取姓名
        .limit(2) //操作流水线：只取2个
        .collect(Collectors.toList());//将结果保存在List中

在上面代码中，数据源是学生列表（students），用来给流提供一个元素序列，调用stream()获取一个流，接下来就是一系列数据处理操作：filter、map、limit和collect。除collect之外，所有这些操作都会返回一个流，组成了一条流水线。最后collect操作开始处理流水线，并返回结果。

流与集合

粗略的说，流与集合之间的差异就在于什么时候进行计算。

集合是一个内存中的数据结构（可以添加或者删除），它包含数据结构中目前所有的值——集合中的每个元素都是预先处理好然后添加到集合中的。
流则是在概念上固定的数据结构（不能添加或删除元素），其元素是按需计算的。

在哲学中，流被看作在时间中分布的一组值，而集合则是空间（计算机内存）中分布的一组值，在一个时间点上全体存在。

只能遍历一次

和迭代器类似，流只能遍历一次。遍历完成之后，我们说这个流已经被消费掉了。

例如下面的代码会抛出异常

Stream<Student> stream = students.stream();
stream.forEach(System.out::println);
stream.forEach(System.out::println);

执行之后抛出如下异常：

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
	at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
	at com.example.demo.java8.stream.StreamTest.main(StreamTest.java:58)

所以要记得，流只能消费一次。

外部迭代与内部迭代

我们使用iterator或者foreach遍历集合时的这种迭代方式被称为外部迭代，而Streams库使用内部迭代，它帮你把迭代做了，还把得到的流值存在了某个地方，你只要给出一个函数说要干什么就可以了。

下面的代码说明了这种区别。

外部迭代

//使用增强for循环做外部迭代，底层还是迭代器
List<String> resultName = new ArrayList<>();
for (Student student : students) {
    resultName.add(student.getName());
}
//使用迭代器做外部迭代
Iterator<Student> iterator = students.iterator();
while (iterator.hasNext()){
    Student student = iterator.next();
    resultName.add(student.getName());
}

内部迭代

List<String> resultName = students.stream()
        .map(Student::getName)
        .collect(Collectors.toList());

流操作

java.util.stream中的Stream接口定义了许多操作。可以分为两大类。先看一下下面这个例子：

List<String> resultName = students.stream() //从列表中获取流
        .filter(student -> student.getAge() < 16) //中间操作
        .map(Student::getName) //中间操作
        .limit(2) //中间操作
        .collect(Collectors.toList());//将Stream转为List

可以看到两类操作：

filter、map和limit链接的一条流水线
collect触发流水线执行并关闭它
流水线中流的操作称为中间操作，关闭流的操作称为终端操作

中间操作

诸如filter或sorted等中间操作会返回一个流，这让很多操作链接起来形成一个复合的流水线（查询）。重要的是，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理——它们很懒（延迟计算/惰性求值）。
因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。
修改一下上面的代码，看一下发生了什么：

List<String> resultName = students.stream() //从列表中获取流
        .filter(student -> {
            System.out.println("filter："+student.getName());
            return student.getAge() < 16;
        }) //中间操作
        .map(student -> {
            System.out.println("map："+student.getName());
            return student.getName();
        }) //中间操作
        .limit(3) //中间操作
        .collect(Collectors.toList());//将Stream转为List

执行结果如下：

filter：张初一
map：张初一
filter：李初二
map：李初二
filter：孙初三
map：孙初三

可以发现，利用流的延迟性质实现了几个好的优化。limit操作实现了只选择前3个，filter和map操作是相互独立的操作，但他们合并到同一次遍历中。

终端操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如List、Integer，亦或是void等。

流的使用

流的使用一般包括三件事：

一个数据源（如集合）来执行一个查询
一个中间操作链，形成一条流水线
一个终端操作，执行流水线，并生成结果

流的流水线背后的理念类似于构建器模式。在构建器模式中有一个调用链来设置一套配置（对流来说这就是一个中间操作链），接着时调用build方法（对流来说就是终端操作）。

使用流

Stream API支持许多操作，这些操作能帮助我们快速完成复杂的数据查询，如筛选、切片、映射、查找、匹配和归约。

筛选和切片

用谓词筛选，筛选出各不相同的元素，忽略流中的头几个元素，或将流截短至指定长度。

用谓词筛选 `filter`

流支持filter方法，该方法接受一个谓词（一个返回boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。例如，下面的代码就是筛选是团员的学生：

List<Student> memberList = students.stream()
        .filter(Student::isMember) //方法引用检查学生是否是团员
        .collect(Collectors.toList());

去重元素 `distinct`

流支持distinct方法，该方法可以将列表中的元素去重（根据流所生成元素的hashCode和equals方法实现）的流。例如下面的代码事筛选列表中的偶数，并去重：

List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 2, 4, 6);
numberList.stream()
        .filter(n -> n % 2 == 0)
        .distinct()
        .forEach(System.out::println);

截短流 `limit`

流支持limit(n)方法，该方法返回一个不超过给定长度的流。如果是有序的流，则最多返回前n个元素。例如，筛选出小于14岁的前三个学生：

List<Student> studentList = students.stream()
        .filter(student -> student.getAge() < 14)
        .limit(3)
        .collect(Collectors.toList());

跳过元素 `skip`

流支持skip(n)方法，该方法返回一个跳过了前n个元素的流。如果流中的元素不足n个，则返回一个空流。例如，跳过年龄小于14岁的头三个学生，返回剩下的。

List<Student> studentList = students.stream()
        .filter(student -> student.getAge() < 14)
        .skip(3)
        .collect(Collectors.toList());

映射

有时候当我们在处理数据时，需要从一系列对象中提取某个属性值，比如从SQL表中选择一列。Stream API通过map和flatMap方法提供了类似的工具。

对流中的每一个元素应用函数 `map`

流支持map方法，该方法接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素。例如，需要提取学生列表中的学生姓名：

List<String> studentList = students.stream()
        .map(Student::getName)//getName会返回String，此时map返回的就是Stream<String>
        .collect(Collectors.toList());

如果需要进一步操作，例如获取姓名的长度，在链接上一个map即可：

List<Integer> studentList = students.stream()
        .map(Student::getName)
        .map(String::length)
        .collect(Collectors.toList());

流的扁平化 `flatMap`

先举个例子，我们需要从["hello", "world"]单词列表中提取每个字符并去重，结果应该是["h", "e", "l", "o", "w", "r", "d"]。

我们可能会写出下面这样的代码：

List<String> wordList = Arrays.asList("hello","word");
List<String[]> result = wordList.stream()
        .map(word -> word.split(""))
        .distinct()
        .collect(Collectors.toList());

但实际上map返回的是Stream<String[]>，或者我们又写出下面这样的代码：

List<String> wordList = Arrays.asList("hello","word");
List<Stream<String>> result = wordList.stream()
        .map(word -> word.split(""))
        .map(Arrays::stream)
        .distinct()
        .collect(Collectors.toList());

但实际上map返回的是Stream<Stream<String>>，而我们真想想要的是Stream<String> 。

这时候flatMap就派上用场了：

List<String> wordList = Arrays.asList("hello","word");
List<String> result = wordList.stream()
        .map(w -> w.split(""))
        .flatMap(Arrays::stream)
        .distinct()
        .collect(Collectors.toList());
System.out.println(result);

map(Arrays::stream)是将每个元素都映射成一个流，而flatMap方法效果将映射的流合并起来，即扁平化一个流。意思就是将流中的每个值都转换成一个流，然后把所有的流连接起来成为一个流

查找和匹配

还有在处理数据时，我们会判断一个集合中的某些元素是否符合给定的条件。Stream API通过allMatch、anyMatch、noneMatch、findFirst和findAny方法提供了这样的工具。

检查谓词是否至少匹配一个元素 `anyMatch`

anyMatch方法可以用来判断“流中是否有一个元素能匹配给定的谓词”。

if(students.stream().anyMatch(Student::isMember)) {
    System.out.println("学生列表中至少有一个是团员！");
}

anyMatch方法返回一个boolean，是一个终端操作。

检查谓词是否匹配所有元素 `allMatch` `noneMatch`

allMatch方法可以用来判断“流中是否所有的元素都能匹配给定的谓词”

if (students.stream().allMatch(student -> student.getAge() < 18)) {
    System.out.println("学生列表中所有学生的年龄都小于18岁！");
}

noneMatch和allMatch是相对的，用来判断“流中的所有元素都不能匹配给定的谓词”

if (students.stream().noneMatch(student -> student.getAge() >= 18)) {
    System.out.println("学生列表中没有学生的年龄大于等于18岁！");
}

anyMatch、allMatch和noneMatch这三个操作都用到了我们所谓的短路，这就是我们熟悉的Java中的&&和||运算符短路在流中的版本。

查找元素 `findAny`

findAny方法返回当前流中的任意元素。可与其他流操作相结合使用。例如，我们需要找到一个学生列表中的团员：

Optional<Student> studentOptional = students.stream()
        .filter(Student::isMember)
        .findAny();

不过这个Optional是什么？

Optional简介
Optional<T>类(java.util.Optional)是一个容器类，代表一个值存在或不存在。上面代码中有可能什么元素都没有找到。Java 8引入Optional<T>用来避免null带来的异常。

先简单了解下它的几个方法：

isPresent()：若Optional包含值则返回true，否则返回false。
ifPresent(Consumer<? super T> consumer)：若Optional包含值时执行给定的代码。参数是Consumer，一个函数式接口。
T get()：若Optional包含值时返回该值，否则抛出NoSuchElementException异常。
T orElse(T other)：若Optional包含值时返回该值，否则返回指定默认值。

例如，前面的studentOptional若包含一个学生，我们就打印该学生的姓名，否则就什么也不做。

studentOptional.ifPresent(student -> System.out.println(student.getName()));

查找第一个元素 `findFirst`

findFirst方法返回当前流中的第一个元素。在某些顺序流中，我们要找到第一个元素，这时可以使用findFirst，例如，给定一个数字列表，找到其中第一个平方根能被2整除的数：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Optional<Integer> first = numbers.stream()
        .map(n -> n * n)
        .filter(n -> n % 2 == 0)
        .findFirst();
first.ifPresent(n -> System.out.println(n));// 4

我们会发现findAny和findFirst的工作方式是类似的，那我们什么时候使用findFirst和findAny呢？
findFirst在并行上限制很多，所以如果不关心返回元素是哪一个（不关心顺序），请使用findAny，因为在并行时限制较少。

归约 `reduce`

reduce操作可以将一个流中的元素组合起来，得到一个值。

元素求和

使用foreach循环求和：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = 0;
for (Integer number : numbers) {
    sum += number;
}

这里通过反复加法，把一个列表归约成一个数字。如果是计算相乘的结果，是不是还要复制粘贴这段代码？大可不必，reduce操作将这种模式做了抽象。用reduce求和：

Integer sum = numbers.stream().reduce(0, (a, b) -> a + b);

这里reduce()接受两个参数:

初始值，这里是0
BinaryOperator<T>组合两个元素产生新值，这里是Lambda(a, b) -> a + b
如果是相乘，则只需传递Lambda(a, b) -> a * b即可：

Integer result = numbers.stream().reduce(0, (a, b) -> a * b);

Java 8中，Integer类有了static int sum(int a, int b)方法来求两个数的和，这刚好是BinaryOperator类型的值，所以代码可以更精简，更易读：

Integer sum = numbers.stream().reduce(0, Integer::sum);

reduce还有一个重载版本，不接受初始值，返回一个Optional<T>对象，考虑流中没有任何元素，也没有初始值，所以reduce无法返回结果，此时Optional中的值就不存在。

最大值和最小值

类比求和的操作，我们传递Lambda(a, b) -> a > b ? a : b即可：

numbers.stream().reduce((a, b) -> a > b ? a : b);

相同的Java 8中的Integer也新增了max和min来求两个数中的最大和最小值，则可以写成：

Optional<Integer> max = numbers.stream().reduce(Integer::max);
Optional<Integer> min = numbers.stream().reduce(Integer::min);

数值流

前面用reduce计算流中元素的中和，现在我想计算学生列表中学生的年龄总和，就可以这么写：

students.stream().map(Student::getAge)
        .reduce(0, Integer::sum);

但是这里暗含了装箱成本。Integer需要被拆箱成原始类型，在进行求和。所以Stream API提供了原始类型流特化，专门支持处理数流的方法。

原始类型流

Java 8中引入了三个原始类型流：IntStream、DoubleStream和LongStream，分别将流中的元素转化为int、long和double，从而避免暗含装箱成本。每个接口都带来了进行常用数值归约的新方法，如对数值流求和的sum，找到最大元素的max，还可以把它们再转回对象流。

映射到数值流 mapToInt mapToDouble mapToLong

students.stream()
        .mapToInt(Student::getAge)
        .sum();

转回对象流 .boxed()

Stream<Integer> stream = students.stream()
        .mapToInt(Student::getAge)
        .boxed();

默认值 OptionalInt OptionalDouble OptionalLong

OptionalInt optionalInt = students.stream()
        .mapToInt(Student::getAge)
        .max();

数值范围 `range` `rangeClosed`

Java 8引入了两个可以用于IntStream和LongStream的静态方法，帮助我们生成一个数值范围。range和rangeClosed，两个方法接收两个参数第一个是起始值，第二个是结束值。前者不包含结束值，后者包含结束值。

IntStream range = IntStream.range(1, 100);
System.out.println(range.count());//99
IntStream intStream = IntStream.rangeClosed(1, 100);
System.out.println(intStream.count());//100

数值流例子

100以内的勾股数：a*a + b*b = c*c，a、b、c都是整数。

IntStream.rangeClosed(1, 100)
        .boxed()
        .flatMap(a ->
                IntStream.rangeClosed(a, 100)
                        .mapToObj(b -> new double[]{a, b, Math.sqrt(a * a + b * b)})
                        .filter(ints -> ints[2] % 1 == 0))
        .forEach(t -> 
                System.out.println((int) t[0] + "--" + (int) t[1] + "--" + (int) t[2]));

构建流

前面我们已经了解了很多流的的操作，并且知道通过stream方法从集合生成流以及根据数值范围创建数值流。下面我们我们介绍如何从序列、数组、文件和生成函数来创建流。

由序列创建流 `Stream.of`

使用静态方法Stream.of显示的创建一个流，该方法接受任意数量的参数。

//创建一个字符串流
Stream<String> stringStream = Stream.of("A", "B", "C", "D", "E");
//创建一个空流
Stream.empty();

由数组创建流 `Arrays.stream`

使用静态方法Arrays.stream从数组创建一个流，该方法接受一个数组参数。

int[] num = {1,2,3,4,5};
IntStream stream = Arrays.stream(num);
System.out.println(stream.sum());//15

由文件生成流

Java 8更新了NIO API（非阻塞 I/O），其中java.nio.file.Files中新增了许多静态方法可以返回一个流，如Files.lines()该方法接受一个文件路径对象（Path对象），返回由指定文件中每一行组成的字符串流。下面的代码用来计算这个文件中有多少个不同的字符：

try (Stream<String> lines = Files.lines(Paths.get("C:\\Users\\symon\\Desktop\\test.txt"), Charset.defaultCharset())) {
    long count = lines
            .flatMap(line -> {
                System.out.println(line);
                return Arrays.stream(line.split(""));
            })
            .distinct()
            .count();
    System.out.println(count);
} catch (IOException e) {
    e.printStackTrace();
}

由函数生成流，创建无限流

Stream API提供了两个静态方法来生成流：Stream.iterate()和Stream.generate()。这两个操作可以创建所谓的无限流：没有固定大小的流。一般来说，会使用limit(n)来进行限制，避免无尽地计算下去。

迭代 `Stream.iterate`

Stream.iterate(0, n -> n + 2)
        .limit(20)
        .forEach(System.out::println);

iterate方法接受一个初始值（这里是0），还有一个依次应用在每个产生的新值上的Lambda（UnaryOperator<T>类型）。这里是n -> n + 2，返回前一个元素加2。所以上面代码生成了一个正偶数流。如果不加limit限制，则会永远计算下去。

生成 `Stream.generate`

Stream.generate(Math::random)
        .limit(10)
        .forEach(System.out::println);

generate方法接受一个Supplier<T>类型的Lambda作为参数，不会像iterate一样对每个新生成的值应用函数。上面代码是取10个0~1之间的随机数。同样，如果不加limit限制，该流也会无限长。

posted @ 2022-10-25 16:54 西瓜柠檬汁阅读(540) 评论(1) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Symon

微信公众号：西瓜柠檬汁

Java 8 Stream API 引入和使用

引入流

流是什么

流简介

流与集合

只能遍历一次

外部迭代与内部迭代

流操作

中间操作

终端操作

流的使用

使用流

筛选和切片

用谓词筛选 filter

去重元素 distinct

截短流 limit

跳过元素 skip

映射

对流中的每一个元素应用函数 map

流的扁平化 flatMap

查找和匹配

检查谓词是否至少匹配一个元素 anyMatch

检查谓词是否匹配所有元素 allMatch noneMatch

查找元素 findAny

查找第一个元素 findFirst

归约 reduce