学习笔记-Stream

最新推荐文章于 2024-07-22 17:32:31 发布
最新推荐文章于 2024-07-22 17:32:31 发布
阅读量45 收藏
点赞数
分类专栏： Java8新特性 文章标签： 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48880019/article/details/129718431
版权

是什么？

流，支持顺序和并行聚合操作的一系列元素。是一个操作，一个动作action。

有什么用？

对数据源（数组或集合）进行操作，产生新的数据。能高效便利的操作集合（collection）对象。适用于操作大批量数据。
数据源
批量操作
结果

怎么用？

1. 创建Stream

//collection流,通过Collection的stream()获得
       List<String> list = new ArrayList<>();
       Stream<String> stream = list.stream();

       //数组流，通过Arrays.stream()静态方法获得
       int[] count = new int[10];
       count[0] = 1;
       count[1] = 2;
       count[3] = 3;
       count[2] = 4;
       count[4] = 5;
       count[5] = 6;
       IntStream stream1 = Arrays.stream(count);
       IntStream stream2 = Arrays.stream(count, 1, 5);
       stream2.forEach(System.out::println);

       //Stream.of()静态方法获得
       Stream<String> stringStream = Stream.of("abc");
       Stream<String> stringStream1 = Stream.of("abc", "def");
       stringStream1.forEach(System.out::println);
       //该方法调用Arrays.stream("abc", "def");


       //无限流，Stream.iterate()静态方法获得，
       Stream<String> stream3 = Stream.iterate("Lambda", (x) -> x + "->method reference");
       //stream3.forEach(System.out::println);//Lambda的基础上不断地加->method reference
       /*Lambda
       Lambda->method reference
       Lambda->method reference->method reference
       Lambda->method reference->method reference->method reference
       Lambda->method reference->method reference->method reference->method reference
       Lambda->method reference->method reference->method reference->method reference->method reference
       .....*/
       //stream3.limit(12).forEach(System.out::println);//需要用limit指定输出大小，否则会无限输出
       Stream<Integer> iterate = Stream.iterate(0, (x) -> x + 1);
       iterate.limit(10).forEach(System.out::println);
       //无限流，Stream.generate()静态方法创建
       Stream.generate(() -> "return").limit(3).forEach(System.out::println);

       //基本数据类型流
       IntStream.range(1, 5).forEach(System.out::println);
       LongStream.range(1, 6).forEach(System.out::println);
       //range(),创建从第一个参数到第二个参数的有序流，以1的步长递增后续元素的值，不包括最后一个元素

       //字符串的流
       IntStream chars = "after".chars();
       chars.forEach(System.out::print);

2. 流操作

操作并不会改变原始数据，但会产生一个新的流，且如果不对产生的新流进行终端操作，该流不会有任何输出。流操作可以没有。
(1) 筛选 filter
从流中筛选元素

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    Stream<T> filter(Predicate<? super T> predicate);
    //参数为断言接口，可以用lambda表达式

示例：

//数组流，通过Arrays.stream()静态方法获得
        int[] count = new int[10];
        count[0] = 1;
        count[1] = 2;
        count[3] = 3;
        count[2] = 44;
        count[4] = 56;
        count[5] = 66;
        IntStream stream2 = Arrays.stream(count, 1, 5);
        //stream2.forEach(System.out::println);执行此代码后不可以执行中间操作
        IntStream intStream = stream2.filter((x) -> {System.out.println("是否大于3");return  x > 3;});
        //中间操作会返回一个新流。
        //如果在中间操作之前执行过终端操作（如forEach）则不可以执行中间操作。
        intStream.forEach(System.out::println);

（2) 截断流 limit
使元素不超过给定数量

		Stream<T> limit(long maxSize);

示例：

List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("ee");
        list.add("cc");
        list.add("dd");
        Stream<String> stream = list.stream();
        stream.limit(2).forEach(System.out::println);//aa ee

（3) 跳过元素 skip

		Stream<T> skip(long n);

示例：

List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("ee");
        list.add("cc");
        list.add("dd");
        Stream<String> stream = list.stream();
        stream.skip(2).forEach(System.out::println);//cc dd

(4) 去重 distinct
通过流生成元素的hashCode()和equals()去除重复元素。
对于对象来说要重写hashCode()和equals()才会去重成功

    	Stream<T> distinct();

示例：

List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("aa");
        list.add("aa");
        list.add("aa");
        Stream<String> stream = list.stream();
        stream.skip(2).forEach(System.out::println);//cc dd

(5) 映射 map
以函数为参数，将每个元素都以函数作用之后返回一个新元素 。

    	<R> Stream<R> map(Function<? super T, ? extends R> mapper);
    	//以函数接口为参数。Function,接收一个参数，返回一个类型。

示例：

		List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("aa");
        list.add("aa");
        list.add("aa");
        Stream<String> stream = list.stream();
        stream.map((x) -> x.toUpperCase() + "小写变大写").forEach(System.out::println);

(5) 映射 flatMap
以函数为参数，将每个元素都以函数作用之后返回一个新流，再将每个元素产生的流拼接成一个流 。

    	<R> Stream<R> map(Function<? super T, ? extends R> mapper);
    	//以函数接口为参数。Function,接收一个参数，返回一个类型。

示例：

		public class StreamTest {
		    @Test
		    public void TestStream(){
		        List<String> list = new ArrayList<>();
		        list.add("aa");
		        list.add("aa");
		        list.add("aa");
		        list.add("aa");
		        Stream<String> stream = list.stream();

				stream.flatMap(StreamTest::toStream).forEach(System.out::println);
				//使用flatMap可以达到以下两行代码的效果
		        //Stream<Stream<Character>> streamStream = stream.map(StreamTest::toStream);
		        //此时中间操作返回一个流 （包含着很多流）
		        //streamStream.forEach((x) -> x.forEach(System.out::println));    }
		
		    //传入字符串返回一个流
		    public static Stream<Character> toStream(String string) {
		        List list = new ArrayList<>();
		        for (Character ch : string.toCharArray()) {
		            //String -> char[]
		            list.add(ch);//将每个Character存入List中            
		        }
		        Stream stream = list.stream();
		        return stream;
		    }
		}

（6) 自然排序 sorted

		    Stream<T> sorted();

示例：

		List<String> list = new ArrayList<>();
        list.add("abcde");
        list.add("ab");
        list.add("abcd");
        list.add("abc");
        Stream<String> stream = list.stream();
        stream.sorted().forEach(System.out::println);
        //ab
		//abc
		//abcd
		//abcde

(7) 定制排序 sorted（Comparator com)

    	Stream<T> sorted(Comparator<? super T> comparator);

示例：

			List<String> list = new ArrayList<>();
	        list.add("abcde");
	        list.add("ab");
	        list.add("abcd");
	        list.add("abc");
	        Stream<String> stream = list.stream();
	        stream.sorted((e, x) -> {
	            if (e.length() < x.length()) {
	                return 1;
	            }else
	            {
	                return -1;
	            }
	     	 }).forEach(System.out::println);
	     	 //abcde
			 //abcd
			 //abc
			 //ab

3. 终端操作

创建流后可以直接执行终端操作。

  1. allMatch 检查是否匹配所有元素
		boolean allMatch(Predicate<? super T> predicate);
  1. anyMatch 检查是否匹配至少一个元素
		boolean anyMatch(Predicate<? super T> predicate);
  1. noneMatch Z检查是否没有匹配所有元素
		boolean noneMatch(Predicate<? super T> predicate);
  1. findFirst 返回第一个元素
		Optional<T> findFirst();

示例：

List<String> list = new ArrayList<>();
        list.add("abcde");
        list.add("ab");
        list.add("abcd");
        list.add("abc");
        Stream<String> stream = list.stream();
        Optional<String> first = stream.findFirst();
        System.out.println(first.get());//
  1. findAny 返回当前流的任意一个元素
		Optional<T> findAny();
  1. count 返回流中元素的总个数
		long count();
  1. max 返回流最大值
		Optional<T> max(Comparator<? super T> comparator);
  1. min 返回流最小值
		Optional<T> min(Comparator<? super T> comparator);

示例：

		 Optional<String> max = stream.min((x, y) -> {
            if (x.length() > y.length()) {
                return 1;
            } else {
                return -1;
            }
        });
        System.out.println(max.get());//ab
  1. reduce 归约
		T reduce(T identity, BinaryOperator<T> accumulator);
		//指定初始值，并对流内元素进行累加操作，返回值一定不为空
		Optional<T> reduce(BinaryOperator<T> accumulator);
		//返回值可能为空，所以返回Optional
		 <U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

示例：

		List<String> list = new ArrayList<>();
        list.add("abcde");
        list.add("ab");
        list.add("abcd");
        list.add("abc");
        Stream<String> stream = list.stream();
        String reduce = stream.reduce("0", (x, y) -> x + y);
        System.out.println(reduce);
        //0abcdeababcdabc
  1. collect 收集
		<R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);
                  
	       <R, A> R collect(Collector<? super T, A, R> collector);
	       //Collector是一个接口是一个收集器，该接口有一个实现类:Collectors提供很多静态方法，

示例：

		List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 12, "秦国", "学习中"));
        list.add(new Student("李四", 13, "楚国", "缀学"));
        list.add(new Student("王五", 15, "晋国", "学习中"));
        list.add(new Student("赵六", 16, "赵国", "缀学"));
        Stream<Student> stream = list.stream();
        HashSet<String> collect = stream.map(Student::getName).collect(Collectors.toCollection(HashSet::new));
        collect.forEach(System.out::println);

补充知识

Optional 对象

是一个容器对象，可以包含也可以不包含非null值。个人理解是一个包装类，可以将类进行包装，能避免空指针异常。

		Optional<Object> empty = Optional.empty();
        //获取空的Optional对象
        Optional<Student> stuOp = Optional.ofNullable(new Student());
        Optional<Student> stuOp1 = Optional.of(new Student());
        //获取Optional对象
        //of与ofNullable区别:两者方法传入参数为null时，of方法会报错，而ofNullable不会报错。

        Student student = stuOp.get();
        //获取Optional封装的对象

        Student s  = new Student("zs", 1, "齐国", "学习中");
        stuOp.orElse(s);
        stuOp1.orElseGet(Student::new);
        //Optional不为空返回包含值，为空返回形参。
        //区别: orElseGet操作空间更大。且当Optional不为空时不会执行orElseGet方法，而orElse不论Optional是否为空都执行。

        boolean present = stuOp.isPresent();
        //判断Optional对象是否为空

        Optional<Student> stu = Optional.ofNullable(s);
        System.out.println(stu.map((y) -> y.getName()).get());

        System.out.println(stu.flatMap((y) -> Optional.of(y.getName())).get());
        //对Optional进行处理，处理结果有值时返回新的Optional，无值返回Optional.empty()
        //区别:方法 形参的返回值 不同，flatMap形参返回必须是Optional;
        //Optional在存在始终牵着Null的手

Fork/Join框架

将一个大任务拆分为多个小任务，然后将小任务的执行结果进行汇总。当数据量庞大时适合使用。

并行流

把一个流的内容拆分为多个数据块，使用多个线程分别处理每个数据块的流。并行流内部使用的是Fork/Join框架。在Stream中可以使用parallel() 和 sequential() 进行并行和顺序的转换。

左戍戎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Nodejs学习笔记之Stream模块
01-20
在Node.js中，Stream模块是核心模块之一，它提供了一种高效处理大量数据的方式，尤其在处理I/O操作时。Stream的概念源自Unix操作系统，通过管道（"|"）连接不同的进程来处理数据流。在Node.js中，Stream同样扮演着...
Stream学习
qq_39542702的博客
06-17 1101
Stream学习
前端学习笔记-Node.js
05-26
3. **流(Stream)**：学习Node.js的流API，如读写流、 Transform流，以及如何在处理大文件时使用流提高性能。 4. **中间件(Middleware)**：了解Express框架中常用的中间件机制，如connect、body-parser等。 **Node....
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
编程学习之路：从零到一的成长指南
KsuferNotes
07-22 251
在当今数字化时代，编程技能已经成为许多人职业发展的重要组成部分。不论你是已经在IT业从业多年的老手，还是刚刚起步的编程新手，这篇博客将带你走过编程学习的每一个重要阶段，从而顺利完成从零到一的华丽转变。
学习测试10-3自动化 web自动化
最新发布
qq_44897733的博客
07-22 382
链接: https://pan.baidu.com/s/1QnGEAeP4ASMgdBYbAtSUTg?pwd=8sdd 提取码: 8sdd。性别、生日、出生地、居住地、情感状态、交友目的、血型。复制这段内容后打开百度网盘手机App，操作更方便哦。2、输入用户名，密码，（使用id属性）4、所有信息后的下拉框设置为保密。论坛系统课堂及其课后练习题库。3、基本资料栏位依次输入内容。三、单个注册与连续注册多个。4、实现连续注册10个账号。二、设置用户的真实姓名。
kubernetes学习日志（七）
qq_47037022的博客
07-18 609
本文记录了service管理，ingress管理，Dashboard管理插件，集群鉴权策略，角色与全局角色，赋权与全局角色赋权。
纯前端小游戏，4096小游戏，有音效，Html5，可学习使用
m0_62996549的博客
07-18 473
【代码】纯前端小游戏，4096小游戏，有音效，Html5，可学习使用。
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 563
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
昇思25天学习打卡营第16天|munger85
MungerVC
07-20 424
MobileNet网络是由Google团队于2017年提出的专注于移动端、嵌入式或IoT设备的轻量级CNN网络，相比于传统的卷积神经网络首先安装依赖下载数据。
2024论文精读：利用大语言模型（GPT）增强上下文学习去做关系抽取任务
YxinMiracle's Studio.
07-20 952
高引论文精度，如何利用大预言模型做关系抽取任务
从0开始的STM32HAL库学习6
hwq_1229_0525的博客
07-21 255
配置红色框图中的各种配置时钟源选择外部时钟 21.预分频器Prescaler，下面填0，不分频2.计数模式，计数模式选择为向上计数3.自动重装寄存器，自动重装计数器填为10，计数到10后清空并出发中断4.滤波器的频率分频：不使用影子寄存器。
javaScrip的学习（一）
weixin_65450681的博客
07-19 1261
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
huawei USG6001v1学习--防火墙相关知识（1）
m0_65350813的博客
07-19 413
防火墙主要是借助硬件和软件的作用于内部和外部网络的环境间产生一种保护的屏障，从而实现对计算机不安全网络因素的阻断。
《书生大模型实战营第3期》入门岛 学习笔记与作业：Python 基础知识
shiter编写程序的艺术
07-21 692
python开发简介：【集成开发环境 IDE】python开发简介：【Conda，Pip】虚环境搭建、配置python开发简介：【jupyter notebook】实战配置python开发简介： 编码规范与工程基础实践使用 jupyter hub /lab搭建机器学习工作台使用跨平台的visual studio code 进行python 开发（综合内容老版本）python 开发环境搭建（综合内容老版本）其实Python 的环境配置在所有编程技术栈中是相对简单的，由于conda，pip 的存在。
昇思25天学习打卡营第30天 | 文本解码原理--以MindNLP为例
嫦娥妹妹等等我的博客
07-22 674
学习MindNLP进行文本解码的经验为我揭示了自然语言处理中文本生成技术的复杂性与美妙之处。通过使用MindNLP库，我能够深入理解并实践如何基于预训练的GPT2模型生成文本，特别是学习如何控制生成过程，从贪婪搜索到Beam搜索，再到采样技术，每种方法都有其独特的优势和适用场景。
ES中的数据类型学习之Aggregate metric(聚合计算)
cclovezbf的博客
07-22 494
"metrics": [ "min", "max", "sum", "value_count" ], --那些聚合操作。--"field": "agg_metric" 代表的是对哪个字段进行聚合可能有agg_metric1，agg_metric2。"default_metric": "max" -- 默认显示的聚合字段 用来query的。"type": "aggregate_metric_double", --字段类型。"my-agg-metric-field": { -- 字段名。
FastAPI（六十五）实战开发《在线课程学习系统》基础架构的搭建
mr~li的博客
07-19 204
接下来我们的开发只需要关注主逻辑的处理即可，准备放到对应的crud.py和schemas.py文件中，其中crud主要是逻辑处理详细代码，schemas中主要是参数模型以及响应结果模型。在之前三篇，我们分享的就是需求的分析，基本接口的整理，数据库链接的配置。放所有中间件的地方，比如mysql，redis，mongodb等（主要是数据库操作相关）数据库表模型放在这里（你也可以把数据库相关的都放在这个目录下）之前配置的链接mysql数据库的配置放在对应的database.py中。通用目录，放一些通用的处理。
Vivado设计套件中的AXI4-Stream基础设施IP教程
"AXI4-Stream Infrastructure IP Suite v3.0 教程与笔记习题" AXI4-Stream Infrastructure IP Suite是Xilinx Vivado Design Suite中的一个关键组件，主要针对高速数据传输需求，广泛应用于高性能计算、图像处理、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值