【Java笔记】Stream流 超详解
【Java笔记】Stream流 超详解
文章目录
- 【Java笔记】Stream流 超详解
-
- 1. 初识Stream流
-
- 1.1 传统集合的多步遍历代码
- 1.2 循环遍历的弊端
- 1.3 Stream的更优写法
- 2 流式思想概述
- 3 获取流
-
- 3.1 单列集合获取流
- 3.2 双列集合获取流
- 3.3 数组获取流
- 3.4 Stream.of() 获取流
- 4.Stream流的中间方法
-
- 4.1 filter
- 4.2 limit & skip
- 4.3 distinct & concat
- 4.4 map
- 5. Stream流中的终结方法
-
- 5.1 forEach & count & toArray
- 5.2 collect
- 6 小结
实习了之后发现我不会的东西是真的多啊，很多学过的东西也忘得差不多了，这次来复习（学习）一下Java中的Stream流，主要因为项目中的代码中用到了很多次。
笔记来源：黑马程序员Java零基础视频教程_下部
1. 初识Stream流
说到Stream便很容易想到I/O Stream，而实际上，谁规定"流"就一定是IO流呢，在Java 8中，得益于Lamdba所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。
总的来说，就是Stream流结合了Lambda表达式，简化了集合、数组的操作。
在认识Stream流的好处之前，我们先来看一下传统集合的操作代码。
1.1 传统集合的多步遍历代码
集合所有的集合都支持直接或间接地便利操作，而当我们需要对集合中的元素进行操作的时候，除了必需的添加，删除、获取外，最典型的就是集合遍历。例如：
import java.util.ArrayList;
import java.util.Collections;
public class demo01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰");
for (String name : list) {
System.out.println(name);
}
}
}
1.2 循环遍历的弊端
Java 8的Lambda让我们可以更加专注于做什么（what），而不是怎么做（How）。我们仔细体会一下上例代码，可以发现：
- for循环的语法就是怎么做
- for循环的循环体才是做什么
为什么要使用循环？因为要进行遍历，但循环时遍历的唯一方式吗？
**遍历是指每一个元素逐一进行处理，而不是从第一个到最后一个顺次处理的循环。**前者时目的，后者是方式。
现在我们希望对集合的袁术进行筛选过滤：
- 首先筛选所有姓张的人
- 然后筛选名字有三个字的人
- 最后对结果进行打印输出
使用传统集合遍历筛选的方式可能为：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class demo01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰");
// 1.首先筛选所有姓张的人
List<String> zhangList = new ArrayList<>();
for (String name : list) {
if (name.startsWith("张"))
zhangList.add(name);
}
// 2.然后筛选名字有三个字的人
List<String> shortList = new ArrayList<>();
for (String name : zhangList) {
if (name.length() == 3)
shortList.add(name);
}
// 3.打印输出
for (String name : shortList) {
System.out.println(name);
}
}
}
学过算法的同学可能会考虑时间复杂度的问题，我们可以对其进行优化：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class demo01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰");
for (String name : list) {
if (name.startsWith("张") && name.length() == 3) {
System.out.println(name);
}
}
}
}
这样虽然优化了一些，但是还是不够好，并且如果业务逻辑比较复杂的话，传统集合遍历方式还是显得鸡肋一些。
每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使 用另一个循环从头开始。
那，Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢？
1.3 Stream的更优写法
下面来看一下借助Java 8的Stream API，什么才叫优雅：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class demo02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰");
list.stream()
.filter(s -> s.startsWith("张"))
.filter(s -> s.length() == 3)
.forEach(System.out::println);
}
}
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码 中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。
2 流式思想概述
整体来看，流式思想类似于工厂车间的生产流水线。
跟我一起速速进厂吧，一起体验夺命流水线。
如果巅峰留不住，那就进厂包吃住。
如果志同道也合，那就流水线回合。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h3spcsS1-1666777511385)(https://xiaoxin18.oss-cn-hangzhou.aliyuncs.com/2022/image-20221026113133867.png)]
以刚才的例子为例
第一次操作，我们只留下以张开头的
第二次操作，我们只留下长度为3的
第三次操作，输出打印
当对多个元素元素进行操作（特别是多步操作）的时候，考虑到新跟那个及便利性，我们应该首先拼好一个”模型“步骤方案，然后再按照方案去执行它。
这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字 3是最终结果。
这里的 filter 、 map 、 skip 都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法 count 执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。
备注：“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何 元素（或其地址值）。
Stream（流）是一个来自数据源的元素队列
- 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
- 数据源 ：流的来源。 可以是集合，数组 等。
和以前的Collection操作不同， Stream操作还有两个基础的特征：
- Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
- 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭 代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。
当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换 → 执行操作获取想要的结 果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以 像链条一样排列，变成一个管道。
简单来说：
- 先得到一条Stream流（流水线），并把数据放上去
- 利用Stream流中的API进行各种操作：包括两类方法
- 中间方法：过滤、转换（方法调用完毕之后，还可以调用其他方法）
- 终结方法：统计、打印（最后一步，调用完毕之后，这个流就结束了）
3 获取流
| 获取方式 | 方法名 | 说明 |
|---|---|---|
| 单列集合 | default Stream stream() | Collection中的默认方法 |
| 双列集合 | 无 | 无法直接使用stream流 |
| 数组 | public static Stream stream(T[] array) | Arrays工具类中的静态方法 |
| 一堆零散数据 | public static Stream of(T… values) | Stream接口中的静态方法 |
3.1 单列集合获取流
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class demo03 {
public static void main(String[] args) {
// 1.单列集合获取Stream流
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰");
// 2.获取到一条流水线，并把集合中的数据放到流水线上
Stream<String> stream = list.stream();
// 3.使用终结方法打印一下流水线上的数据
stream.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
// s:依次表示流水线上的每一个数据
System.out.println(s);
}
});
// lambda形式
list.stream().forEach(s -> System.out.println(s));
}
}
3.2 双列集合获取流
java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流 需要分key、value或entry等情况：
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class demo04 {
public static void main(String[] args) {
// 1.单列集合获取Stream流
HashMap<String, Integer> hm = new HashMap<>();
hm.put("aaa", 111);
hm.put("bbb", 222);
hm.put("ccc", 333);
// 2.获取到一条流水线，并把集合中的数据放到流水线上
Stream<String> keyStream = hm.keySet().stream();
Stream<Integer> valueStream = hm.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = hm.entrySet().stream();
// 3.使用终结方法打印一下流水线上的数据
keyStream.forEach(s -> System.out.println(s));
valueStream.forEach(s -> System.out.println(s));
entryStream.forEach(s -> System.out.println(s.getKey() + ":" + s.getValue()));
}
}
3.3 数组获取流
使用Arrays中的stream方法获取流你会发现，可以使用任何数据类型，包括基本数据类型和引用数据类型。
import java.sql.Array;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class demo05 {
public static void main(String[] args) {
// 1.创建数组
//基本数据类型
int[] arr = {1, 2, 3};
//引用数据类型
String[] arr2 = {"a", "b", "c"};
// 2.获取Stream流
Arrays.stream(arr).forEach(s -> System.out.println(s));
System.out.println("===============");
Arrays.stream(arr2).forEach(s -> System.out.println(s));
}
}
3.4 Stream.of() 获取流
import java.util.stream.Stream;
public class demo06 {
public static void main(String[] args) {
Stream.of(1, 2, 3, 4, 5).forEach(s -> System.out.println(s));
Stream.of("a", "b", "c", "d").forEach(s -> System.out.println(s));
}
}
但是这里有一个小细节：
Stream.of()中的形参是一个可变参数，可变参数的底层是数组
方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数据
但是如果传递的参数是一个数组，数组必须是引用数据类型，如果传递基本数据类型，是会把整个数组当作一个元素，放到Stream中。
import java.sql.Array;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class demo05 {
public static void main(String[] args) {
// 1.创建数组
//基本数据类型
int[] arr = {1, 2, 3};
//引用数据类型
String[] arr2 = {"a", "b", "c"};
// 基本数据类型
Stream.of(arr).forEach(s -> System.out.println(s)); // [I@7c3df479 打印的是地址
// 引用数据类型
Stream.of(arr2).forEach(s -> System.out.println(s));// a b c
}
}
4.Stream流的中间方法
4.1 filter
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class demo07 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// filter 过滤：把姓张的留下
list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
// 如果返回值为true，表示当前数据保留，否则舍弃
return s.startsWith("张");
}
}).forEach(s -> System.out.println(s));
//张无忌
//张三丰
//张翠山
//张良
// lambda形式优化
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
}
}
中间方法，每次都返回新的stream流，原来的Stream流只能使用一次，我们来验证一下
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class demo07 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// filter 过滤：把姓张的留下
list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
// 如果返回值为true，表示当前数据保留，否则舍弃
return s.startsWith("张");
}
}).forEach(s -> System.out.println(s));
//张无忌
//张三丰
//张翠山
//张良
// lambda形式优化
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));
Stream<String> stream2 = stream1.filter(s -> s.length() == 3);
stream2.forEach(s -> System.out.println(s)); // 张无忌 张三丰 张翠山
// 此时stream1已经被使用过了，我现在再使用一次会怎么样呢？
Stream<String> stream3 = stream1.filter(s -> s.length() == 3);
// Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
}
}
4.2 limit & skip
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class demo08 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "赵强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// limit :获取钱几个元素
// skip : 跳过前几个元素
list.stream()
.limit(3)
.forEach(s -> System.out.print(s + " ")); // 张无忌 周芷若 赵敏
System.out.println();
list.stream()
.skip(4)
.forEach(s -> System.out.print(s + " ")); // 张三丰 张翠山 张良 王二麻子 谢广坤
System.out.println();
// 小练习，获取第4~6之间的数据
// 第一种方案
list.stream().skip(3).limit(3).forEach(s -> System.out.print(s + " ")); //赵强 张三丰 张翠山
System.out.println();
// 第二种方案
list.stream().limit(6).skip(3).forEach(s -> System.out.print(s + " ")); // 赵强 张三丰 张翠山
}
}
4.3 distinct & concat
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
public class demo09 {
public static void main(String[] args) {
List<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌", "张无忌", "张无忌",
"赵强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
List<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");
// distinct : 元素去重，依赖(hashCode方法和equals方法)
// 底层利用的是 hashSet 去重的
// hashSet 存储自定义对象的时候要重写hashCode和equals方法
list1.stream().distinct().forEach(s -> System.out.print(s + " "));
// 张无忌 赵强 张三丰 张翠山 张良 王二麻子 谢广坤
System.out.println();
// concat :合并a和b为一个流，如果两个流的类型不一致，会合并到它们的父类
Stream.concat(list1.stream(), list2.stream())
.forEach(s -> System.out.print(s + " "));
// 张无忌 张无忌 张无忌 赵强 张三丰 张翠山 张良 王二麻子 谢广坤 周芷若 赵敏
System.out.println();
}
}
4.4 map
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Stream;
public class demo10 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13",
"赵强-20", "张三丰-100", "张翠山-40", "张良-35", "王二麻子-37", "谢广坤-50");
// map : 转换流中的数据类型，也可以修改数据
// 只获取其中的年龄 String -> int
// 第一个类型：流中原本的数据类型
// 第二个类型：要转成之后的类型
// apple的形参s：依次表示流中的每一个数据
// 返回值：表示转换之后的数据
list.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
String[] split = s.split("-");
Integer age = Integer.valueOf(split[1]);
return age;
}
}).forEach(s -> System.out.print(s + " "));
//15 14 13 20 100 40 35 37 50
System.out.println();
// lamdba 形式
list.stream()
.map(s -> Integer.valueOf(s.split("-")[1]))
.forEach(s -> System.out.print(s + " "));
// 15 14 13 20 100 40 35 37 50
}
}
5. Stream流中的终结方法
5.1 forEach & count & toArray
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
public class demo11 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "张无忌", "张无忌",
"赵强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// 1.forEach : 遍历
// Consumer的泛型：表示流中数据的类型
// accept() 方法中的形参s:依次表示流中的每一个数据
// 方法体：对每一个数据进行处理
list.stream().forEach(new Consumer<String>() {
@Override
public void accept(String s) {
// 每次消耗一个数据
System.out.print(s + " ");
}
});
// 张无忌 张无忌 张无忌 赵强 张三丰 张翠山 张良 王二麻子 谢广坤
System.out.println();
// lambda
list.stream().forEach(s -> System.out.print(s + " "));
// 张无忌 张无忌 张无忌 赵强 张三丰 张翠山 张良 王二麻子 谢广坤
System.out.println();
// 2. count : 统计
long count = list.stream().count();
System.out.println(count);
// 9
// 3. toArray :收集流中的数据，放到数组中
Object[] arr1 = list.stream().toArray();
System.out.println(Arrays.toString(arr1));
// [张无忌, 张无忌, 张无忌, 赵强, 张三丰, 张翠山, 张良, 王二麻子, 谢广坤]
// IntFunction的泛型：具体类型的数组
// apply的形参value：流中数据的个数，要和数组的长度保持一致
// apply的返回值：具体类型的数组
// toArray 方法参数的作用：负责创建一个指定类型的数组
// toArray 方法的底层：会一次得到流里面的每一个数据，并把数据放到数组中去
// tiArray 方法的返回值：是一个装着流里面所有数据的数组
String[] arr2 = list.stream().toArray(new IntFunction<String[]>() {
@Override
public String[] apply(int value) {
return new String[value];
}
});
System.out.println(Arrays.toString(arr2));
//[张无忌, 张无忌, 张无忌, 赵强, 张三丰, 张翠山, 张良, 王二麻子, 谢广坤]
// lambda形式
String[] arr3 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr3));
// [张无忌, 张无忌, 张无忌, 赵强, 张三丰, 张翠山, 张良, 王二麻子, 谢广坤]
}
}
5.2 collect
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
public class demo12 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13",
"赵强-男-20", "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-50");
// collerc(Collector collector) : 收集流中的数据，放到集合中(List,Set,Map)
// 需求：把所有男性放到一个List集合中
List<String> collect1 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toList());
System.out.println(collect1);
// [张无忌-男-15, 赵强-男-20, 张三丰-男-100, 张翠山-男-40, 张良-男-35, 王二麻子-男-37, 谢广坤-男-50]
// 需求：把所有男性放到一个Set集合中
Set<String> collect2 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toSet());
System.out.println(collect2);
// [张良-男-35, 谢广坤-男-50, 赵强-男-20, 张三丰-男-100, 张无忌-男-15, 张翠山-男-40, 王二麻子-男-37]
// 收集到List集合和Set集合的区别：
// 收集到Set集合中元素会去除重复值，而List集合不会
// 需求：收集到Map集合中
// 键：姓名 值：年龄
// 把所有的男性收集起来
/**
* toMap :
* 参数1:表示键的生成规则
* 参数2:表示值的生成规则
* 参数1:
* Function:
* 泛型1：表示流中每一个数据的类型
* 泛型2：表示Map集合中键的数据类型
* 方法apply形参：依次表示流里面的每一个数据
* 方法体：生成键的代码
* 返回值：已经生成的键
* 参数2:
* Function:
* 泛型1：表示流中每一个数据的类型
* 泛型2：表示Map集合中值的数据类型
* 方法apply形参：依次表示流里面的每一个数据
* 方法体：生成值的代码
* 返回值：已经生成的值
*
* 注意：这里Map的键不能重复，否则会报错
*/
Map<String, Integer> map = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(new Function<String, String>() {
@Override
public String apply(String s) {
return s.split("-")[0];
}
}, new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.valueOf(s.split("-")[2]);
}
}));
System.out.println(map);
// {张良=35, 赵强=20, 张翠山=40, 王二麻子=37, 张三丰=100, 张无忌=15, 谢广坤=50}
// lambda形式
Map<String, Integer> map2 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(
s -> s.split("-")[0],
s -> Integer.valueOf(s.split("-")[2])));
System.out.println(map2);
// {张良=35, 赵强=20, 张翠山=40, 王二麻子=37, 张三丰=100, 张无忌=15, 谢广坤=50}
}
}
6 小结
关于Stream流就讲到这里了，接下来我将继续更新其他知识，感谢大佬们支持！