Java基础-Stream流

已于 2022-07-28 00:16:43 修改
阅读量643 收藏 10
点赞数
分类专栏： Java知识点集合【全】 文章标签： java Stream流
于 2022-07-26 01:13:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43474701/article/details/125985912
版权

Stream流


下一篇文章 Java基础-File类

1、Stream流初体验

  • 体验Stream流
  • 创建一个集合，存储多个字符串元素
  • “张三丰”,“张无忌”,“张翠山”,“王二麻子”,“张良”,“谢广坤”
  • 把集合中所有以"张"开头的元素存储到一个新的集合
  • 把"张"开头的集合中的长度为3的元素存储到一个新的集合
  • 遍历上一步得到的集合
public class MyStream1 {
    public static void main(String[] args) {
        //集合的批量添加
        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
        //list.add()

        //遍历list1把以张开头的元素添加到list2中。
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if(s.startsWith("张")){
                list2.add(s);
            }
        }

        //遍历list2集合，把其中长度为3的元素，再添加到list3中。
        ArrayList<String> list3 = new ArrayList<>();
        for (String s : list2) {
            if(s.length() == 3){
                list3.add(s);
            }
        }
        for (String s : list3) {
            System.out.println(s);
        }
        System.out.println("=======================");
       //Stream流
        list1.stream().filter(s->s.startsWith("张"))
                .filter(s->s.length() == 3)
                .forEach(s-> System.out.println(s));
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2、Stream流获取方法

在这里插入图片描述

Stream流的获取 单列集合 : 集合对象.stream(); 双列集合 : 不能直接获取,需要间接获取
集合对象.keySet().stream();
集合对象.entrySet().stream(); 数组 :
Arrays.stream(数组名);

同种数据类型的多个数据:

        Stream.of(数据1,数据2,数据3......);

public class MyStream2 {
    public static void main(String[] args) {
        //单列集合
        //method1();//ctrl+alt+m抽取方法快捷键

        //双列集合
        //method2();

        //数组
        //method3();

        //同种数据类型的多个数据
        //method4();

    }

    private static void method4() {
        Stream.of(1,2,3,4,5,6,7,8).forEach(s-> System.out.println(s));
    }

    private static void method3() {
        int [] arr = {1,2,3,4,5};
        Arrays.stream(arr).forEach(s-> System.out.println(s));
    }

    private static void method2() {
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);

        //双列集合不能直接获取Stream流
        //keySet
        //先获取到所有的键
        //再把这个Set集合中所有的键放到Stream流中
        //hm.keySet().stream().forEach(s-> System.out.println(s));
        
        //entrySet
        //先获取到所有的键值对对象
        //再把这个Set集合中所有的键值对对象放到Stream流中
        hm.entrySet().stream().forEach(s-> System.out.println(s));
    }

    private static void method1() {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

//        Stream<String> stream = list.stream();
//        stream.forEach(s-> System.out.println(s));
        list.stream().forEach(s-> System.out.println(s));
    }
}

3、Stream流的常见的中间方法

在这里插入图片描述

public class MyStream3 {
    public static void main(String[] args) {
//        Stream<T> filter​(Predicate predicate)：过滤
//                Predicate接口中的方法	boolean test​(T t)：对给定的参数进行判断，返回一个布尔值

        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //filter方法获取流中的 每一个数据.
        //而test方法中的s,就依次表示流中的每一个数据.
        //我们只要在test方法中对s进行判断就可以了.
        //如果判断的结果为true,则当前的数据留下
        //如果判断的结果为false,则当前数据就不要.
//        list.stream().filter(
//                new Predicate<String>() {
//                    @Override
//                    public boolean test(String s) {
//                        boolean result = s.startsWith("张");
//                        return result;
//                    }
//                }
//        ).forEach(s-> System.out.println(s));


        //因为Predicate接口中只有一个抽象方法test
        //所以我们可以使用lambda表达式来简化
//        list.stream().filter(
//                (String s)->{
//                    boolean result = s.startsWith("张");
//                        return result;
//                }
//        ).forEach(s-> System.out.println(s));

        list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
    }
}

其他的中间操作方法
在这里插入图片描述

public class MyStream4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");
        
        //method1(list);
        //method2(list);
        //method3();
        //method4(list);

    }

    private static void method4(ArrayList<String> list) {
        //        Stream<T> distinct​()：去除流中重复的元素。依赖(hashCode和equals方法)
        list.stream().distinct().forEach(s-> System.out.println(s));
    }

    private static void method3() {
        //static <T> Stream<T> concat​(Stream a, Stream b)：合并a和b两个流为一个流
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("张三丰");
        list2.add("张无忌");
        list2.add("张翠山");
        list2.add("王二麻子");
        list2.add("张良");
        list2.add("谢广坤");

//        Stream<String> stream1 = list.stream();
//        Stream<String> stream2 = list2.stream();
//
//        Stream<String> stream3 = Stream.concat(stream1, stream2);
//        stream3.forEach(s-> System.out.println(s));

        Stream.concat(list.stream(),list2.stream()).forEach(s-> System.out.println(s));//合并输出
    }

    private static void method2(ArrayList<String> list) {
        //        Stream<T> skip​(long n)：跳过指定参数个数的数据
        list.stream().skip(2).forEach(s-> System.out.println(s));//跳过前面两个
    }

    private static void method1(ArrayList<String> list) {
        //        Stream<T> limit​(long maxSize)：截取指定参数个数的数据
        list.stream().limit(2).forEach(s-> System.out.println(s));//保留前面两个
    }
}

4、Stream流终结方法

在这里插入图片描述

/**
 * Stream流的终结方法
 */
public class MyStream5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //method1(list);


//        long count​()：返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
        
    }

    private static void method1(ArrayList<String> list) {
        //        void forEach​(Consumer action)：对此流的每个元素执行操作
//                      Consumer接口中的方法	void accept​(T t)：对给定的参数执行此操作
        //在forEach方法的底层,会循环获取到流中的每一个数据.
        //并循环调用accept方法,并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据.
        //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
//forEach方法的形参是一个接口，那么传递给它的一定是接口的实现类对象，在这
//里先写一个匿名内部类，这个匿名内部类就是接口的实现类对象

        System.out.println("====================");
	
        //lambda表达式的简化格式   (与形参保持一致数据类型与流中保持一致)->{}
        //是因为Consumer接口中,只有一个accept方法
        list.stream().forEach(
                (String s)->{
                    System.out.println(s);
                }
        );
        System.out.println("====================");

        //lambda表达式还是可以进一步简化的.
        //	形参只有一个类型可以简化小括号可以简化
        list.stream().forEach(s->System.out.println(s));
    }
}

5、在Stream流中无法直接修改集合,数组等数据源中的数据

在这里插入图片描述

/**
 * Stream流的收集方法
 * 练习:
 * 定义一个集合，并添加一些整数1,2,3,4,5,6,7,8,9,10
 * 将集合中的奇数删除，只保留偶数。
 * 遍历集合得到2，4，6，8，10。
 */
public class MyStream6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        //List.of批量添加太麻烦用遍历
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }

//        list.stream().filter(
//                (Integer i)->{
//                    return i % 2 == 0;
//                }
//        )
        list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));
        System.out.println("====================");

        for (Integer integer : list) {
            System.out.println(integer);
        }


    }
}

在这里插入图片描述

6、Stream流的收集操作

在这里插入图片描述

/**
 * Stream流的收集方法
 * 练习:
 * 定义一个集合，并添加一些整数1,2,3,4,5,6,7,8,9,10
 * 将集合中的奇数删除，只保留偶数。
 * 遍历集合得到2，4，6，8，10。
 */
public class MyStream7 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list1.add(i);
        }

        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);

        //filter负责过滤数据的.
        //collect负责收集数据.
        //获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.
        //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
        List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());

        System.out.println(list);


        Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println(set);
    }
}

7、Stream流的练习

在这里插入图片描述

/**
 * 现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
 * 1.男演员只要名字为3个字的前两人
 * 2.女演员只要姓杨的，并且不要第一个
 * 3.把过滤后的男演员姓名和女演员姓名合并到一起
 * 4.把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
 * 演员类Actor，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
 */
public class MyStream9 {
    public static void main(String[] args) {
        ArrayList<String>  manList = new ArrayList<>();
        manList.add("张国立");
        manList.add("张晋");
        manList.add("刘烨");
        manList.add("郑伊健");
        manList.add("徐峥");
        manList.add("王宝强");

        ArrayList<String>  womanList = new ArrayList<>();
        womanList.add("郑爽");
        womanList.add("杨紫");
        womanList.add("关晓彤");
        womanList.add("张天爱");
        womanList.add("杨幂");
        womanList.add("赵丽颖");

        //男演员只要名字为3个字的前两人
        Stream<String> stream1 = manList.stream().filter(name -> name.length() == 3).limit(2);

        //女演员只要姓杨的，并且不要第一个
        Stream<String> stream2 = womanList.stream().filter(name -> name.startsWith("杨")).skip(1);

        Stream.concat(stream1,stream2).forEach(name -> {
            Actor actor = new Actor(name);
            System.out.println(actor);
        });
    }
}

结束语 🥇🥇🥇

发现非常好用的一个刷题网站!大家一起努力！加油！！！
题目难度可以自行选择
在线编程出答案，（也可自行查看答案）非常方便
程序员刷题神器网站点击链接注册即可刷题

编程ID
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java基础之Stream流
何小白的博客
06-13 388
Stream流的基本使用
Java中的 Stream 流01
2301_78886030的博客
06-25 180
Stream流是用于操作数据源如集合、数组等所生成的元素序列；集合是用于存储数据，而流是用于对集合内的数据进行计算。Stream不是数据结构，不会保存数据。Stream不会修改原来的数据源，它会将操作后的数据保存到另外一个新的对象中。Stream是惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。Stream可以帮助我们更加聚焦于我们要做的事，而不需要去关注具体做的过程，简化代码，提高开发效率。Class
Java基础-Stream流_entryset(1)
2401_84411072的博客
04-29 337
Stream流的获取 单列集合 : 集合对象.stream();双列集合 : 不能直接获取,需要间接获取集合对象.keySet().stream();集合对象.entrySet().stream();数组 :Arrays.stream(数组名);
2024年最全Java基础-Stream流_entryset(2)，2024年最新2024前端最新大厂面试真题总结
最新发布
2401_84619986的博客
05-14 705
还有很多的同学在学习的过程中一味的追求学的速度，很快速的刷视频，写了后面忘了前面，最后什么都没有学到，什么都知道，但是什么都不懂，要具体说，也说不出个所以然。很多自学的朋友往往都是自己去找资料学习的，资料上有的或许就学到了，资料上没有的或许就没有学到。最重要的是，在学习的过程中，不知道每个部分该学哪些知识点，学到什么程度才算好，学了能做什么。//forEach方法的形参是一个接口，那么传递给它的一定是接口的实现类对象，在这。因为自学走的弯路是比较的多的，会踩很多的坑，学习的过程中是比较的迷茫的。
java的Stream流
JJpZh的博客
06-20 165
案例需求按照下面的要求完成集合的创建和遍历原始方式示例代码 使用Stream流示例代码 Stream流的好处Stream流的思想Stream流的三类方法生成Stream流的方式Collection体系集合使用默认方法stream()生成流， default Stream stream()Map体系集合把Map转成Set集合，间接的生成流数组通过Arrays中的静态方法stream生成流同种数据类型的多个数据通过Stream接口的静态方法of(T… values)生成流代码演示 1.3Stream
初试stream，entry
liangcon的博客
12-09 150
实习笔记，初次使用stream() 遍历List，以及初次使用Map.Entry
java Stream流语法（笔记）
weixin_49240231的博客
07-28 258
关于通过stream流处理数据的方式
Java中的Stream流
yhb500234的博客
09-03 288
本文主要概述了Java中Stream流的相关知识,包括Stream的获取,操作,以及收集等. 包括一些列中间操作,将集合或者数据转换成流,完成操作后再将流转换成集合或者数组. 要知道,Java中的Stream流只是方便我们操作和处理数据,最后的数据还是要回归到集合或数组本身.
JAVA流-Stream流
Lyajpunov的博客
01-26 569
可以将流看做流水线，这个流水线是处理数据的流水线，一个产品经过流水线会有一道道的工序就如同对数据的中间操作，比如过滤我不需要的，给数据排序能，最后的终止操作就是产品从流水线下来，我们就可以统一打包放入仓库了。 当我们使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换 → 执行操作获取想要的结果。每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。 一、Stream的特性 Stream不存储数据
Java中Stream流详解
訾博（ZiBo）的博客
07-28 774
一、Stream流概述 1、两种遍历集合方式的比较 package study.stream; import java.util.ArrayList; import java.util.List; public class Test { public static void main(String[] args) { List<String> list...
Java之Stream流
每天进步一点点...
08-16 81
Stream流的获取方式 单列集合 可以使用Collection接口中默认的方法stream()生成流 default Stream stream() /** * 单列集合 */ private static void method1() { ArrayList<String> list = new ArrayList(); list.add("aaa"); list.add("bbb"); list
my_stream:My Stream 是一个应用程序，用于存储所有租赁服务上可用的电影的综合观看列表。 它还允许您跟踪您看过的电影
05-29
我的直播 My Stream 是一个应用程序，用于存储所有租赁服务上可用的电影的综合观看列表。 它还允许您跟踪您看过的电影。 GitHub 链接： : 部署的应用程序： : 目录 安装 我的 用法 用户必须注册一个帐户才能使用此服务。 登录后，将加载一个搜索表单，供用户搜索他们想要的电影。 搜索后，在加载时单击电影海报以显示详细信息和添加到列表的选项。 执照 这个项目是在 MIT 许可下获得许可的。 贡献 不 测试 目前没有对该项目进行测试。 截图 问题 如果您有任何问题，可以在http://github.com/MeganGerwick下的 Github 上找到我。
Java中Map的 entrySet() 详解
weixin_44594257的博客
03-30 5012
1、 由于Map中存放的元素均为键值对，故每一个键值对必然存在一个映射关系。 Map中采用Entry内部类来表示一个映射项，映射项包含Key和Value Map.Entry里面包含getKey()和getValue()方法 2、 ...
Java中Map的 entrySet() 详解以及用法(四种遍历map的方式)
大啵鱼
03-13 3307
Entry 由于Map中存放的元素均为键值对，故每一个键值对必然存在一个映射关系。 Map中采用Entry内部类来表示一个映射项，映射项包含Key和Value (我们总说键值对键值对, 每一个键值对也就是一个Entry) Map.Entry里面包含getKey()和getValue()方法 Iterator&lt;Map.Entry&lt;Integer, Integer&gt;&gt;...
java 迭代器 entryset,流VS。 Map的entrySet中的迭代器-Java 8
weixin_34377697的博客
02-13 333
To my understanding, the following code should have print true, since both Stream and Iterator are pointing to the first element.However, when I ran the following code it is printing false:final HashM...
java基础教程——Stream流
weixin_51351637的博客
03-06 552
Collectors是一个工具类，实现各种有用的还原操作的Collector，例如将元素累积到集合中，根据各种标准汇总元素等。一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用。Predicate接口中的方法 boolean test(T t) : 对给定的参数进行判断，返回一个布尔值。Consumer接口中的方法 void accept(T t)： 对给定的参数执行此操作。super T,A,R>是一个接口。
java基础之Stream
weixin_50020236的博客
04-07 448
1.Stream和集合的区别 Stream关注的是对数据的运算，与CPU打交道； 集合关注的是数据的存储，与内存打交道 2.什么是Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！” 注意 ①Stream 自己不会存储元素。 ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。 ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行 3.Stream 的操作三个步...
Java的Stream流详细讲解
qq_45443475的博客
06-28 9518
Java的Stream流详细讲解
Stream:对集合进行操作
VevaLiu的博客
12-01 729
Collection 有stream()方法 Array Arrays.stream(...) Map Map.entrySet().stream() Stream中的方法 方法 说明 Stream<T> filter(Predicate<? super T> predicate); 数据过滤，保留满足条件的 <R> Stream<R> map(Function<? super T, ? extends
java8的stream流操作的数据结构
不说话装高手
10-06 1176
在java8的流操作中分为终止符和非终止符。 非终止符不会触发数据的处理。 每次通过stream()方法新建立一个流的时候都会创建一个Head类。这个类是ReferencePipeline的一个内部类，同时也继承了ReferencePipeline，代表当前流的一个初始状态。之后每进行一次中间操作，都会根据操作的类型生成一个StatelessOp或者StatefulOp代表有无状态的中间操作，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程ID

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值