Stream流的基本使用

最新推荐文章于 2023-07-07 10:07:18 发布
最新推荐文章于 2023-07-07 10:07:18 发布
阅读量383 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seelune_/article/details/130187448
版权

开篇

最近开始写一些项目才发现Java8的新特性有一些特别重要的结果自己还没有真正学习过，比如现在在项目中经常用到的Stream流，用于简化代码可以说事半功倍，今天抽了段时间专门来消化这些知识，并通过一个应用来巩固复习一下。

Stream流的使用步骤

  • 获取Stream流对象
  • 使用中间方法处理数据
  • 使用终结方法处理数据
    下面我们一步步来看：

一、获取Stream流对象

  1. 单列集合 default Stream stream() Collections中的默认方法
//获取Stream流，也就是把list中的数据放到stream流中
        Stream<String> stream = list.stream();
  1. 双列集合无法直接使用Stream流，需要先通过keySet()或entrySet()转为单列集合
//法1
       hashMap.entrySet().stream().forEach(s -> System.out.println(s));    
//法2
       hashMap.keySet().stream().forEach(s -> System.out.println(s));
  1. 数组 public static Stream stream(T[] array) Arrays工具类中的静态方法
        String[] a = {"sda","sda","a"};
        Arrays.stream(a).forEach(s-> System.out.println(s));
  1. 一堆零散数据 public static Stream of(T… values) Stream接口中的静态方法
      Stream.of(1,2,3,4,"5").forEach(s-> System.out.println(s));

二、中间方法处理数据

首先我们需要知道一些常用的中间方法，如下：

  /*
        常见中间方法：
        filter 数据过滤
        limit 获取前面几个元素
        skip 跳过前几个元素
        distinct 元素去重（依赖hashcode和equals方法）,所以对象记得重写这两个方法
        concat 合并a和b的两个流和为一个
        map 转换流中的数据类型

        注意：
        注意1：中间方法，返回新的Stream流，原来的Stream只能使用1次，所以建议使用链式编程
        注意2：终结方法，返回新的数据，对原来的数据不造成影响
         */

通过代码举例使用：

ArrayList<String> list = new ArrayList<>();
        list.add("cc");
        list.add("cas");
        list.add("caw");
        list.add("44");
        list.add("66");
        list.add("dds");
        //filter
        list.stream().filter(s -> s.startsWith("c")).forEach(s -> System.out.print(s+" "));
        System.out.println();
        System.out.println("=============");
        //skip
        list.stream().skip(2).forEach(s-> System.out.print(s+" "));
        System.out.println();
        System.out.println("=============");

        //取过滤后的跳过2个元素的后面的元素
        list.stream().filter(s -> s.startsWith("c")).skip(2).forEach(s -> System.out.println(s));//caw
        list.add("cc");
        System.out.println();
        System.out.println("=============");

        //distinct
        list.stream().distinct().forEach(s-> System.out.print(s+" "));//ccc as caw 44 66 dds
        System.out.println();
        System.out.println("=============");

        //limit
        list.stream().filter(s -> s.startsWith("c")).limit(2).forEach(s -> System.out.print(s + " "));
        System.out.println();
        System.out.println("=============");

        //concat
        ArrayList<String> strings = new ArrayList<>();
        strings.add("yjh");
        strings.add("wu");
        Stream.concat(list.stream(),strings.stream()).forEach(s -> System.out.print(s+" "));//cc cas caw 44 66 dds cc yjh wu
        System.out.println(" ============= ");
        //map
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("dasd","22");
        hashMap.put("das3d","3");
        hashMap.put("d2asd","33");
        hashMap.put("1dasd","2222");
        //要求将hsahMap中的value值转换成int类型
        //s 就为 dasd=22  ...
        hashMap.entrySet().stream().map(s->Integer.parseInt(s.getValue())).forEach(s-> System.out.print(s+" "));//22 3 33 2222


    }

三、终结方法处理数据

终结方法如下：

在这里插入代码片 /**
         * 终结方法：
         * foreach  遍历
         * count    统计
         * toArray 转数组
         * collect(Collertor collector)   收集流中的数据到（List Set Map）
         */

对于前三种简单的，我们同样使用代码举例使用：

 ArrayList<String> list = new ArrayList<>();
        list.add("cc");
        list.add("cas");
        list.add("caw");
        list.add("44");
        list.add("66");
        list.add("dds");
        list.stream().forEach(s -> System.out.println(s));
        long count = list.stream().count();
        System.out.println(count);
        //Arrays
        //toArray方法参数作用，负责创建一个指定类型的底层
        //toArray方法底层，会依次得到流里面的每一个数据，并把数据放到数组中
        //toArray的返回值：是一个装着流里面的所有数据的数组
        String[] array = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.print(Arrays.toString(array)+" ");//[cc, cas, caw, 44, 66, dds]
        String[] strings = list.stream().toArray(value -> new String[value]);
        System.out.print(Arrays.toString(strings)+" ");//[cc, cas, caw, 44, 66, dds]

    }

第四种，收集流中的数据到（List Set Map等等）
较于前三种比较复杂一些，主要体现在转map的过程中，如下：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("cc-1");
        list.add("cas-1");
        list.add("caw-2");
        list.add("44-3");
        list.add("66-1");
        list.add("dds-2");
        //收集-后为1的数据
        // 到List集合中
        List<String> collect = list.stream().filter(s -> "1".equals(s.split("-")[1]))
                .collect(Collectors.toList());
        //到set集合中
        Set<String> collect1 = list.stream().filter(s -> "1".equals(s.split("-")[1]))
                .collect(Collectors.toSet());
        //收集到List和Set的区别就是集合的区别，一个可以重复一个不可以重复嘛
        //到Map集合中，注意：收集到map集合中不能存在重复数据，否则会报错
        /**
         *  toMap:参数一表示键的生成规则
         *        参数二表示值的生成规则
         *  参数一:
         *        Function泛型一：表示流中每个数据的类型
         *                泛型二：表示Map集合中每个键的类型
         *  参数二:
         *        Function泛型一：表示流中每个数据的类型
         *                泛型二：表示Map集合中每个值的类型
         *        方法apply形参：依次表示流里面的每一个数据
         *                 方法体：生成值的代码
         *                 返回值：已经生成的值
         */
        //匿名内部类写法
        Map<String, String> map = list.stream().filter(s -> "1".equals(s.split("-")[1]))
                .collect(Collectors.toMap(new Function<String, String>() {
                                              @Override
                                              public String apply(String s) {
                                                  return s.split("-")[0];
                                              }
                                          },
                        new Function<String, String>() {
                            @Override
                            public String apply(String s) {
                                return s.split("-")[1];
                            }
                        }));
        System.out.println(map);//{66=1, cc=1, cas=1}
        //lambda写法
        Map<String, String> map1 = list.stream().filter(s -> "1".equals(s.split("-")[1]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0],
                        s -> s.split("-")[1]
                ));
        System.out.println(map1);//{66=1, cc=1, cas=1}

四、综合应用

在这里插入图片描述

ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("啊啊,23");
        arrayList.add("呜呜呜呜,24");
        arrayList.add("阿萨德,25");
        arrayList.add("嗷嗷,25");
        arrayList.add("急急急,25");
        arrayList.add("阿闪大,25");
        //1.男的只要3个字的前两个人
        List<String> boyList = arrayList.stream()
                .filter(x -> x.split(",")[0].length() == 3)
                .limit(2)
                .collect(Collectors.toList());
        System.out.println(boyList);//[阿萨德,25, 急急急,25]

        ArrayList<String> arrayList1 = new ArrayList<>();
        arrayList1.add("杨孩子1,23");
        arrayList1.add("杨孩子2,24");
        arrayList1.add("女孩子,25");
        arrayList1.add("女孩子2,25");
        arrayList1.add("女孩子3,25");
        arrayList1.add("女孩1子,25");
        //2.女孩只要只要姓杨的且不要第一个
        List<String> girlList = arrayList1.stream()
                .filter(x -> x.startsWith("杨"))
                .skip(1)
                .collect(Collectors.toList());
        System.out.println(girlList);//[杨孩子2,24]

        //3.把过滤后的男的和女的拼成一个list
        List<String> boyAndGirlList = Stream.concat(boyList.stream(), girlList.stream())
                .collect(Collectors.toList());
        System.out.println(boyAndGirlList);//[阿萨德,25, 急急急,25, 杨孩子2,24]

        //4.上一步的信息封装成Actor对象并存入一个list中
        ArrayList<Actor> actors = new ArrayList<>();
        for (String ac : boyAndGirlList) {
            String[] split = ac.split(",");
            Actor actor = new Actor();
            actor.setName(split[0]);
            actor.setAge(Integer.parseInt(split[1]));
            actors.add(actor);
        }
        System.out.println(actors);
        //[Actor{name='阿萨德', age=25}, Actor{name='急急急', age=25}, Actor{name='杨孩子2', age=24}]

        //3,4可通过map转换来合并
        List<Actor> actorList = Stream.concat(boyList.stream(), girlList.stream())
                .collect(Collectors.toList())
                .stream().map(x -> new Actor(x.split(",")[0], Integer.parseInt(x.split(",")[1])))
                .collect(Collectors.toList());
        System.out.println(actorList);
        //[Actor{name='阿萨德', age=25}, Actor{name='急急急', age=25}, Actor{name='杨孩子2', age=24}]

5、总结

Stream流结合了Lambda表达式，简化了集合、数组的操作，让很多对集合操作的长段代码大幅度缩减。虽然这不可避免地让代码的可读性变差了一些，但实用性却是毋庸置疑的。

JSharkY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Nodejs Stream 数据流使用手册
12-30
本文介绍了使用 node.js streams 开发程序的基本方法。 <code class=hljs>We should have some ways of connecting programs like garden hose--screw in another segment when it becomes necessary to massage ...
stream流的用法，超全
qq_61547726的博客
05-09 3171
循环 List 或 Map 可以使用 Java的 for 循环、增强 for 循环、迭代器和 Stream 流等方式。
stream流的介绍和使用
LC的博客
12-07 3541
#Stream 流的操作流程 Stream流的操作 常见的 Stream 中间操作： 按照条件过滤得到 ==> filter() 有返回的循环改变(可返回一部分，甚至变换类型) ==> map() 无返回的循环改变 （全部返回相同类型）==> peek（） 限制最大个数() ==> limit() 跳过几个，从最开始跳() ==> skip() 排序() ==> sorted() 不同() ==> distinct() peek 和 map 的区别： pee.
Stream流使用方法总结
python15397的博客
07-02 6600
流是一种处理数据的高级手段，任何数据都可以转化成流进行处理。对Stream流来说，比较常见数据源有集合、数组、IO等。我们可以把流想象成一条流水线，流水线的源头是数据源，数据源中的每个元素是流的操作对象。数据源中的元素被依次输送到流水线上，然后我们就可以对这些流水线上的元素进行各种操作，一旦元素走到了流水线的尽头，那么该元素也被“消费掉了”，之后在此次流水线上我们便无法再对该元素进行任何操作。平常我们是赢得for循环、增强for等一些遍历操作都是显示的操作数据源，而stream流的遍历过程对我们来说是不可见
使用 Stream API 优化你的代码
Java笔记虾
09-23 1326
Java8的新特性主要是Lambda表达式和流，当流和Lambda表达式结合起来一起使用时，因为流申明式处理数据集合的特点，可以让代码变得简洁易读 放大招，流如何简化代码 如果有一个需求，需要对数据库查询到的菜肴进行一个处理： 筛选出卡路里小于400的菜肴 对筛选出的菜肴进行一个排序 获取排序后菜肴的名字 菜肴：Dish.java publicclassD...
Stream的运用
weixin_42848855的博客
03-05 1053
java8 stream的使用
NodeJS 中Stream 的基本使用
01-01
fs 中有很基本 API 可以帮助我们读写占用内存较小的文件，如果是大文件或内存不确定也可以通过 open 、 read 、 write 、 close 等方法对文件进行操作，但是这样操作文件每一个步骤都要关心，非常繁琐， fs 中提供了...
TS流基本概念
04-21
TS流基本概念,TS 流格式分析 同步字节 传输误差指示符，传送流（Transport stream, TS)，适用于有信道噪声产生的传输， 目前TS 流广泛应用于广播电视中，如机顶盒等。
03.第三节-stream流的写法基本演示.mp4
10-25
Stream 是 Java8 中处理集合的...使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
node.js中stream流中可读流和可写流的实现与使用方法实例分析
10-15
主要介绍了node.js中stream流中可读流和可写流的实现与使用方法,结合实例形式分析了node.js stream流可读流和可写流基本分类、原理、定义、使用方法及相关注意事项,需要的朋友可以参考下
Stream流的一些基本用法
Linzc19的博客
10-20 4222
stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。同时stream不是一种，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
stream流的详细使用
hallowty的博客
06-09 262
流的终止操作：流的操作分为中间操作和终止操作。流的定义：流是一种按顺序处理数据的抽象概念，它可以从一个源生成数据，然后通过一个或多个操作对数据进行处理，最终生成结果。流的操作：流提供了一系列的操作，可以对流中的元素进行处理和转换。FlatMap：将流中的每个元素转换为一个流，然后将所有流中的元素合并为一个流。Filter：根据条件过滤流中的元素，只保留符合条件的元素。reduce：将流中的元素依次进行指定的操作，生成一个结果。Map：将流中的每个元素进行映射转换，生成一个新的元素。
Stream流的使用
qq_43621307的博客
12-23 423
Stream流的使用
详细讲解新特性Stream流的使用
m0_64416017的博客
07-01 362
从0到100玩转stream流的概念以及使用，让代码更加优雅
Stream流使用
qq_42108331的博客
05-17 205
Stream流使用
Stream流在实际项目中的相关应用
qq_50970746的博客
07-07 401
Stream流在实际项目中的相关应用，stream流按照属性进行分组。stream流把数组列表转为实体类列表。
Java8使用Stream流实现List列表的查询、统计、排序、分组
热门推荐
pan_junbiao的博客
05-05 6万+
Java8提供了Stream（流）处理集合的关键抽象概念，它可以对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。Stream API 借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。 下面是使用Stream的常用方法的综合实例。 （1）创建User.java（用户信息实体类）。 import java.math.BigDecimal; /** * ...
Stream流的简单应用
Momo_daddy的博客
09-12 664
Stream流应用的简单场景
stream流使用详解
最新发布
09-21
Stream流是一种处理数据的高级手段，可以将任何数据转化成流进行处理。常见的数据源有集合、数组、IO等。Stream流具有以下特点：...以上是Stream流的基本使用方法，更高级的用法和源码分析可以在后续的文章中进行详解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值