流式操作,是 Java 8 除了Lambda表达式外的又一重大改变。学习流式操作,就是学习java.util.stream包下的API,我们称之为Stream API,它把真正的函数式编程引入到了 Java 中。
本小节我们将了解到什么是Stream为什么使用Stream API流式操作的执行流程如何实例化StreamStream的中间操作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.jpg
接下来我们就按照这 3 个步骤的顺序来展开学习Stream API。

4. Stream 对象的创建

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

4.1 通过集合创建 Stream

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

  • default Stream stream():返回一个串行流(顺序流);
  • default Stream parallelStream():返回一个并行流。

实例如下:

  1. // 创建一个集合,并添加几个元素
  2. List<String> stringList = new ArrayList<>();
  3. stringList.add("hello");
  4. stringList.add("world");
  5. stringList.add("java");
  6. // 通过集合获取串行 stream 对象
  7. Stream<String> stream = stringList.stream();
  8. // 通过集合获取并行 stream 对象
  9. Stream<String> personStream = stringList.parallelStream();

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

4.2 通过数组创建 Stream

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

  • static Stream 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。

实例如下:

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

4.3 通过 Stream 的 of()方法

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

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

4.4 创建无限流

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

  • public static Stream iterate(final T seed, final UnaryOperator f):遍历;
  • public static Stream generate(Supplier s):生成。

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

5. Stream 的中间操作

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

5.1 筛选与切片

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

  • filter(Predicate p):接收 Lambda,从流中清除某些元素;
  • distinct():筛选,通过流生成元素的hashCode和equals()方法去除重复元素;
  • limit(long maxSize):截断流,使其元素不超过给定数量;
  • skip(long n):跳过元素,返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个,则返回一个空流。与limit(n)互补。

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

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.stream.Stream;
  4. public class StreamDemo2 {
  5. static class Person {
  6. private String name;
  7. private int age;
  8. public Person() { }
  9. public Person(String name, int age) {
  10. this.name = name;
  11. this.age = age;
  12. }
  13. public String getName() {
  14. return name;
  15. }
  16. public void setName(String name) {
  17. this.name = name;
  18. }
  19. public int getAge() {
  20. return age;
  21. }
  22. public void setAge(int age) {
  23. this.age = age;
  24. }
  25. @Override
  26. public String toString() {
  27. return "Person{" +
  28. "name='" + name + '\'' +
  29. ", age=" + age +
  30. '}';
  31. }
  32. }
  33. /**
  34. * 创建一个Person的集合
  35. * @return List
  36. */
  37. public static List<Person> createPeople() {
  38. ArrayList<Person> people = new ArrayList<>();
  39. Person person1 = new Person("小明", 15);
  40. Person person2 = new Person("小芳", 20);
  41. Person person3 = new Person("小李", 18);
  42. Person person4 = new Person("小付", 23);
  43. Person person5 = new Person("大飞", 22);
  44. people.add(person1);
  45. people.add(person2);
  46. people.add(person3);
  47. people.add(person4);
  48. people.add(person5);
  49. return people;
  50. }
  51. public static void main(String[] args) {
  52. List<Person> people = createPeople();
  53. // 创建 Stream 对象
  54. Stream<Person> stream = people.stream();
  55. // 过滤年龄大于 20 的person
  56. Stream<Person> personStream = stream.filter(person -> person.getAge() >= 20);
  57. // 触发终止操作才能执行中间操作,遍历列表中元素并打印
  58. personStream.forEach(System.out::println);
  59. }
  60. }

运行结果:

  1. Person{name='小芳', age=20}
  2. Person{name='小付', age=23}
  3. 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,所以支持链式操作,我们可以将主方法中最后两行代码合并成一行:

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

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

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.stream.Stream;
  4. public class StreamDemo3 {
  5. static class Person {
  6. private String name;
  7. private int age;
  8. public Person() { }
  9. public Person(String name, int age) {
  10. this.name = name;
  11. this.age = age;
  12. }
  13. public String getName() {
  14. return name;
  15. }
  16. public void setName(String name) {
  17. this.name = name;
  18. }
  19. public int getAge() {
  20. return age;
  21. }
  22. public void setAge(int age) {
  23. this.age = age;
  24. }
  25. @Override
  26. public String toString() {
  27. return "Person{" +
  28. "name='" + name + '\'' +
  29. ", age=" + age +
  30. '}';
  31. }
  32. }
  33. /**
  34. * 创建一个Person的集合
  35. * @return List
  36. */
  37. public static List<Person> createPeople() {
  38. ArrayList<Person> people = new ArrayList<>();
  39. Person person1 = new Person("小明", 15);
  40. Person person2 = new Person("小芳", 20);
  41. Person person3 = new Person("小李", 18);
  42. Person person4 = new Person("小付", 23);
  43. Person person5 = new Person("大飞", 22);
  44. people.add(person1);
  45. people.add(person2);
  46. people.add(person3);
  47. people.add(person4);
  48. people.add(person5);
  49. return people;
  50. }
  51. public static void main(String[] args) {
  52. List<Person> people = createPeople();
  53. // 创建 Stream 对象
  54. Stream<Person> stream = people.stream();
  55. // 截断流,并调用终止操作打印集合中元素
  56. stream.limit(2).forEach(System.out::println);
  57. }
  58. }

运行结果:

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

根据运行结果显示,我们只打印了集合中的前两条数据。
跳过前 2 条数据的代码实例如下:

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

运行结果:

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

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

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Objects;
  4. import java.util.stream.Stream;
  5. public class StreamDemo4 {
  6. static class Person {
  7. private String name;
  8. private int age;
  9. public Person() { }
  10. public Person(String name, int age) {
  11. this.name = name;
  12. this.age = age;
  13. }
  14. public String getName() {
  15. return name;
  16. }
  17. public void setName(String name) {
  18. this.name = name;
  19. }
  20. public int getAge() {
  21. return age;
  22. }
  23. public void setAge(int age) {
  24. this.age = age;
  25. }
  26. @Override
  27. public String toString() {
  28. return "Person{" +
  29. "name='" + name + '\'' +
  30. ", age=" + age +
  31. '}';
  32. }
  33. @Override
  34. public boolean equals(Object o) {
  35. if (this == o) return true;
  36. if (o == null || getClass() != o.getClass()) return false;
  37. Person person = (Person) o;
  38. return age == person.age &&
  39. Objects.equals(name, person.name);
  40. }
  41. @Override
  42. public int hashCode() {
  43. return Objects.hash(name, age);
  44. }
  45. }
  46. /**
  47. * 创建一个Person的集合
  48. * @return List
  49. */
  50. public static List<Person> createPeople() {
  51. ArrayList<Person> people = new ArrayList<>();
  52. people.add(new Person("小明", 15));
  53. people.add(new Person("小芳", 20));
  54. people.add(new Person("小李", 18));
  55. people.add(new Person("小付", 23));
  56. people.add(new Person("小付", 23));
  57. people.add(new Person("大飞", 22));
  58. people.add(new Person("大飞", 22));
  59. people.add(new Person("大飞", 22));
  60. return people;
  61. }
  62. public static void main(String[] args) {
  63. List<Person> people = createPeople();
  64. // 创建 Stream 对象
  65. Stream<Person> stream = people.stream();
  66. System.out.println("去重前,集合中元素有:");
  67. stream.forEach(System.out::println);
  68. System.out.println("去重后,集合中元素有:");
  69. // 创建一个新流
  70. Stream<Person> stream1 = people.stream();
  71. // 截断流,并调用终止操作打印集合中元素
  72. stream1.distinct().forEach(System.out::println);
  73. }
  74. }

运行结果:

  1. 去重前,集合中元素有:
  2. Person{name='小明', age=15}
  3. Person{name='小芳', age=20}
  4. Person{name='小李', age=18}
  5. Person{name='小付', age=23}
  6. Person{name='小付', age=23}
  7. Person{name='大飞', age=22}
  8. Person{name='大飞', age=22}
  9. Person{name='大飞', age=22}
  10. 去重后,集合中元素有:
  11. Person{name='小明', age=15}
  12. Person{name='小芳', age=20}
  13. Person{name='小李', age=18}
  14. Person{name='小付', age=23}
  15. Person{name='大飞', age=22}

5.2 映射

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

  • map(Function f):接收一个方法作为参数,该方法会被应用到每个元素上,并将其映射成一个新的元素;
  • mapToDouble(ToDoubleFunction f):接收一个方法作为参数,该方法会被应用到每个元素上,产生一个新的DoubleStream;
  • mapToLong(ToLongFunction f):接收一个方法作为参数,该方法会被应用到每个元素上,产生一个新的LongStream;
  • flatMap(Function f):接收一个方法作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流。

请查看如下实例:

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

运行结果:

  1. PHP
  2. JS
  3. PYTHON
  4. JAVA

可参考下图,理解映射的过程:
3.jpg

5.3 排序

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

  • sorted():产生一个新流,其中按照自然顺序排序;
  • sorted(Comparator com):产生一个新流,其中按照比较器顺序排序。

请查看如下实例:

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

运行结果:

  1. 1
  2. 8
  3. 9
  4. 10
  5. 12
  6. 20

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

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

运行结果:

  1. 20
  2. 12
  3. 10
  4. 9
  5. 8
  6. 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使用内部迭代)。

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

  1. import java.util.Arrays;
  2. import java.util.List;
  3. public class StreamDemo7 {
  4. public static void main(String[] args) {
  5. // 创建一个整型列表
  6. List<Integer> integers = Arrays.asList(10, 12, 9, 8, 20, 1);
  7. // 使用 allMatch(Predicate p) 检查是否匹配所有元素,如果匹配,则返回 true;否则返回 false
  8. boolean b1 = integers.stream().allMatch(integer -> integer > 0);
  9. if (b1) {
  10. System.out.println(integers + "列表中所有的元素都大于0");
  11. } else {
  12. System.out.println(integers + "列表中不是所有的元素都大于0");
  13. }
  14. // 使用 anyMatch(Predicate p) 检查是否至少匹配一个元素
  15. boolean b2 = integers.stream().anyMatch(integer -> integer >= 20);
  16. if (b2) {
  17. System.out.println(integers + "列表中至少存在一个的元素都大于等于20");
  18. } else {
  19. System.out.println(integers + "列表中不存在任何一个大于等于20的元素");
  20. }
  21. // 使用 noneMath(Predicate p) 检查是否没有匹配所有元素
  22. boolean b3 = integers.stream().noneMatch(integer -> integer > 100);
  23. if (b3) {
  24. System.out.println(integers + "列表中不存在大于100的元素");
  25. } else {
  26. System.out.println(integers + "列表中存在大于100的元素");
  27. }
  28. }
  29. }

运行结果:

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

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

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

运行结果:

  1. [10, 12, 9, 8, 20, 1]列表中第一个元素为:Optional[10]
  2. 列表中任意元素:Optional[10]
  3. [10, 12, 9, 8, 20, 1]列表中元素总数为6
  4. [10, 12, 9, 8, 20, 1]列表中最大值为Optional[20]
  5. [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

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

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

运行结果:

  1. 60
  2. Optional[60]

6.3 收集

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

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

运行结果:

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

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

  • static List toList():把流中元素收集到List;
  • static Set toSet():把流中元素收集到Set;
  • static Collection toCollection():把流中元素收集到创建的集合。

    7. 小结

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