Java核心类库之（Stream流：生成、中间、终结、收集操作）

已于 2022-06-30 20:49:01 修改
阅读量1.2w 收藏 21
点赞数 10
文章标签： java udp
于 2021-07-31 12:57:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuan2019035055/article/details/119148948
版权
Java 同时被 2 个专栏收录
33 篇文章 53 订阅
订阅专栏
Java基础
11 篇文章 36 订阅
订阅专栏

目录

1 Stream流

  • 体验Stream流
  • 需求
    在这里插入图片描述
package test;


import java.lang.reflect.Array;
import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建集合，储存多个字符
        ArrayList<String> list = new ArrayList<>();

        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");

        //把集合中所有以“张”开头的数据存储到新的集合
        ArrayList<String> zhanglist = new ArrayList<>();
        for(String s:list) {
            if(s.startsWith("张")) {
                zhanglist.add(s);
            }
        }

//        System.out.println(zhanglist); //[张无忌, 张天峰, 张飞]

        //把"张“开头长度为3的存到新集合
        ArrayList<String> threelist = new ArrayList<>();
        for(String s:zhanglist) {
            if(s.length()==3) {
                threelist.add(s);
            }
        }

        for(String s:threelist) {
            System.out.println(s);
//            张无忌
//            张天峰
        }

        //Stream流
        list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3);
//            张无忌
//            张天峰
    }
}
  • 使用Stream流的方式完成过滤操作
  • list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3);
  • 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义: 生成流、过滤姓张、过滤长度为3、逐一打印
  • Stream流把真正的函数式编程风格引入到Java中

1.1 Stream流的生成方式

  • Stream流的常见生成方式
    • 1、Collection体系的集合可以使用默认方法stream()生成流：default Stream<E> stream()
    • 2、Map体系的集合间接的生成流
    • 3、数组可以通过Stream接口的静态方法生成流：of (T... values)
package test;


import java.util.*;
import java.util.stream.Stream;

public class Demo {
    public static void main(String[] args) {
        //1、Collection体系的集合可以使用默认方法stream()生成流：default Stream<E> stream()
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //2、Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<>();
        Stream<String> keyStream = map.keySet().stream(); //KeySet()方法得到一个Set集合
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //3、数组可以通过Stream接口的静态方法生成流：of (T... values)
        String[] strArray = {"java","python","scala"};
        Stream<String> strArrayStream1 = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("java","python");
        Stream<Integer> integerStream = Stream.of(10, 20, 30);
    }
}
  • Stream流的使用方法
方法名说明
list.stream()生成流：通过数据源(集合，数组等)生成流
filter()中间操作：一个流后面可以跟随零个或多个中间操作， 其目的主要是打开流，做出某种程度的数据过滤映射,然后返回一个新的流,交给下一个操作使用
forEach()终结操作：一个流只能有一个终结操作，当这个操作执行后，流就被使用“光" 了,无法再被操作。所以这必定是流的最后一个操作

1.2 Stream流中间操作之 filter

  • Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤

  • Predicate接口中的方法boolean test(T t)：対给定的参数迸行判断，返回一个布尓值

  • 范例

package test;

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();

        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");

        //需要1：把list集合中以张开头的在控制台输出
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("--------");
//        张无忌
//        张天峰
//        张飞

        //需要2：把list集合中长度为3的元素输出
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("--------");
//        张无忌
//        大熊猫
//        张天峰

        //需求3：把以张开头，长度为3的在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
//        张无忌
//        张天峰
    }
}

1.3 Stream流中间操作之 limit 和 skip

  • Stream<T> limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
  • Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
  • 范例：
package test;

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();

        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");

        //需要1：取前三个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("---------");
//        小黑
//        张无忌
//        大熊猫

        //需求2：跳过3个元素，把剩下的在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("---------");
//        张天峰
//        小白
//        张飞

        //需求3：跳过2个元素，把剩下元素的前两个输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
//        大熊猫
//        张天峰
    }
}

1.4 Stream流中间操作之 concat 和 distinct

  • static <T> Stream<T> concat(Stream а, Stream b)：合并a和b两个流为一个流

  • Stream<T> distinct()：返回由该流的不同元素(根据Object.equals(Object)) 组成的流

  • 范例：

package test;

import java.util.ArrayList;
import java.util.stream.Stream;

public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();

        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");

        //需要1：取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);

        //需求2：跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);

        //需求3：合并1,2结果得到的流，并输出
//        Stream.concat(s1,s2).forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        大熊猫
//        张天峰
//        小白
//        张飞

        //需求4：合并1,2结果得到的流，并输出，要求结果不重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        小白
//        张飞
    }
}

1.5 Stream流中间操作之 sorted

  • Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序
  • Stream<T> sortểd(Comparator comparator)：返回由此流的元素组成的流，根据提供的Comparator排序
  • 范例
package test;

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();

        list.add("b123");
        list.add("a1");
        list.add("f1234");
        list.add("c12");
        list.add("e12345");
        list.add("d12345");

        //需要1：按照字母顺序在控制台输出
        list.stream().sorted().forEach(System.out::println);
//        a1
//        b123
//        c12
//        d12345
//        e12345
//        f1234

        //需求2：按照字符串长度，长度相同自然排序
        list.stream().sorted((s1, s2) -> {
            int num1 = s1.length() - s2.length();
            int num2 = num1 == 0 ? s1.compareTo(s2) : num1;
            return num2;
        }).forEach(System.out::println);
//        a1
//        c12
//        b123
//        f1234
//        d12345
//        e12345
    }
}

1.6 Stream流中间操作之 map 和 mapToInt

  • <R> Stream<R> map(Function mapper)：返回由给定函数应用于此流元素的结果组成的流
    Function接口中的方法—R apply(T t)
  • IntStream mapToInt(ToIntFunction mapper)：返回一个InStream其中包含给定函数应用于此流的元素的结果
    Instream：表示原始流
    TolntFunction接口中的方法—int applyAslnt(T value)
  • 范例：
package test;

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();

        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //需要:将集合中的字符串转换为整数后在控制台输出
//        list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        //方法引用
//        list.stream().map(Integer::parseInt).forEach(System.out::println);
//        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//        10
//        20
//        30
//        40
//        50

        //InStream中方法 :int sum()返回流中元素总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result); //150
    }
}

1. 7 Stream流终结操作之 forEach 和 count

  • Stream流的常见终结操作方法

    • void forEach(Consumer action)：对此流的每个元素执行操作
      Consumer接口中的方法—void accept(T t)：对给定的参数执行此操作
    • long count()：返回此流中的元素数

  • 范例

package test;

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();

        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");

        //需求1：输出集合中的元素
        list.stream().forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        小白
//        张飞

        //需求2：统计以张开头的个数
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count); //3
    }
}

1.8 Stream流收集操作

  • 对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢?
  • Stream流的收集方法
方法名说明
R collect(Collector collector)但是这个收集方法的参数是一个Collector 接口
  • 工具类Collectors提供了具体的收集方式
方法名说明
public static <T> Collector toList()把元素收集到List集合中
public static <T> Collector toSet()把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)把元索收集到Map集合中
  • 范例
package test;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo {
    public static void main(String[] args) {
        //创建list集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("大熊猫");
        list.add("张飞");
        list.add("小熊猫");

        //需求1：得到名字为三个字的流
        Stream<String> listStream = list.stream().filter(name -> name.length() == 3);

        //需求2：把使用Stream操作得到数据存入list集合并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for (String name : names) {
            System.out.println(name);
//            大熊猫
//            小熊猫
        }

        //创建Set集合对象
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);

        //需求3：得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age > 25);

        //需求4：把使用Stream操作得到数据存入set集合并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for (Integer age : ages) {
            System.out.println(age);
//            40
//            30
        }

        //定义个字符串数组，由姓名和年龄组成
        String[] strArray = {"小黑,10", "小白,20", "小熊猫,30", "大熊猫,40"};

        //需求5：得到字符串数组中年龄大于25的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);
        
        //需求6：把使用Stream操作得到数据存入map集合并遍历，姓名做键，年龄做值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer vlaue = map.get(key);
            System.out.println(key + "," + vlaue);
//            大熊猫,40
//            小熊猫,30
        }
    }
}
袁袁袁袁满
关注
专栏目录
Stream流
weixin_43339889的博客
08-14 882
Stream流
Java——Stream流
m0_72786443的博客
09-13 1345
Stream流
java——Stream流
weixin_46362658的博客
03-13 1724
创建不可变集合 什么是不可变集合 不可变集合，就是不可以被修改的集合。 集合的数据项在创建的时候提供，并且在整个生命周期都不可改变。否则报错 为什么要创建不可变集合 如果某个数不能被修改，把他预防性的拷贝到不可变集合是个很好的实践 或者当集合对象不可信的库效用时，不可变形式是安全的 如何创建不可变集合 在List、Set、Map接口中，都存在of方法，可以创建一个不变的集合 ...
stream流详解
最新发布
weixin_62801797的博客
08-20 792
通过数据源生成流一个流后面可以跟一个或者多个中间操作，其中主要的是打开流，做出某种程度的过滤，然后返回一个新的流 给下一个操作使用。接口中的方法 boolean(T t):对给定参数进行判断，返回一个布尔值IntStream:表示原始int 流ToIntFunction接口中的方法 int applyAsInt(T value)InStream流中的特有方法 int sum()常见的函数式接口：1.Supplier接口 生产数据 T get()
Java之Stream流
lghlhg的博客
12-15 1533
Stream是一种处理集合（Collection）数据的方式。Stream可以让我们以一种更简洁的方式对集合进行过滤、映射、排序等操作。
Java中的Stream流
yhb500234的博客
09-03 297
本文主要概述了Java中Stream流的相关知识,包括Stream的获取,操作,以及收集等. 包括一些列中间操作,将集合或者数据转换成流,完成操作后再将流转换成集合或者数组. 要知道,Java中的Stream流只是方便我们操作和处理数据,最后的数据还是要回归到集合或数组本身.
归约、分组与分区，深入讲解JavaStream终结操作
A1867350的博客
04-21 1023
对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！正体系化！**
基础复习第二十六天  java8新特性之Lambda表达式和Stream流的使用
小东学java
03-16 496
java8的新特性
求职之路 | 2024年Java从入门到干活：第18章JDK8-JDK21新特性(二)——Stream API
weixin_36664787的博客
04-01 1763
Stream API把真正的函数式编程引入到Java中。毫不夸张的说，他是目前为止对Java类库最好的补充，它极大提升Java程序员的生产力，写出高效、简洁的代码，让程序员的思绪在指尖跳舞，牛逼的不要不要滴。Stream API是处理集合的关键抽象概念，对集合可以执行复杂的操作，如查找、过滤、映射等等，使用起来就像使用SQL操作数据库一样操作集合。Stream API提供一种高效且易于使用的处理数据的方式。
Java中Stream流
Stars____的博客
02-23 561
使用Stream流的便捷之处 ArrayList<String> list1 = new ArrayList<>(); list1.add("abc001"); list1.add("def003"); list1.add("zxc002"); list1.add("qwe006"); list1.add("abc0007"); list1.add("abc008");
Java8新特性stream
qq_42964601的博客
05-02 636
Java8新特性stream 概念 Stream是Java8 API的新成员，它允许以声明性方式处理数据集合 特点 （1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。 （2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。 流程 1）第一步：把集合转换为流stream 2）第二步：操作stream流stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal o
Java中的Stream
m0_46359551的博客
07-30 1464
Java中的Stream
java的Stream流
JJpZh的博客
06-20 208
案例需求按照下面的要求完成集合的创建和遍历原始方式示例代码 使用Stream流示例代码 Stream流的好处Stream流的思想Stream流的三类方法生成Stream流的方式Collection体系集合使用默认方法stream()生成流， default Stream stream()Map体系集合把Map转成Set集合，间接的生成流数组通过Arrays中的静态方法stream生成流同种数据类型的多个数据通过Stream接口的静态方法of(T… values)生成流代码演示 1.3Stream
java中Stream流
weixin_51304175的博客
09-08 141
Stream流的使用 生成流 通过数据源(集合，数组等)生成流 list.stream() 中间操作 一个流后面可以跟随0个或多个中间操作，目的是打开流，做出某种程度的数据过滤/反射，之后返回一个新的流，交给下一个操作使用 filter() 终结操作 一个流只能有一个终结操作，当这个操作执行后，流就被使用光了，无法再被操作 forEach() Stream流的常见生成方式 import java.util.*; import java.util.stream.Stream; public
java中的Stream流
qq_54650406的博客
04-23 546
java中的Stream流 前言：技术小白，如有错误及冒犯，欢迎指正，参考大佬：b站up三更草堂 首先我们准备好以下类 @Data @NoArgsConstructor @AllArgsConstructor @EqualsAndHashCode//用于后期的去重使用 public class Author { //id private Long id; //姓名 private String name; //年龄 private Integer age;
Java中stream流
wangqsse的博客
05-25 284
1、什么是stream流 Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

袁袁袁袁满

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

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

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

打赏作者

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

抵扣说明：

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

余额充值