Java stream流使用详细介绍

刺骨的言语ヽ痛彻心扉 2024-03-22 15:10 198阅读 0赞

Java Stream 是 JDK 1.8 引入的一个新特性，是对集合（Collection）对象进行流式处理的一种方式。相比于传统的集合遍历方式，Java Stream 更加简洁、优雅，可以快速实现各种集合的遍历、筛选、映射、分组、汇总、排序等操作。本文将围绕 Java Stream 的基本使用方式、中间操作、终止操作等方面进行详细介绍。

### 1. 基本使用方式 ###

创建 Stream 对象的方式有多种，可以通过集合对象的 stream() 方法、Arrays 类的 stream 方法、Stream 类的 of() 方法以及 BufferedReader 的 lines() 方法等。这里以 List 为例，介绍如何创建 Stream 对象：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream();

基本操作可以分为中间操作和终止操作两类。中间操作返回一个新的 Stream 对象，可以链式调用多个中间操作来完成数据的处理和转换。终止操作则返回一个非 Stream 的结果，例如 List、Map、int、long 等。

### 2. 中间操作 ###

中间操作可以分为筛选、映射、排序、去重等多个类别，下面分别介绍各个类别的使用。

#### 2.1 筛选操作 ####

筛选操作用于过滤 Stream 中的元素，过滤条件可以是某个属性的值、是否满足某个条件等。常用的筛选操作包括 filter、distinct、limit、skip、peek 等。

##### 2.1.1 filter 方法 #####

filter 方法用于过滤 Stream 中满足指定条件的元素，返回一个新的 Stream 对象。例如，下面代码过滤出 Stream 中大于 2 的元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream().filter(i -> i > 2);
    stream.forEach(System.out::println); // 输出：3 4 5

上面代码中，使用 filter 方法来过滤出大于 2 的元素，然后再使用 forEach 方法将符合条件的元素输出。

##### 2.1.2 distinct 方法 #####

distinct 方法用于去重 Stream 中的元素，返回一个新的 Stream 对象。例如，下面代码去重一个 Stream 对象：

List<Integer> list = Arrays.asList(1, 2, 3, 1, 2, 3);
    Stream<Integer> stream = list.stream().distinct();
    stream.forEach(System.out::println); // 输出：1 2 3

上面代码中，使用 distinct 方法去重 Stream 中的元素，将去重后的结果输出。

##### 2.1.3 limit 方法 #####

limit 方法用于限制 Stream 中元素的数量，返回一个新的 Stream 对象。例如，下面代码限制一个 Stream 对象的元素数量为 2：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream().limit(2);
    stream.forEach(System.out::println); // 输出：1 2

上面代码中，使用 limit 方法限制了只输出两个符合条件的元素。

##### 2.1.4 skip 方法 #####

skip 方法用于跳过 Stream 中的前几个元素，返回一个新的 Stream 对象。例如，下面代码跳过一个 Stream 对象的前两个元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream().skip(2);
    stream.forEach(System.out::println); // 输出：3 4 5

上面代码中，使用 skip 方法跳过了前两个元素，输出跳过后的结果。

##### 2.1.5 peek 方法 #####

peek 方法用于对 Stream 中的每个元素进行操作但不影响 Stream 的元素，返回一个新的 Stream 对象。例如，下面代码修改一个 Stream 对象的每个元素并输出：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream().peek(i -> i *= 2);
    stream.forEach(System.out::println); // 输出：1 2 3 4 5

上面代码中，使用 peek 方法修改每个元素的值为原来的两倍，但是并不影响 Stream 的元素。

#### 2.2 映射操作 ####

映射操作用于对 Stream 中的元素进行变换或处理，并返回一个新的 Stream 对象。常用的映射操作包括 map、flatMap 等。

##### 2.2.1 map 方法 #####

map 方法用于将 Stream 中的每个元素进行映射操作，返回一个新的 Stream 对象。例如，下面代码将一个 Stream 对象中的所有元素都乘以 2：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream().map(i -> i * 2);
    stream.forEach(System.out::println); // 输出：2 4 6 8 10

上面代码中，使用 map 方法将 Stream 中的每个元素都乘以 2，并输出变换后的结果。

##### 2.2.2 flatMap 方法 #####

flatMap 方法用于把 Stream 中的每个元素先变成一个 Stream，然后将这些 Stream 再合并成一个 Stream，返回一个新的 Stream 对象。例如，下面代码将一个 Stream 对象中的每个元素都转换成一个新的 Stream，并合并成一个 Stream：

List<String> list1 = Arrays.asList("I", "am");
    List<String> list2 = Arrays.asList("the", "one");
    List<List<String>> list = Arrays.asList(list1, list2);
    
    Stream<String> stream = list.stream().flatMap(Collection::stream);
    stream.forEach(System.out::println); // 输出：I am the one

上面代码中，使用 flatMap 方法将 Stream 对象中的每个元素都转换为一个新的 Stream，并合并成一个 Stream 对象，输出合并后的结果。

#### 2.3 排序操作 ####

排序操作用于对 Stream 中的元素进行排序，可以使用 sorted 和 unsorted 方法。sorted 方法可以按照自然顺序或传入的 Comparator 进行排序，而 unsorted 方法可以取消之前的排序操作。

##### 2.3.1 sorted 方法 #####

sorted 方法用于对 Stream 中的元素进行排序，可以按照自然顺序或传入的 Comparator 进行排序，返回一个新的 Stream 对象。例如，下面代码将一个 Stream 对象中的元素按照自然顺序进行排序：

List<Integer> list = Arrays.asList(3, 2, 1, 4, 5);
    Stream<Integer> stream = list.stream().sorted();
    stream.forEach(System.out::println); // 输出：1 2 3 4 5

上面代码中，使用 sorted 方法按照自然顺序对 Stream 中的元素进行排序，并输出排序后的结果。

##### 2.3.2 unsorted 方法 #####

unsorted 方法用于取消之前的排序操作，返回一个新的 Stream 对象。例如，下面代码先对一个 Stream 对象进行排序，然后使用 unsorted 方法取消排序：

List<Integer> list = Arrays.asList(3, 2, 1, 4, 5);
    Stream<Integer> stream1 = list.stream().sorted();
    Stream<Integer> stream2 = stream1.unsorted();
    stream2.forEach(System.out::println); // 输出：3 2 1 4 5

上面代码中，首先使用 sorted 方法对 Stream 中的元素进行排序，然后使用 unsorted 方法取消排序，并输出取消排序后的结果。

#### 2.4 其他操作 ####

除了筛选、映射、排序操作之外，Java Stream 还提供了其他一些便捷的操作方法，例如 forEach、reduce 等。

##### 2.4.1 forEach 方法 #####

forEach 方法用于对 Stream 中的每个元素进行遍历，返回一个新的 Stream 对象。例如，下面代码遍历一个 Stream 对象并输出每个元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream().forEach(System.out::println);

上面代码中，使用 forEach 方法对 Stream 中的每个元素进行遍历，并输出每个元素的值。

##### 2.4.2 reduce 方法 #####

reduce 方法用于将 Stream 中的元素按照指定的方式进行归约操作，返回一个非 Stream 的结果值。例如，下面代码将一个 Stream 对象中的所有元素相加：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    int sum = list.stream().reduce(0, (a, b) -> a + b);
    System.out.println(sum); // 输出：15

上面代码中，使用 reduce 方法对 Stream 中的元素进行归约操作，将所有元素相加并输出结果。

### 3. 终止操作 ###

终止操作用于对 Stream 中的元素进行最终操作，例如将 Stream 中的元素转换为 List、Map 等集合类型，或者对 Stream 中的元素进行计数、求和等操作。常用的终止操作包括 forEach、collect、count、max、min、sum、reduce 等。

#### 3.1 forEach 方法 ####

forEach 方法用于对 Stream 中的每个元素进行遍历操作，没有返回值。例如，下面代码遍历一个 Stream 对象并输出每个元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    list.stream().forEach(System.out::println);

上面代码中，使用 forEach 方法对 Stream 中的每个元素进行遍历，并输出每个元素的值。

#### 3.2 collect 方法 ####

collect 方法用于将 Stream 中的元素转换为 List、Map 等集合类型，返回一个非 Stream 的结果对象。例如，下面代码将一个 Stream 对象中的元素转换为 List 类型：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> newList = list.stream().collect(Collectors.toList());
    System.out.println(newList); // 输出：[1, 2, 3, 4, 5]

上面代码中，使用 collect 方法将 Stream 中的元素转换为 List 类型，并输出转换后的结果。

#### 3.3 count 方法 ####

count 方法用于统计 Stream 中元素的个数，返回一个 long 类型的结果值。例如，下面代码获取一个 Stream 对象中元素的数量：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    long count = list.stream().count();
    System.out.println(count); // 输出：5

上面代码中，使用 count 方法统计 Stream 中元素的数量，并输出统计结果。

#### 3.4 max 和 min 方法 ####

max 和 min 方法用于获取 Stream 中元素的最大值和最小值，返回一个 Optional 类型的结果值。例如，下面代码分别获取一个 Stream 对象中元素的最大值和最小值：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Optional<Integer> max = list.stream().max(Integer::compareTo);
    Optional<Integer> min = list.stream().min(Integer::compareTo);
    
    System.out.println(max.get()); // 输出：5
    System.out.println(min.get()); // 输出：1

上面代码中，使用 max 和 min 方法获取 Stream 中元素的最大值和最小值，并输出结果。

#### 3.5 sum 方法 ####

sum 方法用于求 Stream 中所有元素的和，返回一个 double 类型的结果值。例如，下面代码求一个 Stream 对象中所有元素的和：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    double sum = list.stream().mapToInt(Integer::intValue).sum();
    System.out.println(sum); // 输出：15.0

上面代码中，使用 sum 方法求 Stream 中所有元素的和，并输出结果。

#### 3.6 reduce 方法 ####

reduce 方法用于将 Stream 中的元素按照指定的方式进行归约操作，返回一个非 Stream 的结果值。例如，下面代码将一个 Stream 对象中的所有元素相加：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    int sum = list.stream().reduce(0, (a, b) -> a + b);
    System.out.println(sum); // 输出：15

上面代码中，使用 reduce 方法对 Stream 中的元素进行归约操作，将所有元素相加并输出结果。

### 4. 总结 ###

本文介绍了 Java Stream 的基本使用方式、中间操作和终止操作，并举例说明了筛选、映射、排序等多个操作方法的使用。Java Stream 是 Java 1.8 版本引入的一项重要特性，使用 Stream 可以让我们更加简洁、优雅地处理集合对象，提高开发效率，值得我们深入学习和掌握。