当前位置： 首页 > news >正文

StreamAPI

news 2025/8/24 3:14:26

StreamAPI

最近开发用上了 Java8的StreamAPI,(咋现在才用?嗯哼,项目需要)自己也不怎么会,来总结一波吧!

别认为好抽象!!!干他就完事
在这里插入图片描述

一.StreamAPI介绍

就是用来处理集合的数据 其实到后面会发现和SQL的语句是差不多的~哈哈?你不信?往下面看

Stream:英文翻译叫做流

举个粟子:Stream相当于一条河流,数据相当于里面的水,这条河流里面的水你要饮用还是其他操作叫做Stream的执行数据操作,从而达到你要的目的(比如达成饮用水的目的),在计算机中就是处理达成你要的结果

注意!

  1. Stream不会自己存储元素
  2. 不会改变源对象,只是返回含有结果的一个新Stream
  3. 延迟执行,在要结果的时候才执行(有点像懒汉模式)
    在这里插入图片描述

二.流操作的过程

主要就是从生到死周期

  1. 创建Stream:就是从一个数组或者集合拿取数据(相当于找到水源地)
//主要两种创建方式:
1.Steam()
2.parallelStream()   //这个主要返回并行流//eg:List<String>  list=new ArrayList<>();Stream<String> s1=list.stream();//   
===========================================
//值创建流     Stream.of()   静态方法显示创建   Stream<String>  s=Stream.of("a","s","ddddd");s.forEach(System.out::println);==============================================
//创建无限流   Stream.iterate()  和  Stream.generate()两个方法//举例  迭代Steam<Integer> s=Stream.iterate(0,(x)->x>>1);s.limit(10).forEach(System.out::println);//举例 生成Stream.generate(()->Math.random().limit(6)forEach(System.out::println));
  1. **中间逻辑操作:**就相当于SQL语句中执行条件,处理达到你要的结果和业务数据(比如你要取水去做饮用水啊中间是不是要净化啥的操作)

看下面的主题,太多了,但也是重点

  1. **结束:**就是终止条件,写结果返回语句,不能无休止啊

三.中间操作

在终止操作时才会一次性全部处理,就是要到开学了,小学生才会用功写完全部作业~哈哈

filter,limit,skip,distinct

1.筛选切片

Filter:接受Lambda,进行过滤操作,排除一些不需要的元素

// (1)filter——接收 Lambda ， 从流中排除某些元素。@Testpublic void testFilter() {//这里加入了终止操作 ，不然中间操作一系列不会执行//中间操作只有在碰到终止操作才会执行emps.stream().filter((e)->e.getAge()>18)  //过滤只要年龄大于18 的.forEach(System.out::println);//终止操作}

limit(n):截取指定n个以内数量的元素

// （2）limit——截断流，使其元素不超过给定数量。@Testpublic void testLimit() {emps.stream().filter((e)->e.getAge()>8).limit(6)//跟数据库中的limit有差不多.forEach(System.out::println);//终止操作}

skip(n):跳过元素,就是前n个元素不要,从第n+1个数开始,没有,就返回空

// （3)skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补@Testpublic void testSkip() {emps.stream().filter((e)->e.getAge()>8).skip(2)//这里可以查找filter过滤后的数据，前两个不要，要后面的，与limit相反.forEach(System.out::println);//终止操作}

distinct:就是去重,返回不重复的元素

原理:利用hashCode()和equals()去除重复的元素,

// （4）distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素@Testpublic void testDistinct() {emps.stream().distinct()//去除重复的元素，因为通过流所生成元素的 hashCode() 和 equals() 去除重复元素，所以对象要重写hashCode跟equals方法.forEach(System.out::println);//终止操作}

2.Map映射

  • map()
  • mapToDouble()
  • mapToInt()
  • mapToLong()
  • flatMap()

map():就是接受一个函数作为参数,该参数会被应用到每个元素上,并且映射成一个新的元素

flatMap():接受一个函数作为参数,并且将流中每个值转换成另一个流,然后把所有的流连成一个流

直接复制了哈,这个代码感觉还是不错的,一起看看吧~哈哈

//  map-接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。@Testpublic void testMapAndflatMap() {List<String> list=Arrays.asList("aaa","bbb","ccc","ddd");list.stream().map((str)->str.toUpperCase())//里面是Function.forEach(System.out::println);System.out.println("----------------------------------");//这里是只打印名字，map映射，根据Employee::getName返回一个name，映射成新的及结果nameemps.stream().map(Employee::getName).forEach(System.out::println);System.out.println("======================================");//流中流Stream<Stream<Character>> stream = list.stream().map(StreamAPI::filterCharacter);//{{a,a,a},{b,b,b}}//map是一个个流（这个流中有元素）加入流中stream.forEach(sm->{sm.forEach(System.out::println);});System.out.println("=============引进flatMap=============");
//      只有一个流Stream<Character> flatMap = list.stream().flatMap(StreamAPI::filterCharacter);//flatMap是将一个个流中的元素加入流中//{a,a,a,b,b,b}flatMap.forEach(System.out::println);}/*** 测试map跟flatMap的区别* 有点跟集合中的add跟addAll方法类似    这个就好理解多了* add是将无论是元素还是集合，整体加到其中一个集合中去[1,2,3.[2,3]]* addAll是将无论是元素还是集合，都是将元素加到另一个集合中去。[1,2,3,2,3]* @param str* @return*/public static Stream<Character> filterCharacter(String str){List<Character> list=new ArrayList<>();for (Character character : str.toCharArray()) {list.add(character);}return list.stream();}

3.排序

自然排序: sorted()

定制排序: sorted(Comparator c): 就是里面写你想添加判断条件

货不多说,看测试代码

@Testpublic  void  testSorted() {List<String> list=Arrays.asList("ccc","aaa","bbb","ddd","eee");list.stream().sorted().forEach(System.out::println);System.out.println("=======定制排序=========");//=====仔细瞅瞅这边emps.stream().sorted((x, y) -> {if(x.getAge() == y.getAge()){return x.getName().compareTo(y.getName());}else{return Integer.compare(x.getAge(), y.getAge());}}).forEach(System.out::println);}

四.结束

1.查找与匹配

allMatch(): 检查是否匹配所有元素

anyMatch(): 检查是否至少匹配一个元素

noneMatch(): 是否没有匹配的所有元素

findFirst(): 返回第一个元素

findAny(): 返回当前流中的任意元素

count(): 返回流中的元素总数

max(),min(): 返回流中的最大最小值

forEach(): 就是迭代循环,贼常用的

**测试代码:**复制过来的,写的不好,可以留言哈!!!

    //3. 终止操作/*查找与匹配allMatch——检查是否匹配所有元素anyMatch——检查是否至少匹配一个元素noneMatch——检查是否没有匹配的元素findFirst——返回第一个元素findAny——返回当前流中的任意元素count——返回流中元素的总个数max——返回流中最大值min——返回流中最小值*/@Testpublic void test() {
//      emps.stream():获取串行流
//      emps.parallelStream()：获取并行流System.out.println("==========allMatch==============");boolean allMatch = emps.stream().allMatch((e)->e.getStatus().equals(Status.BUSY));System.out.println(allMatch);System.out.println("==========anyMatch==============");boolean anyMatch = emps.stream().anyMatch((e)->e.getAge()>10);System.out.println(anyMatch);System.out.println("==========noneMatch==============");boolean noneMatch = emps.stream().noneMatch((e)->e.getStatus().equals(Status.BUSY));System.out.println(noneMatch);System.out.println("==========findFirst==============");Optional<Employee2> findFirst = emps.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))//按照工资排序并输出第一个.findFirst();       System.out.println(findFirst);System.out.println("==========findAny==============");Optional<Employee2> findAny = emps.stream().filter((e)->e.getStatus().equals(Status.BUSY)).findAny();System.out.println(findAny);System.out.println("==========count==============");long count = emps.stream().count();System.out.println(count);System.out.println("==========max==============");Optional<Double> max = emps.stream().map(Employee2::getSalary).max(Double::compare);System.out.println(max);System.out.println("==========min==============");Optional<Employee2> min = emps.stream().min((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()));System.out.println(min);}

2.归纳

reduce(T iden,BinaryOperator b):流中元素反复结合得到一个值,返回T

reduce(BinaryOperator b):流中元素反复结合得到一个值,返回Optional<T>

map-reduce模式感兴趣可以骚操作一波

@Testpublic void testReduce() {List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8,9,10);Integer sum = list.stream().reduce(0,(x,y)->x+y);System.out.println(sum);Optional<Double> reduce = emps.stream().map(Employee2::getSalary).reduce(Double::sum);System.out.println(reduce.get());}

3.收集

collect():你想收集成啥样的集合返回

Collectors其中主要的方法:

方法名作用返回类型
toSet把流中元素收集到setSet
toList将流中的元素收集到ListList
toCollection:将流中的元素收集到自己创建的集合中Collection
counting计算流中的元素个数long
summingInt对元素中的整数类型求和Integer
averagingInt求平均值Double
summarizingInt收集流中Integer属性的统计值IntSummaryStatistics
方法作用返回类型
joining连接流中的每个字符串String
maxBy,minBy根据比较器选择最大最小值Optional
reducing归约归约产生的类型
collectingAndThen包裹另一个收集器并对其结果转换函数转换函数返回的类型
groupingBy根据某些属性值对流分组,属性为k,结果为vMap<K,List>
partitioningBy根据true或false进行分区Map<Boolean,List>

测试代码:

//===============
List<String> collect = emps.stream().map(Employee2::getName).collect(Collectors.toList());collect.forEach(System.out::println);
//=====================================================Set<String> collect2 = emps.stream().map(Employee2::getName).collect(Collectors.toSet());collect2.forEach(System.out::println);
//=======================================================
HashSet<String> collect3 = emps.stream().map(Employee2::getName).collect(Collectors.toCollection(HashSet::new));collect3.forEach(System.out::println);
//======================================================Optional<Double> collect = emps.stream().map(Employee2::getSalary).collect(Collectors.maxBy(Double::compare));System.out.println(collect.get());Optional<Employee2> collect2 = emps.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));System.out.println(collect2.get());
//=======================================================
Optional<Double> collect4 = emps.stream().map(Employee2::getSalary).collect(Collectors.minBy(Double::compare));System.out.println(collect4);Optional<Employee2> collect3 = emps.stream().collect(Collectors.minBy((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary())));System.out.println(collect3.get());
//====================================================
Double collect5 = emps.stream().collect(Collectors.summingDouble(Employee2::getSalary));System.out.println(collect5);
//========================================================
Double collect6 = emps.stream().collect(Collectors.averagingDouble((e)->e.getSalary()));Double collect7 = emps.stream().collect(Collectors.averagingDouble(Employee2::getSalary));System.out.println("collect6："+collect6);System.out.println("collect7："+collect7);
//=======================================================
//总数Long collect8 = emps.stream().collect(Collectors.counting());System.out.println(collect8);
//====================================================
DoubleSummaryStatistics collect9 = emps.stream().collect(Collectors.summarizingDouble(Employee2::getSalary));long count = collect9.getCount();double average = collect9.getAverage();double max = collect9.getMax();double min = collect9.getMin();double sum = collect9.getSum();System.out.println("count:"+count);System.out.println("average:"+average);System.out.println("max:"+max);System.out.println("min:"+min);System.out.println("sum:"+sum);
//=========================================================
//分组@Testpublic void testCollect3() {Map<Status, List<Employee2>> collect = emps.stream().collect(Collectors.groupingBy((e)->e.getStatus()));System.out.println(collect);Map<Status, List<Employee2>> collect2 = emps.stream().collect(Collectors.groupingBy(Employee2::getStatus));System.out.println(collect2);}
//=====多级==================================================
//多级分组@Testpublic void testCollect4() {Map<Status, Map<String, List<Employee2>>> collect = emps.stream().collect(Collectors.groupingBy(Employee2::getStatus, Collectors.groupingBy((e)->{if(e.getAge() >= 60)return "老年";else if(e.getAge() >= 35)return "中年";elsereturn "成年";})));System.out.println(collect);}
//===================================================
//多级分组@Testpublic void testCollect4() {Map<Status, Map<String, List<Employee2>>> collect = emps.stream().collect(Collectors.groupingBy(Employee2::getStatus, Collectors.groupingBy((e)->{if(e.getAge() >= 60)return "老年";else if(e.getAge() >= 35)return "中年";elsereturn "成年";})));System.out.println(collect);}
//==========================================================
//多级分组@Testpublic void testCollect4() {Map<Status, Map<String, List<Employee2>>> collect = emps.stream().collect(Collectors.groupingBy(Employee2::getStatus, Collectors.groupingBy((e)->{if(e.getAge() >= 60)return "老年";else if(e.getAge() >= 35)return "中年";elsereturn "成年";})));System.out.println(collect);}
//======================================================
//组接字符串@Testpublic void testCollect6() {String collect = emps.stream().map((e)->e.getName()).collect(Collectors.joining());System.out.println(collect);String collect3 = emps.stream().map(Employee2::getName).collect(Collectors.joining(","));System.out.println(collect3);String collect2 = emps.stream().map(Employee2::getName).collect(Collectors.joining(",", "prefix", "subfix"));System.out.println(collect2);}@Testpublic void testCollect7() {Optional<Double> collect = emps.stream().map(Employee2::getSalary).collect(Collectors.reducing(Double::sum));System.out.println(collect.get());}
//==========================================================

总测试代码

    /*** collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法*/@Testpublic void testCollect() {List<String> collect = emps.stream().map(Employee2::getName).collect(Collectors.toList());collect.forEach(System.out::println);Set<String> collect2 = emps.stream().map(Employee2::getName).collect(Collectors.toSet());collect2.forEach(System.out::println);HashSet<String> collect3 = emps.stream().map(Employee2::getName).collect(Collectors.toCollection(HashSet::new));collect3.forEach(System.out::println);}@Testpublic void testCollect2() {Optional<Double> collect = emps.stream().map(Employee2::getSalary).collect(Collectors.maxBy(Double::compare));System.out.println(collect.get());Optional<Employee2> collect2 = emps.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));System.out.println(collect2.get());Optional<Double> collect4 = emps.stream().map(Employee2::getSalary).collect(Collectors.minBy(Double::compare));System.out.println(collect4);Optional<Employee2> collect3 = emps.stream().collect(Collectors.minBy((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary())));System.out.println(collect3.get());System.out.println("=========================================");Double collect5 = emps.stream().collect(Collectors.summingDouble(Employee2::getSalary));System.out.println(collect5);Double collect6 = emps.stream().collect(Collectors.averagingDouble((e)->e.getSalary()));Double collect7 = emps.stream().collect(Collectors.averagingDouble(Employee2::getSalary));System.out.println("collect6："+collect6);System.out.println("collect7："+collect7);//总数Long collect8 = emps.stream().collect(Collectors.counting());System.out.println(collect8);DoubleSummaryStatistics collect9 = emps.stream().collect(Collectors.summarizingDouble(Employee2::getSalary));long count = collect9.getCount();double average = collect9.getAverage();double max = collect9.getMax();double min = collect9.getMin();double sum = collect9.getSum();System.out.println("count:"+count);System.out.println("average:"+average);System.out.println("max:"+max);System.out.println("min:"+min);System.out.println("sum:"+sum);}//分组@Testpublic void testCollect3() {Map<Status, List<Employee2>> collect = emps.stream().collect(Collectors.groupingBy((e)->e.getStatus()));System.out.println(collect);Map<Status, List<Employee2>> collect2 = emps.stream().collect(Collectors.groupingBy(Employee2::getStatus));System.out.println(collect2);}//多级分组@Testpublic void testCollect4() {Map<Status, Map<String, List<Employee2>>> collect = emps.stream().collect(Collectors.groupingBy(Employee2::getStatus, Collectors.groupingBy((e)->{if(e.getAge() >= 60)return "老年";else if(e.getAge() >= 35)return "中年";elsereturn "成年";})));System.out.println(collect);}//分区@Testpublic void testCollect5() {Map<Boolean, List<Employee2>> collect = emps.stream().collect(Collectors.partitioningBy((e)->e.getSalary()>5000));System.out.println(collect);}//组接字符串@Testpublic void testCollect6() {String collect = emps.stream().map((e)->e.getName()).collect(Collectors.joining());System.out.println(collect);String collect3 = emps.stream().map(Employee2::getName).collect(Collectors.joining(","));System.out.println(collect3);String collect2 = emps.stream().map(Employee2::getName).collect(Collectors.joining(",", "prefix", "subfix"));System.out.println(collect2);}@Testpublic void testCollect7() {Optional<Double> collect = emps.stream().map(Employee2::getSalary).collect(Collectors.reducing(Double::sum));System.out.println(collect.get());}
http://www.lryc.cn/news/16802.html

相关文章：

  • MySQl高可用集群搭建（MGR + ProxySQL + Keepalived）
  • java+Selenium+TestNg搭建自动化测试架构(3)实现POM（page+Object+modal）
  • oracle11g忘记system密码，重置密码
  • 黑马 Vue 快速入门 笔记
  • HTTP协议知识体系核心重点梳理
  • Nginx优化与防盗链
  • 自动驾驶路径规划概况
  • 某某银行行面试题目汇总--HashMap为什么要扩容
  • 求职者：“我有五年测试经验”面试官： “不，你只是把一年的工作经验用了五年”
  • Nacos配置中心
  • 【故障】6、yum不可用
  • 深度解读 ｜ 数据资产管理面临诸多挑战，做好这5个措施是关键
  • 双检测人脸防伪识别方法(活体检测+人脸识别+关键点检测+人像分割)
  • 2023年3月 - 笔记
  • 浅谈Redisson实现分布式锁对原理
  • struts1.2升级struts2.5.30问题汇总
  • 电动汽车充放电的优化调度（Matlab代码实现）
  • 《JeecgBoot系列》 如何设计表单实现“下拉组件二级联动“ ? 以省市二级联动为例
  • 数学小课堂：数学的线索（从猜想到定理再到应用的整个过程）
  • Collecting package metadata (current_repodata.json): failed
  • 几十亿工单表，查询优化案例
  • LabVIEW应用程序（EXE）无法正确动态调用插件
  • 到了35岁，软件测试职业发展之困惑如何解？
  • Google Guice 3：Bindings（1）
  • 学习国家颁布的三部信息安全领域法律，理解当前工作中的信息安全合规要求
  • LeetCode_Python_二分查找算法
  • 功能测试三年，是时候做出改变了
  • 图扑孪生工厂流水线组态图可视化
  • 车机开发—【CarService启动流程】
  • webpack中require.context的运用