【JAVA入门】Day34 - Stream流

2024-09-07 08:04
文章标签 java 入门 stream day34

本文主要是介绍【JAVA入门】Day34 - Stream流，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

【JAVA入门】Day34 - Stream流

文章目录

  • 【JAVA入门】Day34 - Stream流
    • 一、Stream 流的作用和使用步骤
    • 1.Stream流的创建，数据的添加
    • 2. Stream流的中间方法
    • 3. Stream流的终结方法

        Stream 流有什么作用？我们看一个例子：

【练习】需求：按照下面的要求完成集合的创建和遍历。
①把所有以“张”开头的元素存储到新集合中。
②把“张”开头的，长度为3的元素再存储到新集合中。
③遍历打印最终结果。
        以往我们是这样写的。

package Stream;import java.util.ArrayList;public class StreamDemo {public static void main(String[] args) {/*①把所有以“张”开头的元素存储到新集合中。
②把“张”开头的，长度为3的元素再存储到新集合中。
③遍历打印最终结果。*/ArrayList<String> list1 = new ArrayList<>();list1.add("张无忌");list1.add("周芷若");list1.add("赵敏");list1.add("张强");list1.add("张三丰");//①把所有以“张”开头的元素存储到新集合中。ArrayList<String> list2 = new ArrayList<>();for (String name : list1) {if(name.startsWith("张")){list2.add(name);}}System.out.println(list2);//②把“张”开头的，长度为3的元素再存储到新集合中。ArrayList<String> list3 = new ArrayList<>();for (String name : list2) {if(name.length() == 3){list3.add(name);}}System.out.println(list3);//③遍历打印最终结果。for (String s : list3) {System.out.println(s);}}
}

        使用 Stream 流我们可以这样写。

package Stream;import java.util.ArrayList;public class StreamDemo1 {public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();list1.add("张无忌");list1.add("周芷若");list1.add("赵敏");list1.add("张强");list1.add("张三丰");list1.stream().filter(name->name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));}
}

        一行代码就完成了所有任务。可以说是大大简化了代码。

一、Stream 流的作用和使用步骤

        Stream 本身是结合了 Lambda 表达式，简化了集合、数组的各种操作。
        Stream的使用理论步骤是：
①先得到一条 Stream 流（流水线），并把数据放上去。
②利用 Stream 流中的 API 进行各种操作，包括：过滤、转换、统计、打印等等。
        Stream 流中的方法分为两种：中间方法（过滤、转换）、终结方法（统计、打印）。中间方法就是调用完毕之后还可以调用其他方法；终结方法就是流的最后一步，调用完毕之后，不能再调用其他方法。
        下面我们根据步骤分别介绍相关方法。
在这里插入图片描述

1.Stream流的创建，数据的添加

1.单列集合创建流水线：

package Stream;import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;public class StreamDemo2 {public static void main(String[] args) {//1.单列集合获取Stream流ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"a","b","c","d","e");/*//获取一条流水线，把集合中的数据放到流水线上Stream<String> stream1 = list.stream();//使用终结方法打印流水线上所有数据stream1.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});*///利用Lambda表达式简化list.stream().forEach(s -> System.out.println(s));}
}

2.双列集合间接使用流水线：

package Stream;import java.util.HashMap;public class StreamDemo3 {public static void main(String[] args) {//1.创建一个双列集合HashMap<String,Integer> hm = new HashMap<>();//2.添加数据hm.put("aaa",111);hm.put("bbb",222);hm.put("ccc",333);hm.put("ddd",444);//3.获取stream流，放入键hm.keySet().stream().forEach(s -> System.out.println(s));//4.第二种获取stream流的办法，放入键值对hm.entrySet().stream().forEach(s -> System.out.println(s));}
}

3.数组使用流水线：

package Stream;import java.util.Arrays;public class StreamDemo4 {public static void main(String[] args) {//1.创建数组int[] arr = {1,2,3,4,5,6,7,8,9,10};String[] arr2 = {"a","b","c","d","e"};//2.创建stream流Arrays.stream(arr).forEach(s -> System.out.println(s));Arrays.stream(arr2).forEach(s -> System.out.println(s));}
}

4.大量零散数据使用流水线：

package Stream;import java.util.stream.Stream;public class StreamDemo5 {public static void main(String[] args) {//public static<T> Stream<T> of(T...values)     Stream接口中的静态方法Stream.of(1,2,3,4,5).forEach(s -> System.out.println(s));Stream.of("a","b","c","d","e").forEach(s -> System.out.println(s));}
}

要注意：

//数组可以作为Stream.of()的参数，但必须是引用类型的，如果传递基本数据类型的数组，会把整个数组当成一个元素放入Stream
Stream.of(arr2).forEach(s -> System.out.println(s));

2. Stream流的中间方法

        Stream 流的中间方法如下。
在这里插入图片描述
        其中要注意 distinct() 方法去重，依赖于那两个常用方法，如果要去重的是自定义数据类型，务必重写这两个方法。
        还要注意：中间方法会返回新的 Stream 流，而原来的 Stream 流只能用一次（调一次方法就关闭了），所以建议使用链式编程节省代码量。
        还要注意：修改 Stream 流中的数据是不会影响原来集合或者数组中的数据的。
        部分方法使用例代码如下。

package Stream;import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;public class StreamDemo6 {public static void main(String[] args) {/*filter  过滤limit   获取前几个元素skip    跳过前几个元素*/ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"张无忌","周芷若","赵敏","张三丰","张翠山","张良","王二麻子","谢广坤");//filter 过滤 把“张”开头的留下，其他不要/*list.stream().filter(new Predicate<String>() {@Overridepublic boolean test(String s) {//如果返回值为true,表示当前数据留下//如果返回值为false,表示当前数据舍弃不要return s.startsWith("张");}}).forEach(s -> System.out.println(s));*/list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));//原集合没有发生变化System.out.println(list);   //[张无忌, 周芷若, 赵敏, 张三丰, 张翠山, 张良, 王二麻子, 谢广坤]}
}

package Stream;import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;public class StreamDemo7 {public static void main(String[] args) {/*distinct 元素去重，依赖hashCode和equals方法concat   合并a和b两个流为一个流*/ArrayList<String> list1 = new ArrayList<>();Collections.addAll(list1, "张无忌","张无忌","张无忌","张强","张三丰","张翠山","张良","王二麻子","谢广坤");ArrayList<String> list2 = new ArrayList<>();Collections.addAll(list2,"周芷若","赵敏");//元素去重list1.stream().distinct().forEach(s -> System.out.println(s));//流的合并Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));}
}

package Stream;import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;public class StreamDemo8 {public static void main(String[] args) {/*map     转换流中的数据类型*/ArrayList<String> list = new ArrayList<>();Collections.addAll(list, "张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41");//获取里面的年龄并进行打印//第一个类型：表示流中原本的数据类型//第二个类型：表示要转换之后的数据类型//apply的形参s:表示流里面的每一个数据//返回值：表示转换之后的数据类型list.stream().map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {String[] arr = s.split("-");String ageString = arr[1];                  //arr[0]是名字,arr[1]是年龄int age = Integer.parseInt(ageString);return age;}}).forEach(s -> System.out.println(s));//简写为Lambda表达式list.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s -> System.out.println(s));}
}

3. Stream流的终结方法

        Stream 的终结方法使用完毕后，Stream 流就关闭了，所以要写在最后。
在这里插入图片描述
        以下演示了如何遍历、统计一个流中的数据，并将流中的数据收集到一个数组当中，使用的方法是 toArray()，其中的代码都可以用 Lambda 表达式来改写。

package Stream;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;public class StreamDemo9 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list, "张无忌","张无忌","张无忌","张强","张三丰","张翠山","张良","王二麻子","谢广坤");//void forEach(Consumer action) 遍历//重写的方法体是对每一个数据的操作
/*list.stream().forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});
*/list.stream().forEach(s -> System.out.println(s));//long count() 统计System.out.println(list.stream().count());//toArray() 收集流中数据，放入数组中Object[] arr1 = list.stream().toArray();                //空参是转化为Object类型，放入Object数组中System.out.println(Arrays.toString(arr1));              //调用Arrays.toString方法转化为字符串打印//IntFunction的泛型是：具体类型的数组 <? extends Object[]>//apply方法的形参：流中数据的个数，要和数组长度保持一致//apply的返回值：返回具体的类型的数组//apply的方法体：创建数组，流中有多少数据，数组长度就填多少//toArray方法整体这个实现类参数的作用是：创建一个指定类型的数组//toArray方法的底层会依次得到流中每一个数据，并把数据放入数组中//toArray方法的返回值是一个装着流里所有数据的数组
/*        String[] arr = list.stream().toArray(new IntFunction<String[]>() {@Overridepublic String[] apply(int value) {return new String[value];}});
*/String[] arr2 = list.stream().toArray(value -> new String[value]);System.out.println(Arrays.toString(arr2));}
}

        以下的代码将演示如何使用 collect() 方法将流中的数据收集到各种集合（List、Set、Map）当中。

package Stream;import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;public class StreamDemo10 {public static void main(String[] args) {/*collect(Collector collector)        收集流中数据，放入集合中(List Set Map)*/ArrayList<String> list = new ArrayList<>();Collections.addAll(list, "张无忌-男-15","周芷若-女-14","赵敏-女-13","张强-男-20","张三丰-男-100","张翠山-女-40","张良-男-35","王二麻子-男-37","谢广坤-男-41");//1.收集到List集合中//需求：收集所有男性List<String> newList = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());System.out.println(newList);//2.收集到Set集合中//需求：收集所有男性//收集到Set中时，数据会自动去重，且无序Set<String> newSet = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());System.out.println(newSet);//3.收集到Map集合中//需求：收集所有男性，键：姓名，值：年龄//toMap:参数一：生成键的规则，参数二：生成值的规则，两个参数都是new Function实现类//第一个new Function<流里面每一个数据的类型,键里面数据的类型>//第二个new Function<流里面每一个数据的类型,值里面数据的类型>//apply方法形参：依次表示流中每一个数据，方法体：生成键/值，返回值：生成的键/值/*注意点：如果要把数据收集到Map当中，那么键是不能有重复的，否则代码会报错*//*Map<String, Integer> newMap = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(new Function<String, String>() {@Overridepublic String apply(String s) {//张无忌-男-15//键是名字，对应0索引return s.split("-")[0];}}, new Function<String, Integer>() {@Overridepublic Integer apply(String s) {//张无忌-男-15//值是年龄，对应2索引return Integer.parseInt(s.split("-")[2]);}}));*///改写为Lambda表达式Map<String, Integer> newMap = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(s -> s.split("-")[0], s -> Integer.parseInt(s.split("-")[2])));System.out.println(newMap);}
}

【练习1】定义一个集合，并添加一些整数1, 2, 3, 4, 5, 6, 7, 8, 9, 10。
要求过滤奇数，只留下偶数，并保存结果。

package Stream;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;public class StreamDemo11 {public static void main(String[] args) {/*定义一个集合，并添加一些整数1, 2, 3, 4, 5, 6, 7, 8, 9, 10。要求过滤奇数，只留下偶数，并保存结果。*/ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,1, 2, 3, 4, 5, 6, 7, 8, 9, 10);//过滤奇数，只留下偶数List<Integer> newList = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());System.out.println(newList);}
}

【练习2】创建一个 ArrayList 集合，并添加以下字符串，字符串前面是姓名，后面是年龄：
“zhangsan，23” “lisi，24” “wangwu，25”，保留年龄大于等于24岁的人，并把结果放入 Map 中，姓名为键，年龄为值。

package Stream;import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;public class StreamDemo12 {public static void main(String[] args) {/*创建一个 ArrayList 集合，并添加以下字符串，字符串前面是姓名，后面是年龄："zhangsan，23" "lisi，24" "wangwu，25"，保留年龄大于等于24岁的人，并把结果放入 Map 中，姓名为键，年龄为值。*/ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"zhangsan，23" ,"lisi，24" ,"wangwu，25");//1.建立流过滤器Map<String, Integer> map = list.stream().filter(s -> Integer.parseInt(s.split("，")[1]) >= 24).collect(Collectors.toMap(s -> s.split("，")[0], s -> Integer.parseInt(s.split("，")[1])));//2.打印System.out.println(map);}}

【练习3】如下。
在这里插入图片描述

这篇关于【JAVA入门】Day34 - Stream流的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1144517。

相关文章

如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解

如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解

《如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解》：本文主要介绍如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别的相关资料,描述了如何使用海康威视设备网络SD... 目录前言开发流程问题和解决方案dll库加载不到的问题老旧版本sdk不兼容的问题关键实现流程总结前言作为
阅读更多...
SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

《SpringBoot中使用ThreadLocal进行多线程上下文管理及注意事项小结》本文详细介绍了ThreadLocal的原理、使用场景和示例代码,并在SpringBoot中使用ThreadLo... 目录前言技术积累1.什么是 ThreadLocal2. ThreadLocal 的原理2.1 线程隔离2
阅读更多...
springboot将lib和jar分离的操作方法

springboot将lib和jar分离的操作方法

《springboot将lib和jar分离的操作方法》本文介绍了如何通过优化pom.xml配置来减小SpringBoot项目的jar包大小,主要通过使用spring-boot-maven-plugin... 遇到一个问题，就是每次maven package或者maven install后target中的ja
阅读更多...
Java中八大包装类举例详解(通俗易懂)

Java中八大包装类举例详解(通俗易懂)

《Java中八大包装类举例详解(通俗易懂)》：本文主要介绍Java中的包装类,包括它们的作用、特点、用途以及如何进行装箱和拆箱,包装类还提供了许多实用方法,如转换、获取基本类型值、比较和类型检测,... 目录一、包装类（Wrapper Class）1、简要介绍2、包装类特点3、包装类用途二、装箱和拆箱1、装
阅读更多...
如何利用Java获取当天的开始和结束时间

如何利用Java获取当天的开始和结束时间

《如何利用Java获取当天的开始和结束时间》：本文主要介绍如何使用Java8的LocalDate和LocalDateTime类获取指定日期的开始和结束时间,展示了如何通过这些类进行日期和时间的处... 目录前言1. Java日期时间API概述2. 获取当天的开始和结束时间代码解析运行结果3. 总结前言在J
阅读更多...
Java深度学习库DJL实现Python的NumPy方式

Java深度学习库DJL实现Python的NumPy方式

《Java深度学习库DJL实现Python的NumPy方式》本文介绍了DJL库的背景和基本功能,包括NDArray的创建、数学运算、数据获取和设置等,同时,还展示了如何使用NDArray进行数据预处理... 目录1 NDArray 的背景介绍1.1 架构2 JavaDJL使用2.1 安装DJL2.2 基本操
阅读更多...
最长公共子序列问题的深度分析与Java实现方式

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列（LCS）问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动
阅读更多...
Java多线程父线程向子线程传值问题及解决

Java多线程父线程向子线程传值问题及解决

《Java多线程父线程向子线程传值问题及解决》文章总结了5种解决父子之间数据传递困扰的解决方案,包括ThreadLocal+TaskDecorator、UserUtils、CustomTaskDeco... 目录1 背景2 ThreadLocal+TaskDecorator3 RequestContextH
阅读更多...
关于Spring @Bean 相同加载顺序不同结果不同的问题记录

关于Spring @Bean 相同加载顺序不同结果不同的问题记录

《关于Spring@Bean相同加载顺序不同结果不同的问题记录》本文主要探讨了在Spring5.1.3.RELEASE版本下,当有两个全注解类定义相同类型的Bean时,由于加载顺序不同,最终生成的... 目录问题说明测试输出1测试输出2@Bean注解的BeanDefiChina编程nition加入时机总结问题说明
阅读更多...
java父子线程之间实现共享传递数据

java父子线程之间实现共享传递数据

《java父子线程之间实现共享传递数据》本文介绍了Java中父子线程间共享传递数据的几种方法,包括ThreadLocal变量、并发集合和内存队列或消息队列,并提醒注意并发安全问题... 目录通过 ThreadLocal 变量共享数据通过并发集合共享数据通过内存队列或消息队列共享数据注意并发安全问题总结在 J
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2