第7章-第9节-Java中的Stream流（链式调用）

1、什么是Stream流

Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。

2、案例

假设现在有一个需求， 将list集合中姓张的元素过滤到一个新的集合中；然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中

// 已知的知识来解决需求
List<String> list1 = new ArrayList<>();
list1.add("张老三");
list1.add("张小三");
list1.add("李四");
list1.add("赵五");
list1.add("张六");
list1.add("王八");ArrayList<String> list2 = new ArrayList<>();
// 1.将list集合中姓张的元素过滤到一个新的集合中
for(String name : list1){if(name.startsWith("张")){list2.add(name);}
}
ArrayList list3 = new ArrayList();
for (String name : list2) {if (name.length() == 3){list3.add(name);}
}
System.out.println(list3);

很麻烦，不是吗，同样我们需要更加简洁优雅的方式实现 (链式调用)

3、 Stream流

list1.stream().filter((String name)->name.startsWith("张")).filter((String name)->name.length()==3).forEach((String name)->{System.out.println("符合条件的姓名：" + name);
});

4、获取流的方式

Stream<String> stream1 = list.stream();
Stream<String> stream2 = set.stream();//根据Map集合的键获取流
Set<Integer> map1 = map.keySet();
Stream<Integer> stream3 = map1.stream();
//根据Map集合的值获取流
Collection<String> map2 = map.values();
Stream<String> stream4 = map2.stream();
//根据Map集合的键值对对象获取瑞
Set<Map.Entry<Integer, String>> map3 = map.entrySet();
Stream<Map.Entry<Integer, String>> stream5 = map3.stream();
// 根据数组获取流
String[] arr = {"张颜宇","张三","李四","赵五","刘六","王七"};
Stream<String> stream6 = Stream.of(arr);

5、Stream流的常用方法

1）、count方法

List<String> list = new ArrayList<>();list.add("张老三");list.add("张小三");list.add("李四");list.add("赵五");list.add("张六");list.add("王八");long count = list.stream().count();System.out.println("集合中的元素个数是：" + count);//输出结果：//集合中的元素个数是：6

2）、filter 方法

// 获取stream流
Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
// 需求：过去出姓张的元素
stream.filter((String name)->{return name.startsWith("张");
}).forEach((String name)->{System.out.println("流中的元素" + name);
});

3）、foreach 方法

List<String> list = new ArrayList<>();
list.add("张老三");
list.add("张小三");
list.add("李四");
list.add("赵五");
list.add("张六");
list.add("王八");// 函数模型：获取流 --> 注意消费流中的元素
list.stream().forEach((String name)->{System.out.println(name);
});

4）、limit方法

// 获取流的长度
Stream<String> stream1 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
// 需求：保留前三个元素
stream1.limit(3).forEach((String name)->{System.out.println("流中的前三个元素是：" + name);
});

5）、map方法

//基本类型转换    
// 获取Stream流
Stream<String> stream1 = Stream.of("11","22","33","44","55");
// 需求：把stream1流中的元素转换为int类型
stream1.map((String s)->{return Integer.parseInt(s); // 将String类型的s进行转换为Integer类型的元素，并返回
}).forEach((Integer i)->{System.out.println(i);  // 将转换后的int类型的元素逐一输出
});
//大写转换收集
List list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("orange");
Stream stream = list.stream().map(s -> s.toUpperCase());
stream.forEach(System.out::println);
//元素计算收集
List list = Arrays.asList(1, 2, 3, 4, 5);
List resultList = list.stream().map(x -> x * x).collect(Collectors.toList());
System.out.println(resultList);
//引用数据类型属性收集
List people = new ArrayList<>();
people.add(new Person("Tom", 18));
people.add(new Person("Jerry", 20));
List result = people.stream().map(Person::getName).collect(Collectors.toList());
System.out.println(result);
//实体类map类型收集
List people = new ArrayList<>();
people.add(new Person("Tom", 18));
people.add(new Person("Jerry", 20));
Map result = people.stream().collect(Collectors.toMap(Person::getName, Person::getAge));
System.out.println(result);

6）、skip方法

// 获取stream流
Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
stream.skip(3).forEach((String name)->{System.out.println("跳过前三个，打印剩下的" + name);
});

7）、concat方法

Stream<String> stream1 = Stream.of("11","22","33","44","55");
Stream<String> stream2 = Stream.of("张颜宇", "张三", "李四", "赵五", "刘六", "王七");
// 需求：合并两个流
Stream<String> stream = Stream.concat(stream1,stream2);
stream.forEach((String name)->{System.out.print(name);
});

 8）、收集Stream流方法

List<String> list2 = new ArrayList<>();
list2.add("张老三");
list2.add("张小三");
list2.add("李四");
list2.add("赵五");
list2.add("张六");
list2.add("王八");// 需求：过滤出姓张的并且长度为3的元素
Stream<String> stream = list2.stream().filter((String name) -> {return name.startsWith("张");
}).filter((String name) -> {return name.length() == 3;
});// stream 收集到单列集合中
List<String> list = stream.collect(Collectors.toList());
System.out.println(list);// stream 收集到单列集合中
Set<String> set = stream.collect(Collectors.toSet());
System.out.println(set);
public class StreamTest {public static void main(String[] args) {List<String> names = new ArrayList<>();//Collections.addAll();Collections.addAll(names,"张三丰","张无忌","李四","王五","李娜","吴彦祖");
//        System.out.println(names);//        for (String s:names) {
//            //打印所有姓张的
//            if(s.startsWith("张")){
//                System.out.println(s);
//            }
//            //打印出所有名字长度是3的
//            if(s.length()==3){
//                System.out.println(s);
//            }
//        }//Stream 流实现集合过滤//1. 通过集合获取流Stream<String> s1 = names.stream();//2. 过滤器 filter  遍历器  foreach//过滤出所有姓张的姓名
//        s1.filter((String name) -> name.startsWith("张"))
//                .forEach((String name) -> {
//                    System.out.println(name);
//                });//limit（X） 取前X个数据Stream<String> stm2 = Stream.of("张小毛","赵本山","吴亦凡","曹孟德","刘备","李斯");
//        stm2.limit(3).forEach((String s) -> System.out.println(s));//skip（X） 跳过X个数据，打印剩下的
//        stm2.skip(3).forEach((String s) -> System.out.println(s));//concat（流1，流2） 合并流1和流2 （泛型最好相同）Stream<String> stream3 = Stream.of("11","22","33","44","55");//合并两个流存到stmAll中
//        Stream<String>stmAll = Stream.concat(stm2,stream3);
//        stmAll.forEach((String s) -> System.out.println(s));//map 映射
//        stream3.map((String n) -> {
//            return Integer.parseInt(n);
//        }).forEach((Integer num)-> System.out.println(num));//        stream3.map((String number) -> {
//            number = "100";
//            return number;
//        }).forEach((String n) -> System.out.println(n));Stream<String> stm4 = Stream.of("张小毛","赵本山","吴亦凡","曹孟德","刘备","李斯");//挑选出3个字名字，并且存入一个List中List ss = stm4.filter((String name) ->name.length() == 3).collect(Collectors.toList()); //collect收集方法：将过滤出来的数据转为集合//Collectors.toList()转为什么集合toList List集合//关闭stm4.close();System.out.println(ss);//        AtomicInteger sum = new AtomicInteger();
//        AtomicInteger sum_mew = new AtomicInteger();
//        stream3.map((String n) -> {
//        sum.set(Integer.parseInt(n) + sum.get());
//        return sum;
//        }).forEach((AtomicInteger num)-> {
//            sum_mew.set(num.get());
//        });
//        System.out.println("总和为："+sum_mew);}
}

9）、Stream流的reduce方法

//利用reduce方法快捷运算
List numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce((a, b) -> a + b).get();
System.out.println(sum);

本电子书目录：《Java基础的重点知识点全集》

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/334834.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【Leetcode】236.二叉树的最近公共祖先

【Leetcode】236.二叉树的最近公共祖先

一、题目 1、题目描述 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 示例1…
阅读更多...
使用Moonbuilders Academy平台，学习DApp开发

使用Moonbuilders Academy平台，学习DApp开发

Moonbeam团队于2022年宣布开放Moonbuilders Academy。这是一套以开发为中心的异步学习课程&#xff0c;用于学习如何在Moonbeam上构建跨链DApp。 如何从官网进入平台&#xff1f; 点击http://moonbeam.network 鼠标移动至 “Builders”&#xff0c;在Resources下方选择“Moo…
阅读更多...
【Java并发】聊聊concurrentHashMap的put核心流程

【Java并发】聊聊concurrentHashMap的put核心流程

结构介绍 1.8中concurrentHashMap采用数组链表红黑树的方式存储&#xff0c;并且采用CASSYN的方式。在1.7中主要采用的是数组链表&#xff0c;segment分段锁reentrantlock。本篇主要在1.8基础上介绍下. 那么&#xff0c;我们的主要重点是分析什么呢&#xff0c;其实主要就是p…
阅读更多...
DRM-VAE

DRM-VAE

&#x1d6ff; means variance&#xff0c;&#x1d443;(&#x1d44b;|&#x1d467;;&#x1d703;) means a function that make &#x1d467; close to &#x1d44b;. 作者未提供代码
阅读更多...
Selenium 学习（0.19）——软件测试之基本路径测试法——拓展案例

Selenium 学习（0.19）——软件测试之基本路径测试法——拓展案例

1、案例 请使用基本路径法为变量year设计测试用例&#xff0c;year的取值范围是1000<year<2001。代码如下&#xff1a; 2、步骤 先画控制流程图 再转化为控制流图&#xff08;标出节点&#xff09; V(G) 总区域数 4 V(G) E - N 2 (边数 - 节点数 2…
阅读更多...
【HarmonyOS4.0】第三篇-类web开发模式

【HarmonyOS4.0】第三篇-类web开发模式

【HarmonyOS4.0】第三篇-类web开发模式 一、鸿蒙介绍 课程核心 为什么我们需要学习鸿蒙&#xff1f; 哪些人适合直接转鸿蒙&#xff1f; 鸿蒙系统优势是什么&#xff1f; 课程内容 (1)为什么要学习鸿蒙 从行情出发&#xff1a; 美国商务部长访问中国&#xff0c;2023年…
阅读更多...
文件上传至阿里云

文件上传至阿里云

注册阿里云账号后,开通好对象存储服务&#xff08;OSS&#xff09;&#xff0c;三个月试用 阿里云登录页 (aliyun.com) 目录 一.创建Bucket 二.获取AccessKey&#xff08;密钥&#xff09; 三.参考官方SDK文件&#xff0c;编写入门程序 1.复制阿里云OSS依赖&#xff0c;粘贴…
阅读更多...
数模学习day10-聚类模型

数模学习day10-聚类模型

说明&#xff0c;本文部分图片和内容源于数学建模交流公众号 目录 K-means聚类算法 K-means聚类的算法流程&#xff1a; 图解 算法流程图 评价 K-means算法 基本原则 算法过程 Spss软件操作 K-means算法的疑惑 系统&#xff08;层次&#xff09;聚类 算法流程 Sp…
阅读更多...
设计模式之外观模式【结构型模式】

设计模式之外观模式【结构型模式】

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档> 学习的最大理由是想摆脱平庸&#xff0c;早一天就多一份人生的精彩&#xff1b;迟一天就多一天平庸的困扰。各位小伙伴&#xff0c;如果您&#xff1a; 想系统/深入学习某…
阅读更多...
Camunda ServiceTask

Camunda ServiceTask

一&#xff1a;Java class Java class实现JavaDelegate接口&#xff0c;只需要配置类的全限定名即可&#xff0c;不需要被Spring容器管理。 public class JavaClassServiceTask implements JavaDelegate {Overridepublic void execute(DelegateExecution execution) throws …
阅读更多...
6.1 截图工具HyperSnap6简介

6.1 截图工具HyperSnap6简介

图片是组成多媒体作品的基本元素之一&#xff0c;利用图片可以增强多媒体作品的亲和力和说说服力。截取图片最简单的方法是直接按下键盘上的“PrintScreen”键截取整个屏幕或按下“AltPrintScreen”组合键截取当前活动窗口&#xff0c;然后在画笔或者其它的图片处理软件中进行剪…
阅读更多...
Hyperledger Fabric 管理链码 peer lifecycle chaincode 指令使用

Hyperledger Fabric 管理链码 peer lifecycle chaincode 指令使用

链上代码&#xff08;Chaincode&#xff09;简称链码&#xff0c;包括系统链码和用户链码。系统链码&#xff08;System Chaincode&#xff09;指的是 Fabric Peer 中负责系统配置、查询、背书、验证等平台功能的代码逻辑&#xff0c;运行在 Peer 进程内&#xff0c;将在第 14 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023