45. 【Java教程】流式操作

本文主要是介绍45. 【Java教程】流式操作，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

流式操作，是 Java 8 除了Lambda表达式外的又一重大改变。学习流式操作，就是学习java.util.stream包下的API，我们称之为Stream API，它把真正的函数式编程引入到了 Java 中。

本小节我们将了解到什么是Stream，为什么使用Stream API， 流式操作的执行流程，如何实例化Stream，Stream的中间操作、Stream的终止操作等内容。

1. 什么是 Stream

Stream是数据渠道，用于操作数据源所生成的元素序列，它可以实现对集合（Collection）的复杂操作，例如查找、替换、过滤和映射数据等操作。

我们这里说的Stream不同于java的输入输出流。另外，Collection 是一种静态的数据结构，存储在内存中，而Stream是用于计算的，通过CPU实现计算。注意不要混淆。

Tips：Stream自己不会存储数据；Stream不会改变源对象，而是返回一个新的持有结果的Stream（不可变性）；Stream操作是延迟执行的（这一点将在后面介绍）。

2. 为什么使用 Stream API

我们在实际开发中，项目中的很多数据都来源于关系型数据库（例如 MySQL、Oracle 数据库），我们使用SQL的条件语句就可以实现对数据的筛选、过滤等等操作；

但也有很多数据来源于非关系型数据库（Redis、MongoDB等），想要处理这些数据，往往需要在 Java 层面去处理。

使用Stream API对集合中的数据进行操作，就类似于 SQL 执行的数据库查询。也可以使用Stream API来执行并行操作。简单来说，Stream API提供了一种高效且易于使用的处理数据的方式。

3. 流式操作的执行流程

流式操作通常分为以下 3 个步骤：

1. 创建Stream对象：通过一个数据源（例如集合、数组），获取一个流；

2. 中间操作：一个中间的链式操作，对数据源的数据进行处理（例如过滤、排序等），直到执行终止操作才执行；

3. 终止操作：一旦执行终止操作，就执行中间的链式操作，并产生结果。

下图展示了Stream的执行流程：

接下来我们就按照这 3 个步骤的顺序来展开学习Stream API。

4. Stream 对象的创建

有 4 种方式来创建Stream对象。

4.1 通过集合创建 Stream

Java 8 的java.util.Collection 接口被扩展，提供了两个获取流的默认方法：

• default Stream<E> stream()：返回一个串行流（顺序流）；

• default Stream<E> parallelStream()：返回一个并行流。

实例如下：

// 创建一个集合，并添加几个元素  
List<String> stringList = new ArrayList<>();  
stringList.add("hello");  
stringList.add("world");  
stringList.add("java");  
​  
// 通过集合获取串行 stream 对象  
Stream<String> stream = stringList.stream();  
// 通过集合获取并行 stream 对象  
Stream<String> personStream = stringList.parallelStream();

串行流并行流的区别是：串行流从集合中取数据是按照集合的顺序的；而并行流是并行操作的，获取到的数据是无序的。

4.2 通过数组创建 Stream

Java 8 中的java.util.Arrays的静态方法stream()可以获取数组流：

• static <T> Stream<T> stream(T[] array)：返回一个数组流。

此外，stream()还有几个重载方法，能够处理对应的基本数据类型的数组：

• public static IntStream stream(int[] array)：返回以指定数组作为其源的连续IntStream；

• public static LongStream stream(long[] array)：返回以指定数组作为其源的连续LongStream；

• public static DoubleStream stream(double[] array)：返回以指定数组作为其源的连续DoubleStream。

实例如下：

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;public class StreamDemo1 {public static void main(String[] args) {// 初始化一个整型数组int[] arr = new int[]{1,2,3};// 通过整型数组，获取整形的 stream 对象IntStream stream1 = Arrays.stream(arr);// 通过字符串类型的数组，获取泛型类型为 String 的 stream 对象String[] stringArr = new String[]{"Hello", "mybj"};Stream<String> stream2 = Arrays.stream(stringArr);}
}

4.3 通过 Stream 的 of()方法

可以通过Stream类下的of()方法来创建 Stream 对象，实例如下：

import java.util.stream.Stream;public class StreamDemo1 {public static void main(String[] args) {// 通过 Stream 类下的 of() 方法，创建 stream 对象、Stream<Integer> stream = Stream.of(1, 2, 3);}
}

4.4 创建无限流

可以使用Stream类下的静态方法iterate()以及generate()创建无限流：

• public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)：遍历；

• public static<T> Stream<T> generate(Supplier<T> s)：生成。

创建无限流的这种方式实际使用较少，大家了解一下即可。

5. Stream 的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理。在终止操作时会一次性全部处理这些中间操作，称为“惰性求值”。下面，我们来学习一下常用的中间操作方法。

5.1 筛选与切片

关于筛选和切片中间操作，有下面几个常用方法：

• filter(Predicate p)：接收 Lambda，从流中清除某些元素；

• distinct()：筛选，通过流生成元素的hashCode和equals()方法去除重复元素；

• limit(long maxSize)：截断流，使其元素不超过给定数量；

• skip(long n)：跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与limit(n)互补。

我们先来看一个过滤集合元素的实例：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;public class StreamDemo2 {static class Person {private String name;private int age;public Person() { }public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}}/*** 创建一个Person的集合* @return List*/public static List<Person> createPeople() {ArrayList<Person> people = new ArrayList<>();Person person1 = new Person("小明", 15);Person person2 = new Person("小芳", 20);Person person3 = new Person("小李", 18);Person person4 = new Person("小付", 23);Person person5 = new Person("大飞", 22);people.add(person1);people.add(person2);people.add(person3);people.add(person4);people.add(person5);return people;}public static void main(String[] args) {List<Person> people = createPeople();// 创建 Stream 对象Stream<Person> stream = people.stream();// 过滤年龄大于 20 的personStream<Person> personStream = stream.filter(person -> person.getAge() >= 20);// 触发终止操作才能执行中间操作，遍历列表中元素并打印personStream.forEach(System.out::println);}
}

运行结果：

Person{name='小芳', age=20}  
Person{name='小付', age=23}  
Person{name='大飞', age=22}

实例中，有一个静态内部类Person以及一个创建Person的集合的静态方法createPeople()，在主方法中，我们先调用该静态方法获取到一个Person列表，然后创建了Stream对象，再执行中间操作（即调用fliter()方法），这个方法的参数类型是一个断言型的函数式接口，接口下的抽象方法test()要求返回boolean结果，因此我们使用Lambda表达式，Lambda体为person.getAge() >= 20，其返回值就是一个布尔型结果，这样就实现了对年龄大于等于 20 的person对象的过滤。

由于必须触发终止操作才能执行中间操作，我们又调用了forEach(System.out::println)，在这里记住它作用是遍历该列表并打印每一个元素即可，我们下面将会讲解。另外，filter()等这些由于中间操作返回类型为 Stream，所以支持链式操作，我们可以将主方法中最后两行代码合并成一行：

stream.filter(person -> person.getAge() >= 20).forEach(System.out::println);

我们再来看一个截断流的使用实例：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;public class StreamDemo3 {static class Person {private String name;private int age;public Person() { }public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}}/*** 创建一个Person的集合* @return List*/public static List<Person> createPeople() {ArrayList<Person> people = new ArrayList<>();Person person1 = new Person("小明", 15);Person person2 = new Person("小芳", 20);Person person3 = new Person("小李", 18);Person person4 = new Person("小付", 23);Person person5 = new Person("大飞", 22);people.add(person1);people.add(person2);people.add(person3);people.add(person4);people.add(person5);return people;}public static void main(String[] args) {List<Person> people = createPeople();// 创建 Stream 对象Stream<Person> stream = people.stream();// 截断流，并调用终止操作打印集合中元素stream.limit(2).forEach(System.out::println);}
}

运行结果：

Person{name='小明', age=15}  
Person{name='小芳', age=20}

根据运行结果显示，我们只打印了集合中的前两条数据。

跳过前 2 条数据的代码实例如下：

// 非完整代码
public static void main(String[] args) {List<Person> people = createPeople();// 创建 Stream 对象Stream<Person> stream = people.stream();// 跳过前两个元素，并调用终止操作打印集合中元素stream.skip(2).forEach(System.out::println);
}

运行结果：

Person{name='小李', age=18}  
Person{name='小付', age=23}  
Person{name='大飞', age=22}

distinct()方法会根据equals()和hashCode()方法筛选重复数据，我们在Person类内部重写这两个方法，并且在createPerson()方法中，添加几个重复的数据 ，实例如下：

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;public class StreamDemo4 {static class Person {private String name;private int age;public Person() { }public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return age == person.age &&Objects.equals(name, person.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}}/*** 创建一个Person的集合* @return List*/public static List<Person> createPeople() {ArrayList<Person> people = new ArrayList<>();people.add(new Person("小明", 15));people.add(new Person("小芳", 20));people.add(new Person("小李", 18));people.add(new Person("小付", 23));people.add(new Person("小付", 23));people.add(new Person("大飞", 22));people.add(new Person("大飞", 22));people.add(new Person("大飞", 22));return people;}public static void main(String[] args) {List<Person> people = createPeople();// 创建 Stream 对象Stream<Person> stream = people.stream();System.out.println("去重前，集合中元素有：");stream.forEach(System.out::println);System.out.println("去重后，集合中元素有：");// 创建一个新流Stream<Person> stream1 = people.stream();// 截断流，并调用终止操作打印集合中元素stream1.distinct().forEach(System.out::println);}
}

运行结果：

去重前，集合中元素有：  
Person{name='小明', age=15}  
Person{name='小芳', age=20}  
Person{name='小李', age=18}  
Person{name='小付', age=23}  
Person{name='小付', age=23}  
Person{name='大飞', age=22}  
Person{name='大飞', age=22}  
Person{name='大飞', age=22}  
去重后，集合中元素有：  
Person{name='小明', age=15}  
Person{name='小芳', age=20}  
Person{name='小李', age=18}  
Person{name='小付', age=23}  
Person{name='大飞', age=22}

5.2 映射

关于映射中间操作，有下面几个常用方法：

• map(Function f)：接收一个方法作为参数，该方法会被应用到每个元素上，并将其映射成一个新的元素；

• mapToDouble(ToDoubleFunction f)：接收一个方法作为参数，该方法会被应用到每个元素上，产生一个新的DoubleStream；

• mapToLong(ToLongFunction f)：接收一个方法作为参数，该方法会被应用到每个元素上，产生一个新的LongStream；

• flatMap(Function f)：接收一个方法作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

请查看如下实例：

import java.util.Arrays;
import java.util.List;public class StreamDemo5 {public static void main(String[] args) {// 创建一个包含小写字母元素的字符串列表List<String> stringList = Arrays.asList("php", "js", "python", "java");// 调用 map() 方法，将String下的toUpperCase()方法作为参数，这个方法会被应用到每个元素上，映射成一个新元素，最后打印映射后的元素stringList.stream().map(String::toUpperCase).forEach(System.out::println);}}

运行结果：

PHP  
JS  
PYTHON  
JAVA

可参考下图，理解映射的过程：

5.3 排序

关于排序中间操作，有下面几个常用方法：

• sorted()：产生一个新流，其中按照自然顺序排序；

• sorted(Comparator com)：产生一个新流，其中按照比较器顺序排序。

请查看如下实例：

import java.util.Arrays;
import java.util.List;public class StreamDemo6 {public static void main(String[] args) {List<Integer> integers = Arrays.asList(10, 12, 9, 8, 20, 1);// 调用sorted()方法自然排序，并打印每个元素integers.stream().sorted().forEach(System.out::println);}}

运行结果：

1  
8  
9  
10  
12  
20

上面实例中，我们调用sorted()方法对集合元素进行了从小到大的自然排序，那么如果想要实现从大到小排序，任何实现呢？此时就要用到sorted(Comparator com)方法定制排序，查看如下实例：

import java.util.Arrays;
import java.util.List;public class StreamDemo6 {public static void main(String[] args) {List<Integer> integers = Arrays.asList(10, 12, 9, 8, 20, 1);// 定制排序integers.stream().sorted((i1, i2) -> -Integer.compare(i1, i2)).forEach(System.out::println);}}

运行结果：

20
12
10
9
8
1

实例中，sorted()方法接收的参数是一个函数式接口Comparator，因此使用Lambda表达式创建函数式接口实例即可，Lambda体调用整型的比较方法，对返回的整型值做一个取反即可。

6. Stream 的终止操作

执行终止操作会从流的流水线上生成结果，其结果可以是任何不是流的值，例如List、String、void。

在上面实例中，我们一直在使用forEach()方法来执行流的终止操作，下面我们看看还有哪些其他终止操作。

6.1 匹配与查找

关于匹配与查找的终止操作，有下面几个常用方法：

• allMatch(Predicate p)：检查是否匹配所有元素；

• anyMatch(Predicate p)：检查是否至少匹配一个元素；

• noneMatch(Predicate p)：检查是否没有匹配所有元素；

• findFirst()：返回第一个元素；

• findAny()：返回当前流中的任意元素；

• count()：返回流中元素总数；

• max(Comparator c)：返回流中最大值；

• min(Comparator c)：返回流中最小值；

• forEach(Consumer c)：内部迭代（使用 Collection 接口需要用户去做迭代，称为外部迭代；相反 Stream API使用内部迭代）。

如下实例，演示了几个匹配元素相关方法的使用：

import java.util.Arrays;
import java.util.List;public class StreamDemo7 {public static void main(String[] args) {// 创建一个整型列表List<Integer> integers = Arrays.asList(10, 12, 9, 8, 20, 1);// 使用 allMatch(Predicate p) 检查是否匹配所有元素，如果匹配，则返回 true；否则返回 falseboolean b1 = integers.stream().allMatch(integer -> integer > 0);if (b1) {System.out.println(integers + "列表中所有的元素都大于0");} else {System.out.println(integers + "列表中不是所有的元素都大于0");}// 使用 anyMatch(Predicate p) 检查是否至少匹配一个元素boolean b2 = integers.stream().anyMatch(integer -> integer >= 20);if (b2) {System.out.println(integers + "列表中至少存在一个的元素都大于等于20");} else {System.out.println(integers + "列表中不存在任何一个大于等于20的元素");}// 使用 noneMath(Predicate p) 检查是否没有匹配所有元素boolean b3 = integers.stream().noneMatch(integer -> integer > 100);if (b3) {System.out.println(integers + "列表中不存在大于100的元素");} else {System.out.println(integers + "列表中存在大于100的元素");}}}

运行结果：

[10, 12, 9, 8, 20, 1]列表中所有的元素都大于0
[10, 12, 9, 8, 20, 1]列表中至少存在一个的元素都大于等于20
[10, 12, 9, 8, 20, 1]列表中不存在大于100的元素

查找元素的相关方法使用实例如下：

import java.util.Arrays;
import java.util.List;
import java.util.Optional;public class StreamDemo8 {public static void main(String[] args) {// 创建一个整型列表List<Integer> integers = Arrays.asList(10, 12, 9, 8, 20, 1);// 使用 findFirst() 获取当前流中的第一个元素Optional<Integer> first = integers.stream().findFirst();System.out.println(integers + "列表中第一个元素为：" + first);// 使用 findAny() 获取当前流中的任意元素Optional<Integer> any = integers.stream().findAny();System.out.println("列表中任意元素：" + any);// 使用 count() 获取当前流中元素总数long count = integers.stream().count();System.out.println(integers + "列表中元素总数为" + count);// 使用 max(Comparator c) 获取流中最大值Optional<Integer> max = integers.stream().max(Integer::compare);System.out.println(integers + "列表中最大值为" + max);// 使用 min(Comparator c) 获取流中最小值Optional<Integer> min = integers.stream().min(Integer::compare);System.out.println(integers + "列表中最小值为" + min);}}

运行结果：

[10, 12, 9, 8, 20, 1]列表中第一个元素为：Optional[10]
列表中任意元素：Optional[10]
[10, 12, 9, 8, 20, 1]列表中元素总数为6
[10, 12, 9, 8, 20, 1]列表中最大值为Optional[20]
[10, 12, 9, 8, 20, 1]列表中最小值为Optional[1]

实例中，我们观察到findFirst()、findAny()、max()等方法的返回值类型为Optional类型，关于这个Optional类，我们将在下一小节具体介绍。

6.2 归约

关于归约的终止操作，有下面几个常用方法：

• reduce(T identity, BinaryOperator b)：可以将流中的元素反复结合起来，得到一个值。返回 T；

• reduce(BinaryOperator b)：可以将流中的元素反复结合起来，得到一个值，返回 Optional<T>。

归约相关方法的使用实例如下：

import java.util.Arrays;
import java.util.List;
import java.util.Optional;public class StreamDemo9 {public static void main(String[] args) {// 创建一个整型列表List<Integer> integers = Arrays.asList(10, 12, 9, 8, 20, 1);// 使用 reduce(T identity, BinaryOperator b) 计算列表中所有整数和Integer sum = integers.stream().reduce(0, Integer::sum);System.out.println(sum);// 使用 reduce(BinaryOperator b) 计算列表中所有整数和，返回一个 Optional<T>Optional<Integer> reduce = integers.stream().reduce(Integer::sum);System.out.println(reduce);}}

运行结果：

60
Optional[60]

6.3 收集

collect(Collector c)：将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。

实例如下：

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;public class StreamDemo10 {public static void main(String[] args) {// 创建一个整型列表List<Integer> integers = Arrays.asList(10, 12, 9, 8, 20, 1, 10);Set<Integer> collect = integers.stream().collect(Collectors.toSet());System.out.println(collect);}}

运行结果：

[1, 20, 8, 9, 10, 12]

Collector 接口中的实现决定了如何对流执行收集的操作（如收集到 List、Set、Map）。java.util.stream.Collectors 类提供了很多静态方法，可以方便地创建常用收集器实例，常用静态方法如下：

• static List<T> toList()：把流中元素收集到List；

• static Set<T> toSet()：把流中元素收集到Set；

• static Collection<T> toCollection()：把流中元素收集到创建的集合。

7. 小结

通过本小节的学习，我们知道了Stream不同于java.io下的输入输出流，它主要用于处理数据。Stream API可用于处理非关系型数据库中的数据；想要使用流式操作，就要知道创建Stream对象的几种方式；流式操作可分为创建Stream对象、中间操作和终止操作三个步骤。多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理。执行终止操作会从流的流水线上生成结果，其结果可以是任何不是流的值。

这篇关于45. 【Java教程】流式操作的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---