【Java面试系列】JDK 1.8 新特性之 Stream API

在这里插入图片描述

一、Stream 简介
二、Stream 特点：
- Stream 注意点：
- 1、什么是聚合操作
- 2、Stream 流
- - 1、什么是流
  - 2、流的构成
  - 3、stream 流的两种操作
  - 4、惰性求值和及早求值方法
  - 5、Stream 流的并行
三、Stream操作的三个步骤
- 1、创建流
- - 第一种：通过集合
  - 第二种：通过数组
  - 第三种：Stream.of()静态方法直接手动生成一个Stream
  - 第四种：创建无限流
  - 第五种：自己构建
- 2、中间操作
- 3、终止操作：一个终止操作，执行中间操作连，产生结果。
系列文章
版本记录

一、Stream 简介

Java 8 引入了全新的 Stream API，这里的 Stream 和 I/O 流不同，它更像具有 Iterable 的集合类，但行为和集合类又有所不同。
Stream 是 Java 8 的新特性，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作（aggregate operation）或者大批量数据操作。
Stream 是用函数式编程方式在集合类上进行复杂操作的工具，开发者可以更容易地使用 Lambda 表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。
同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。
所以说，Java 8 中首次出现的 java.util.stream 是一个函数式语言+多核时代综合影响的产物。

二、Stream 特点：

（1）Stream 流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列；
（2）Stream 相当于高级版的 Iterator；
（3）Stream 的聚合操作与数据库 SQL 的聚合操作 sorted、filter、map 等非常类似；
（4）Stream 是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作（aggregate operation）或者大批量数据操作；
（5）Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等；
（6）在数据操作方面，Stream 不仅可以通过串行的方式实现数据操作，还可以通过并行的方式处理大批量数据，提高处理效率；

Stream 注意点：

（1）Stream 不会自己存储数据。
（2）Stream 不会改变原对象，他们会返回一个新的 Stream。
（3）Stream 操作是延迟的，他们会等到需要的结果时才执行。
（4）用并行流并不一定会提高效率，因为 jvm 对数据进行切片和切换线程也是需要时间的。

1、什么是聚合操作

在传统的 J2EE 应用中，Java 代码就必须依赖于关系型数据库的聚合操作来完成诸如客户每月平均消费金额、最昂贵的在售商品、本周完成的有效订单（排除了无效的）以及取十个数据样本作为首页推荐等需求。但在当今这个数据大爆炸的时代，在数据来源多样化、数据海量化的今天，很多时候不得不脱离 RDBMS，或者以底层返回的数据为基础进行更上层的数据统计。
而 Java 的集合 API 中，仅仅有极少量的辅助型方法，更多的时候是程序员需要用 Iterator 来遍历集合，完成相关的聚合应用逻辑，这是一种远不够高效、笨拙的方法。而在 Java 8 使用 Stream，代码更加简洁易读；而且使用并发模式，程序执行速度更快。

2、Stream 流

1、什么是流

1、Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如，“过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。Stream 就如同一个迭代器（Iterator），单向不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。

2、而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分片成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。Stream 的并行操作依赖于 Java 7 中引入的 Fork/Join 框架（JSR166y）来拆分任务和加速处理过程。

3、Stream 的另外一大特点是，数据源本身可以是无限的。

2、流的构成

当我们使用一个流的时候，通常包括三个基本步骤：获取数据源（source）→ 数据转换 → 执行操作获取想要的结果。如下图所示：

3、stream 流的两种操作

每次数据转换都保持原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道，如：

图中所示，整个过程就是将 goods 元素集合作为一个 “序列”，进行一组 “流水线” 操作： goods 集合提供了元素序列的数据源；通过 stream() 方法获得 Stream，filter / sorted / limit 是一组链式数据处理，连接起来”构成 “流水线”；forEach 最终执行。

1、filter/sorted/limit 的返回值均为 Stream（类似于 Builder 模式），但它们并不立即执行，而是构成了 “流水线”，直到 forEach 最终执行，并且关闭 Stream。因此将 filter/sorted/limited 等能够 “连接起来”，并且返回 Stream 的方法称为 “中间操作”（Intermediate）；将 forEach 等最终执行，并且关闭 Stream 的方法称为 “终止操作”（Terminal）。

2、intermediate 操作目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果。

3、Stream 的中间操作并不是立即执行，而是 “延迟的”、“按需计算”；完成 “终止操作” 后，Stream 将被关闭。多个中间操作可以连接起来性格一条流水线，除非流水线上触发器终止操作，否则中间操作不会执行任何的处理，而是在终止操作时一次性全部处理，成为惰性求值。

4、惰性求值和及早求值方法

1、像 filter 这样只描述Stream，最终不产生新集合的方法叫作惰性求值方法；而像 count 这样最终会从 Stream 产生值的方法叫作及早求值方法。
如何判断一个操作是惰性求值还是及早求值：
只需要看其返回值即可：如果返回值是Stream，那么就是惰性求值；如果返回值不是 Stream 或者是 void，那么就是及早求值。

2、在一个 Stream 操作中，可以有多次惰性求值，但有且仅有一次及早求值。

3、中间操作是 lazy(惰性求值) 的，只有在终止操作执行时，才会一次性执行。可以这么认为，Stream 里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在终止操作的时候循环 Stream 对应的集合，然后对每个元素执行所有的函数。

5、Stream 流的并行

并行处理指的是 Stream 结合了 ForkJoin 框架，对 Stream 处理进行了分片，Spliterator.estimateSize 会估算出分片的数据量；
通过预估的数据量获取最小处理单元的阈值，如果当前分片大小大于最小处理单元的阈值，就继续切分集合；
每个分片都将会生成一个 Sink 链表，当所有分片操作完成后，ForkJoin 框架将会合并所有分片结果集。

三、Stream操作的三个步骤

1、创建Stream：一个数据源（例如：set 、list），获取一个流
2、中间操作：一个中间操作连接，对数据源的数据进行处理
3、终止操作:一个终止操作，执行中间操作连，产生结果。

1、创建流

创建流方式有多种：

第一种：通过集合

对于Collection接口（List 、Set、Queue等）直接调用Stream()方法可以获取Stream

List<String> list = new ArrayList<>();
Stream<String> stringStream = list.stream(); //返回一个顺序流
Stream<String> parallelStream = list.parallelStream(); //返回一个并行流（可多线程）

第二种：通过数组

把数组变成Stream使用Arrays.stream()方法

Stream<String> stream1 = Arrays.stream(new String[]{"CBB", "YJJ", "CB", "CJJ"});

第三种：Stream.of()静态方法直接手动生成一个Stream

    Stream<String> stream = Stream.of("A", "B", "C", "D");

第四种：创建无限流

        //迭代//遍历10个奇数Stream.iterate(1,t->t+2).limit(10).forEach(System.out::println);
//生成//生成10个随机数Stream.generate(Math::random).limit(10).forEach(System.out::println);

第五种：自己构建

2、中间操作

一个流可以后面跟随着0个或者多个中间操作，其目的是打开流，做出某种程度的数据过滤、去重、排序、映射、跳过等。然后返回一个新的流，交给下一个使用，仅仅是调用这个方法，没有真正开始遍历。

map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

3、终止操作：一个终止操作，执行中间操作连，产生结果。

forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

package com.chen.test.JAVA8Features.Stream;

import java.util.*;
import java.util.stream.Collectors;

public class StreamDemo01 {public static void main(String[] args) {
List<Integer> list = new ArrayList<>();for (int i = 0; i < 10; i++) {list.add(i);}//mapList<Integer> collect = list.stream().map(n -> n * 2).collect(Collectors.toCollection(ArrayList::new));collect.forEach(System.out::println);//filer 过滤List<Integer> list1 = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());list1.forEach(System.out::println);//distinct 去重List<Integer> list2 = list.stream().distinct().collect(Collectors.toList());list2.forEach(System.out::println);//skip 跳过List<Integer> list3 = list.stream().skip(3).collect(Collectors.toList());list3.forEach(System.out::println);//limit 截取Set<Integer> set = list.stream().limit(3).collect(Collectors.toSet());set.forEach(System.out::println);//skip  and limit 组合使用List<Integer> list4 = list.stream().skip(3).limit(5).collect(Collectors.toList());list4.forEach(System.out::println);
}
}

————————————————

                        版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/weixin_40294256/article/details/126338618

系列文章

内容	地址链接
JAVA面试	常见问题
JAVA面试	Spring知识点
JAVA面试	Mysql
JAVA面试	Redis常见问题
JAVA面试	MongoDB
JAVA面试	JDK 1.8 新特性之 Lambda表达式
JAVA介绍	Linux （实战）常用命令