Java8 Stream详细用法介绍

编程语言 2023-04-09 03:54:12 阅读次数: 0

Java8 Stream详细用法介绍

一、Stream概述

Stream流是JDK8新增的成员，允许以声明性方式处理数据集合，可以把Stream流看作是遍历数据集合的一个高级迭代器。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找/筛选/过滤、排序、聚合和映射数据等操作。Stream API 提供了一种高效且易于使用的处理数据的方式。

1.1、流的定义

从支持数据处理操作的源生成的元素序列。数据源可以是集合，数组或IO资源。

1.2、流与集合

stream Collection
主要用途 主要用于描述对数据的计算 主要为了存储和访问数据
计算时间 在有需求的时候才计算 每个元素都是先计算出来的
遍历方式 内部迭代 外部迭代

1.3、流的特性

  • 不是数据结构，不会保存数据，stream的目的是处理数据。
  • stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
  • 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。

1.4、Stream的创建

1、通过Stream.empty()创建空流

Stream<String> streamEmpty = Stream.empty();

2、通过 java.util.Collection.stream() 方法用集合创建流

List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();

3、使用 java.util.Arrays.stream(T[]array)方法用数组创建流

int[] array={
    
    1,3,5,6,8};
IntStream stream = Arrays.stream(array);

4、通过构造器 Stream.builder() 创建

使用构建器时，应在语句的右侧部分另外指定所需类型，否则build()方法将创建Stream 的实例

Stream<String> streamBuilder = 
	Stream.<String>builder().add("a").add("b").add("c").build();

5、使用 Stream的静态方法：of()、iterate()、generate()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);

6、通过 File 创建

Java NIO类Files允许通过lines()方法生成文本文件的Stream 。 文本的每一行都成为流的一个元素：

Path path = Paths.get("C:\\file.txt");
Stream<String> streamOfFile = Files.lines(path);
Stream<String> streamWithCharset = Files.lines(path, Charset.forName("UTF-8"));

1.5、Stream操作分类

在这里插入图片描述

Stream操作分为两种：

  • 中间操作，每次返回一个新的流，可以有多个。

    • 无状态：指元素的处理不受之前元素的影响；
    • 有状态：指该操作只有拿到所有元素之后才能继续下去。

  • 终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。

    • 非短路操作：指必须处理所有元素才能得到最终结果；
    • 短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果。

在这里插入图片描述

二、Stream API 使用

2.1 中间操作

2.1.1、filter() 过滤

过滤器根据给定的谓词过滤流的所有元素，并返回一个新的流。
在这里插入图片描述
数据准备：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Fruit {
    
    
    //id
    private Integer id;
    //名称
    private String name;
    //颜色
    private String color;
    //数量
    private Integer num;
    //重量
    private Double weight;
}

List<Fruit> fruitList = new ArrayList<>();
fruitList.add(new Fruit(1, "apple", "green", 4, 300.0));
fruitList.add(new Fruit(2, "apple", "red", 14, 325.0));
fruitList.add(new Fruit(3, "apple", "yellow", 27, 450.0));
fruitList.add(new Fruit(4, "orange", "yellow", 10, 100.0));
fruitList.add(new Fruit(5, "banana", "yellow", 22, 250.0));

//1.查找重量大于400的苹果 filter
fruitList.stream().filter(p -> p.getName().equals("apple"))
	.filter(p -> p.getWeight() > 400.0)
	.forEach(System.out::println);
//结果输出
Fruit(id=3, name=apple, color=yellow, num=27, weight=450.0)

2.1.2、map与flatMap 映射

map：对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素，一对一映射
在这里插入图片描述

//2.将每种颜色苹果的数量增加5 map
fruitList.stream().filter(p -> p.getName().equals("apple"))
	.map(m -> m.getNum() + 5)
	.forEach(System.out::println);
//输出结果，新生成的Stream只包含苹果的数量
9
19
32

flatMap：对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素，一对多映射
在这里插入图片描述

//3.输出各种颜色苹果的数量 flatMap
fruitList.stream().filter(p -> p.getName().equals("apple"))
	.flatMap(m -> Stream.of(m.getColor() + ": " + m.getNum()))
	.forEach(System.out::println);
//输出结果
green: 4
red: 14
yellow: 27

2.1.3、sorted() 排序

对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。

//4.按重量由大到小对苹果进行排序 sorted倒序排
fruitList.stream().filter(p -> p.getName().equals("apple"))
	.sorted(Comparator.comparing(Fruit::getWeight).reversed())
	.forEach(System.out::println);
//输出结果
Fruit(id=3, name=apple, color=yellow, num=27, weight=450.0)
Fruit(id=2, name=apple, color=red, num=14, weight=325.0)
Fruit(id=1, name=apple, color=green, num=4, weight=300.0)

2.1.4、distinct() 去重

distinct()对stream中的相同元素进行去重

List<String> typeList = fruitList.stream().map(Fruit::getName).distinct().collect(Collectors.toList());
//["apple","orange","banana"]

2.1.5、concat() 合并

concat() 合并两个流

String[] arr1 = {
    
     "a", "b", "c", "d" };
String[] arr2 = {
    
     "a", "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
List<String> newList = Stream.concat(stream1, stream2).collect(Collectors.toList());
//流合并：[a, b, c, d, a, d, e, f, g]

2.1.6、limit() 限制

limit() 限制从流中获得前n个数据

List<Integer> collect = Stream.iterate(1, x -> x + 1)
	.limit(10).collect(Collectors.toList());
//limit：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2.1.7、skip() 跳过

skip() 跳过前n个数据

List<Integer> collect2 = Stream.iterate(1, x -> x + 1)
	.skip(5).limit(5).collect(Collectors.toList());
//skip：[6, 7, 8, 9, 10]

2.1.8、boxed() 装箱

将基本数据类型包装成引用类型

//int[]转List
int[] decimals = {
    
    1, 2, 3, 4, 5};
List<Integer> integers = Arrays.stream(decimals).boxed().collect(Collectors.toList());

2.2 终止操作

2.2.1、forEach() 遍历

//5.forEach遍历
fruitList.stream().forEach(System.out::println);

2.2.2、collect() 收集

collect()方法用于从steam 收集元素并将它们存储在集合中。

//6.筛选出颜色为黄色的水果 collect收集
fruitList.stream().filter(f -> f.getColor().equals("yellow"))
	.collect(Collectors.toList())
	.forEach(System.out::println);
//输出结果
Fruit(id=3, name=apple, color=yellow, num=27, weight=450.0)
Fruit(id=4, name=orange, color=yellow, num=10, weight=100.0)
Fruit(id=5, name=banana, color=yellow, num=22, weight=250.0)

2.2.2.1、partitioningBy/groupingBy 分区/分组

partitioningBy 分区：将stream按条件分为两个 Map，比如重量是否高于300g分为两部分。

groupingBy 分组：将集合分为多个Map，比如水果按类型分组。有单级分组和多级分组。

在这里插入图片描述

//8.分组
//按重量是否高于300g分组 partitioningBy分区
Map<Boolean, List<Fruit>> collect = fruitList.stream().collect(Collectors.partitioningBy(p -> p.getWeight() > 300.0));
System.out.println("按重量是否高于300g分组：" + collect);
//按水果类型分组
Map<String, List<Fruit>> collect1 = fruitList.stream().collect(Collectors.groupingBy(Fruit::getName));
System.out.println("按水果类型分组：" + collect1);
//按水果类型、颜色分组
Map<String, Map<String, List<Fruit>>> collect2 =
        fruitList.stream().collect(Collectors.groupingBy(Fruit::getName, Collectors.groupingBy(Fruit::getColor)));
System.out.println("按水果类型、颜色分组：" + collect2);

2.2.2.2、counting 计数

可使用count()聚合函数代替

2.2.2.3、averagingDouble 平均值

Double avgWeight = fruitList.stream().collect(Collectors.averagingDouble(Fruit::getWeight));
System.out.println("平均重量 = " + avgWeight);  //平均重量 = 285.0

2.2.2.4、maxBy minBy 最值

可使用 max()、min()聚合函数代替

2.2.2.5、summarizingDouble 统计

DoubleSummaryStatistics statistics = fruitList.stream().collect(Collectors.summarizingDouble(Fruit::getWeight));
//重量统计 = DoubleSummaryStatistics{count=5, sum=1425.000000, min=100.000000, average=285.000000, max=450.000000}
System.out.println("重量统计 = " + statistics);

2.2.2.6、joining 连接

joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。

String join = fruitList.stream().map(Fruit::getName).collect(Collectors.joining(","));
System.out.println("join = " + join);   //join = apple,apple,apple,orange,banana

2.2.2.7、toList、toSet、toMap 集合转换

//1.将不同水果种类转为list toList
List<String> typeList = fruitList.stream()
	.map(Fruit::getName).distinct()
	.collect(Collectors.toList());
//["apple","orange","banana"]

//2.将不同水果种类转为set toSet
Set<String> typeSet = fruitList.stream()
	.map(Fruit::getName)
	.collect(Collectors.toSet());
//["orange","banana","apple"]

//3.输出各种颜色苹果的数量 toMap
Map<String, Integer> appleMap = fruitList.stream()
	.filter(p -> p.getName().equals("apple"))
	.collect(Collectors.toMap(Fruit::getColor, Fruit::getNum));
//{"red":14,"green":4,"yellow":27}

2.2.3、match() 匹配

Stream 有三个 match 方法：

  • allMatch：Stream 中全部元素符合传入的 predicate，返回 true
  • anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
  • noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true
//7.匹配match
//anyMatch 任意一个匹配
fruitList.stream().anyMatch(p->p.getColor().contains("green")); //true
//noneMatch 全部不匹配
fruitList.stream().noneMatch(p->p.getColor().contains("green")); //false
//allMatch 全部匹配
fruitList.stream().allMatch(p->p.getColor().contains("green")); //false

2.2.4、count() max() sum() 聚合

// 8.聚合
//计算水果总数 sum
int sum = fruitList.stream().mapToInt(Fruit::getNum).sum();
System.out.println("sum = " + sum); //sum = 77
//计算水果种类数量 count
long count = fruitList.stream().map(Fruit::getName).distinct().count();
System.out.println("水果种类数量 = " + count);    //水果种类数量 = 3
//计算不同类型的水果数量 先分组再求和
Map<String, Integer> tSum = fruitList.stream().collect(Collectors.groupingBy(Fruit::getName, Collectors.summingInt(Fruit::getNum)));
System.out.println("tSum = " + tSum);   //tSum = {banana=22, orange=10, apple=45}
//最大重量 max
Optional<Fruit> max = fruitList.stream().max(Comparator.comparing(Fruit::getWeight));
System.out.println("最大重量 = " + max);    //最大重量 = Optional[Fruit(id=3, name=apple, color=yellow, num=27, weight=450.0)]

2.2.5、reduce() 规约

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
在这里插入图片描述

List<Integer> list = Arrays.asList(1, 2, 3, 4);
//求和
Optional<Integer> reduce = list.stream().reduce((x, y) -> x + y);
System.out.println("求和:" + reduce.get()); //10
//求积
Optional<Integer> reduce2 = list.stream().reduce((x, y) -> x * y);
System.out.println("求积:" + reduce2.get());	//24
//求最大值
Optional<Integer> reduce3 = list.stream().reduce((x, y) -> x > y ? x : y);
System.out.println("求最大值:" + reduce3.get());	//4

//计算水果总数
Optional<Integer> sum = fruitList.stream().map(Fruit::getNum).reduce(Integer::sum);
System.out.println("sum = " + sum.get()); //sum = 77
//计算最大重量
Optional<Double> maxWeight = fruitList.stream().map(Fruit::getWeight).reduce(Double::max);
System.out.println("maxWeight = " + maxWeight.get());   //maxWeight = 450.0

参考文章：https://www.dandelioncloud.cn/article/details/1468718846331953154

猜你喜欢

转载自blog.csdn.net/weixin_45698637/article/details/128469255
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022