Stream流
Stream初探：何方神圣？
Stream流是一种处理集合数据的高效工具，它可以让你以声明性的方式处理数据集合。Stream不是存储数据的数据结构，而是对数据源（如集合、数组）的运算操作概念，支持函数式编程风格
特性
- 可以配合lambda写出简洁代码。
- 链式操作：支持一系列中间操作（如filter, map）和最终操作（如forEach, collect），这些操作可以链接起来，形成一个管道来处理数据。
- 延迟执行：中间操作不会立即执行，而是构建一个执行计划，直到遇到最终操作时才一次性完成所有操作，这种方式可以提高效率。
- 并行处理：支持并行处理，通过调用parallelStream()方法，可以轻松地利用多核处理器的优势，无需手动编写多线程代码。
- 类型安全：利用泛型，Stream操作可以在编译期检查类型错误，提高代码的安全性和可读性。
如何获得Stream流
Java提供了几种方式,可以让我们获得Stream流
- [集合创建流]Collection 接口的 stream()或 parallelStream()方法
- [自由值创建]静态的 Stream.of(…)、Stream.empty()方法
- [数组创建流]Arrays.stream(array)
- 静态的 Stream.generate()方法生成无限流，接受一个不包含引元的函数
- 静态的 Stream.iterate()方法生成无限流，接受一个种子值以及一个迭代函数
- Pattern 接口的 splitAsStream(input)方法
- 静态的 Files.lines(path)、Files.lines(path, charSet)方法
- 静态的 Stream.concat()方法将两个流连接起来
代码演示
/*
* 三种常用获得流的方法
* 1.Collection接口中的stream()方法
* 2.Stream类的静态方法 of()
* 3.Arrays工具类的stream(T[] array)方法
*
*/
// 用Collection接口中的stream()方法，获得流
ArrayList<Integer> list = new ArrayList<>();// 创建集合
list.add(1);
list.add(2);
list.add(3);
Stream<Integer> stream1 = list.stream();// 获得流
// 2.Stream类的静态方法 of()
Stream<Integer> stream2 = Stream.of(1, 2, 3, 4);// 获得流
//3.Arrays工具类的stream(T[] array)方法
int[] arr = {1,2,3,4};
IntStream stream3 = Arrays.stream(arr);// 获得流
Stream方法操作
Stream流就是流式处理数据,流的操作有很多种
- 中间操作(真正处理数据的操作)
- 中间操作就是执行完返回的是一个流,即可以**
继续执行**流操作- 敲代码来说,就是使用中间操作的方法,写完继续再.调用其他方法
- 终止操作(将
操作完的结果返回)
- 敲代码来说,调用终止方法,代码就结束;
| 操作 | 函数 | 说明 |
|---|---|---|
| 中间操作 | filter(Predicate) | 将结果为false的元素过滤掉 |
| 中间操作 | map(Function) | 转换元素的值，可以用方法引元或者lambda表达式 |
| 中间操作 | flatMap(Function) | 若元素是流，将流摊平为正常元素，再进行元素转换(合并两个流为一个流) |
| 中间操作 | limit(long n) | 保留前n个元素 |
| 中间操作 | skip(long n) | 跳过前n个元素 |
| 中间操作 | concat(Stream s1, Stream s2) | 将两个流拼接起来 |
| 中间操作 | distinct() | 剔除重复元素 |
| 中间操作 | sorted() | 将Comparable元素的流排序 |
| 中间操作 | sorted(Comparator) | 将流元素按Comparator排序 |
| 中间操作 | peek(Consumer) | 流不变，但会把每个元素传入fun执行，可以用作调试 |
| 终结操作 | max(Comparator) | 取最大值 |
| 终结操作 | min(Comparator) | 取最小值 |
| 终结操作 | count() | 统计元素数量 |
| 终结操作 | findFirst() | 获得流的第一个元素 |
| 终结操作 | findAny() | 返回任意元素 |
| 终结操作 | anyMatch(Predicate) | 任意元素匹配时返回true |
| 终结操作 | allMatch(Predicate) | 所有元素匹配时返回true |
| 终结操作 | noneMatch(Predicate) | 没有元素匹配时返回true |
| 终结操作 | reduce(Function) | 从流中计算某个值，接受一个二元函数作为累积器，从前两个元素开始持续应用它，累积器的中间结果作为第一个参数，流元素作为第二个参数 |
| 终结操作 | iterator() | 迭代器迭代元素 |
| 终结操作 | forEach(Consumer) | lambda的方式迭代 |
| 终结操作 | forEachOrdered(Consumer) | 可以应用在并行流上以保持元素顺序 |
5.2.1 中间操作
下面演示流的操作使用 - 中间操作
package day613.jdk8New.stream;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.stream.Stream;
public class StreamAPITest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();// 创建集合
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Stream<Integer> stream1 = list.stream();// 获得流
/*
* void forEach(Consumer<? super T> action);
* ---遍历流
* ---参数类型：Consunmer
* -----使用lambda重写Consumer接口的 void accept(T t)
*/
//遍历流
//stream1.forEach(t -> System.out.print(t + " "));// 1 2 3 4 5 6
/*
* Stream<T> filter(Predicate<? super T> predicate);
* ---过滤，即过滤掉不想要的数据，留下想要的
* ---参数类型 Predicate
* -----使用lambda重写Predicate接口的 boolean test(T t)
*/
//过滤奇数，留下偶数
//stream1.filter(t->t % 2 == 0).forEach(t-> System.out.print(t + " "));// 2 4 6
/*
* <R> Stream<R> map(Function<? super T, ? extends R> mapper);
* ---转换元素的值
* ---参数类型 Function
* -----使用lambda重写Function接口的 R apply(T t)
*/
//将流中的整型转换成字符串类型，并遍历
//stream1.map(t->String.valueOf(t)).forEach(t-> System.out.print(t + " "));//1 2 3 4 5 6
/*
* Stream<T> limit(long maxSize);
* ---保留前maxSize个元素
* ---参数类型 long
*/
//保留前四个
//stream1.limit(4).forEach(t-> System.out.print(t + " "));// 1 2 3 4
/*
* Stream<T> skip(long n);
* ---跳过前n个元素
* ---参数类型 long
*/
//跳过前四个
//stream1.skip(4).forEach(t-> System.out.print(t + " "));// 5 6
/*
* Stream<T> sorted(Comparator<? super T> comparator);
* ---排序
* ---参数类型 Comparator
* -----使用lambda重写Comparator接口的 int compare(T o1, T o2);
*/
//降序排序
stream1.sorted((o1,o2) -> o2 - o1 ).forEach(t-> System.out.print(t + " "));
}
}
练习:
给定ArrayList<Integer>集合,
先过滤数据只保留偶数,
后对数据进行降序排序,
去除重复元素,
将元素转成String类型
后将每个元素拼接上《》后输出
public static void test() {
ArrayList<Integer> list = new ArrayList<>( );
list.add(3);
list.add(1);
list.add(3);
list.add(2);
list.add(4);
list.add(6);
list.add(5);
list.add(7);
list.add(5);
list.add(6);
list.add(9);
list.add(8);
list.add(10);
list.add(7);
// 获得流
Stream<Integer> stream = list.stream( );
// 先过滤数据只保留偶数
// 后对数据进行降序排序,
// 去除重复元素,
// 将元素转成String类型
// 后将每个元素拼接上《》后输出
stream.filter(e -> e % 2 == 0)
.sorted((o1,o2) -> o2 - o1)
.distinct()
.map(e -> String.valueOf(e))
.forEach(e -> System.out.println("《"+e+"》" ));
}
5.2.3 注意事项
Stream流的操作注意事项
流的操作只能使用一次,也就是说执行过终结操作后不能再继续使用
否则报错报错
IllegalStateException stream has already been closed使用中间操作,返回新的流
没有终止操作,就不会有结果,换句话说,没有终结操作,中间操作是 不会执行的
public static void test2() {
Stream<Integer> stream = Stream.of(1, 2, 3);
stream.filter((e) -> {
System.out.println("正在过滤元素:"+e );
return e % 2 == 0;
});
// 没有终结操作,中间的filter不会执行,输出语句不会执行
}
5.3 流的收集
流操作完,将数据流中的数据再返回成数组和集合 --> 这就是收集流
将流收集到集合或数组中
- collect() 收集到集合
- collect(Collectors.toList( )) 将stream流中的数据,收集到List集合
- collect(Collectors.toSet( )) 将stream流中的数据,收集到set集合
- toArray 收集到数组
ArrayList<Integer> list = new ArrayList<>( );
list.add(3);
// 获得流
Stream<Integer> stream = list.stream( );
// 先过滤数据只保留偶数
// 后对数据进行降序排序,
// 去除重复元素,
// 将元素转成String类型
// 变成ArrayList<String>返回
List<String> list2 = stream.filter(e -> e % 2 == 0)
.sorted((o1, o2) -> o2 - o1)
.distinct( )
.map(e -> String.valueOf(e))
.collect(Collectors.toList( ));// 收集为List集合
最后
如果感觉有收获的话，点个赞 👍🏻 吧。
❤️❤️❤️本人菜鸟修行期，如有错误，欢迎各位大佬评论批评指正！😄😄😄
💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍
