Stream流的基本使用

最新推荐文章于 2024-10-07 17:57:48 发布
最新推荐文章于 2024-10-07 17:57:48 发布
阅读量472 收藏
点赞数
分类专栏： 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表达式，简化了集合、数组的操作，让很多对集合操作的长段代码大幅度缩减。虽然这不可避免地让代码的可读性变差了一些，但实用性却是毋庸置疑的。

Stream流简单使用
QQQQQQQQYY的博客
03-27 861
Stream流作为1.8新特性，在敲代码时带来了全新的体验和更实际运用的场景 一、特点： 1.只能遍历一次： 从数据源中制造一条数据流，依次对流中的元素进行操作，当元素经历过流，便无法再对这条流进行操作 2.采用内部迭代的方式 相比与Collection，是使用Iterator遍历器进行处理，Collection是一种外部迭代 而对于Stream,只要申明处理方式，处理过程在流中自行完成，这是一种内部迭代，在数据量大与高并发场景，内部迭代比外部迭代更加高效 二、优点 无存储......
java入门到精通2：java8Stream流各种使用
程序员句号的博客
03-12 1110
java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。
Stream流的使用
weixin_54363295的博客
02-08 650
stream流
Stream流最全操作示例，详细解释由浅入深好理解
最新发布
a59457asdf的博客
10-07 181
Java开发中，stream流可以对集合数据进行各种操作，如基础的过滤、排序、聚合等，但是stream流的使用可以让代码更加简洁。（注：开发中视情况使用，如果是复杂的数据逻辑处理，不建议使用stream流，可能不易读，不便于维护，不便于问题的排查）十一、 joining()方法可以接受零个或多个参数，用于指定连接字符串的分隔符、前缀和后缀。十、flatMap:提取集合对象中的属性组成新的集合。三、默认的distinct去重，以及复杂逻辑去重。九、List转List
stream流的使用
qq_44892120的博客
06-27 1807
stream流的使用
stream流的简单使用
06-05
在本资源中，我们将通过一个简单的示例来介绍Stream流的基本使用。 Person类定义 首先，我们需要定义一个Person类，用于存储人员信息。该类中包含三个私有成员变量：name、age和gender。同时，我们还重写了...
简单总结Java IO中stream流的使用方法
09-02
Java IO中的Stream流是Java语言进行输入输出操作的核心机制。它以“流”的方式处理数据，使得数据的传输变得简单且高效。Stream流分为两种主要类型：数据流和打印流，它们都是Java入门学习的基础。 首先，我们来...
NodeJS 中Stream 的基本使用
10-18
本文将深入探讨Node.js中的Stream基本使用，主要包括创建可读流、流动状态与暂停状态的理解。 首先，创建可读流是通过`fs.createReadStream`方法实现的。该方法接受两个参数，第一个是文件路径，第二个是选项对象，...
Stream流api的基本使用
m0_73555722的博客
09-04 467
Stream是数据渠道，用于操作数据源所生成的元素序列，它可以实现对集合的复杂操作，例如过滤、排序和映射等。(1)集合是一种静态的数据结构，存储在内存中，而Stream是通过CPU来实现计算的(并不会存储数据) (2)Stream不会改变源对象，而是返回的Stream(不可变) (3)Stream流只能使用一次。
Stream流使用
小何的博客
05-17 254
Stream流使用
Stream流的用法(基础)
qq_39378056的博客
08-30 336
import lombok.Data; import org.junit.Test; import java.util.*; import java.util.stream.Collectors; /** * 官方api文档：https://www.oracle.com/java/technologies/javase/8-whats-new.html * 记录stream的用法 * 简介： * Stream是Java8 新增的流特性，目的是让程序员写出高效率、干净、简洁的代码
使用 Stream API 优化你的代码
Java笔记虾
09-23 1386
Java8的新特性主要是Lambda表达式和流，当流和Lambda表达式结合起来一起使用时，因为流申明式处理数据集合的特点，可以让代码变得简洁易读 放大招，流如何简化代码 如果有一个需求，需要对数据库查询到的菜肴进行一个处理： 筛选出卡路里小于400的菜肴 对筛选出的菜肴进行一个排序 获取排序后菜肴的名字 菜肴：Dish.java publicclassD...
Stream流使用的详细介绍
YunWQ的博客
06-03 912
Stream流式编程 Java 8引入了全新的Stream API。这里的Stream和I/O流不同。它提供一种对 Java 集合运算和表达的流式编程方式，大大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 少废话，咱们先来体验一把 //打印输出集合中，姓张并且者长度为3的元素 public class StreamDemo1 { public static void main(String[] args) { ArrayList<String> li
stream流的用法，超全
qq_61547726的博客
05-09 4038
循环 List 或 Map 可以使用 Java的 for 循环、增强 for 循环、迭代器和 Stream 流等方式。
stream流的介绍和使用
LC的博客
12-07 4033
#Stream 流的操作流程 Stream流的操作 常见的 Stream 中间操作： 按照条件过滤得到 ==> filter() 有返回的循环改变(可返回一部分，甚至变换类型) ==> map() 无返回的循环改变 （全部返回相同类型）==> peek（） 限制最大个数() ==> limit() 跳过几个，从最开始跳() ==> skip() 排序() ==> sorted() 不同() ==> distinct() peek 和 map 的区别： pee.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值