Stream流方法

最新推荐文章于 2022-09-29 15:45:03 发布
最新推荐文章于 2022-09-29 15:45:03 发布
阅读量225 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42927103/article/details/119139055
版权

Stream方法

1、filter(T-> boolean) 过滤

    public static void filter(){
        List<User> list = users();
        List<User> newlist = list.stream().filter(user -> user.getAge() > 20)
                .collect(Collectors.toList());
        for (User user : newlist) {
            System.out.println(user.getName()+" --> "+ user.getAge());
        }
    }
 /*   ---结果---
    袁天罡 --> 99
   陆佑劫 --> 45
   张天师 --> 48*/

2、distinct 去重

    数据源中复制new User("李星云", 18, 0, "渝州",new BigDecimal(1000)) 并粘贴两个
    public static void distinct(){
        List<User> list = users();
        List<User> newlist = list.stream().distinct().collect(Collectors.toList().reversed());
        //List<User> newlist = list.stream().distinct().collect(Collectors.toList());
        for (User user : newlist) {
            System.out.println(user.getName()+" --> "+ user.getAge());
        }
    }
/*    ---结果---
   李星云 --> 18
   陆林轩 --> 16
   姬如雪 --> 17
   袁天罡 --> 99
   张子凡 --> 19
   陆佑劫 --> 45
   张天师 --> 48
   蚩梦 --> 18*/

3、sorted 排序

    public static void sorted(){
        List<User> list = users();
        List<User> newlist = list.stream()
                .sorted(Comparator.comparingInt(User::getAge))
                .collect(Collectors.toList());
        for (User user : newlist) {
            System.out.println(user.getName()+" --> "+ user.getAge());
        }
    }
//倒叙
    list.stream().sorted(Comparator.comparing(Student::getAge).reversed())
/*    ---结果---
    陆林轩 --> 16
   姬如雪 --> 17
   李星云 --> 18
   蚩梦 --> 18
   张子凡 --> 19
   陆佑劫 --> 45
   张天师 --> 48
   袁天罡 --> 9*/

4、limit返回前n个元素

    public static void limit(){
        List<User> list = users();
        List<User> newlist = list.stream()
                .sorted(Comparator.comparingInt(User::getAge))
                .limit(2)
                .collect(Collectors.toList());
        for (User user : newlist) {
            System.out.println(user.getName()+" --> "+ user.getAge());
        }
    }
/*    ---结果---
   陆林轩 --> 16
   姬如雪 --> 17*/

5、skip去除前n个元素

    public static void skip(){
        List<User> list = users();
        List<User> newlist = list.stream()
                .sorted(Comparator.comparingInt(User::getAge))
                .skip(2)
                .collect(Collectors.toList());
        for (User user : newlist) {
            System.out.println(user.getName()+" --> "+ user.getAge());
        }
    }

/*    ---结果---
   李星云 --> 18
   蚩梦 --> 18
   张子凡 --> 19
   陆佑劫 --> 45
   张天师 --> 48
   袁天罡 --> 99*/

6、map(T->R) 输出查询的内容

 public static void map(){
        List<User> list = users();
        List<String> newlist = list.stream()
                .map(User::getName).distinct().collect(Collectors.toList());
        for (String add : newlist) {
            System.out.println(add);
        }
    }
 /*   ---结果---
   李星云
   陆林轩
   姬如雪
   袁天罡
   张子凡
   陆佑劫
   张天师
   蚩梦*/

7、flatMap(T -> Stream)

    public static void flatmap(){
        List<String> flatmap = new ArrayList<>();
        flatmap.add("常宣灵,常昊灵");
        flatmap.add("孟婆,判官红,判官蓝");
        /*
            这里原集合中的数据由逗号分割，使用split进行拆分后，得到的是Stream<String[]>，
            字符串数组组成的流，要使用flatMap的Arrays::stream
            将Stream<String[]>转为Stream<String>,然后把流相连接
   、     */
        flatmap = flatmap.stream()
                .map(s -> s.split(","))
                .flatMap(Arrays::stream)
                .collect(Collectors.toList());
        for (String name : flatmap) {
            System.out.println(name);
        }
    }
   /* ---结果---
    常宣灵
   常昊灵
   孟婆
   判官红
   判官蓝*/

8、allMatch（T->boolean）检测是否全部满足参数行为

    public static void allMatch(){
        List<User> list = users();
        boolean flag = list.stream()
                .allMatch(user -> user.getAge() >= 17);
        System.out.println(flag);
    }
/* ---结果---
false/*

9、anyMatch（T->boolean）检测是否有任意元素满足给定的条件

    public static void anyMatch(){
        List<User> list = users();
        boolean flag = list.stream()
                .anyMatch(user -> user.getSex() == 1);
        System.out.println(flag);
    }
 /*  ---结果---
   true*/

10、noneMatchT->boolean）流中是否有元素匹配给定的 T -> boolean条件

    public static void noneMatch(){
        List<User> list = users();
        boolean flag = list.stream()
                .noneMatch(user -> user.getAddress().contains("郑州"));
        System.out.println(flag);
    }
/*   ---结果---
   true*/

11、findFirst( ):找到第一个元素

    public static void findfirst(){
        List<User> list = users();
        Optional<User> optionalUser = list.stream()
                .sorted(Comparator.comparingInt(User::getAge))
                .findFirst();
        System.out.println(optionalUser.toString());
    }
 /*  ---结果---
   Optional[User{name='陆林轩', age=16, sex=1, money=500, address='渝州'}]*/

12、findAny( ):找到任意一个元素

    public static void findAny(){
        List<User> list = users();
//        Optional<User> optionalUser = list.stream()
                .findAny();
        Optional<User> optionalUser = list.stream()
                .findAny();
        System.out.println(optionalUser.toString());
    }
 /*  ---结果---
   Optional[User{name='李星云', age=18, sex=0, money=1000, address='渝州'}]*/

13、计算总数

​```java
    public static void count(){
        List<User> list = users();
        long count = list.stream().count();
        System.out.println(count);
    }
 /*   ---结果---
   8*/

14、最大值 最小值

    public static void max_min(){
        List<User> list = users();
        Optional<User> max = list.stream()
                .collect(
                        Collectors.maxBy(
                                Comparator.comparing(User::getAge)
                        )
                );
        Optional<User> min = list.stream()
                .collect(
                        Collectors.minBy(
                                Comparator.comparing(User::getAge)
                  )
                );
        System.out.println("max--> " + max+"  min--> "+ min);
    }
/*   ---结果---
   max--> Optional[User{name='袁天罡', age=99, sex=0, money=100000, address='藏兵谷'}]  min--> Optional[User{name='陆林轩', age=16, sex=1, money=500, address='渝州'}]*/

15、求和_平均值

    public static void sum_avg(){
        List<User>list = users();
        int totalAge = list.stream()
                .collect(Collectors.summingInt(User::getAge));
        System.out.println("totalAge--> "+ totalAge);

        /*获得列表对象金额， 使用reduce聚合函数,实现累加器*/
        BigDecimal totalMpney = list.stream()
                .map(User::getMoney)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println("totalMpney--> " + totalMpney);

        double avgAge = list.stream()
                .collect(Collectors.averagingInt(User::getAge));
        System.out.println("avgAge--> " + avgAge);
    }
/*   ---结果---
   totalAge--> 280
   totalMpney--> 105700
   avgAge--> 35.0*/

16、一次性得到元素的个数、总和、最大值、最小值

    public static void allVlaue(){
        List<User> list = users();
        IntSummaryStatistics statistics = list.stream()
                .collect(Collectors.summarizingInt(User::getAge));
        System.out.println(statistics);
    }
 /*  ---结果---
   IntSummaryStatistics{count=8, sum=280, min=16, average=35.000000, max=99}*/

17、拼接

    public static void join(){
        List<User> list = users();
        String names = list.stream()
                .map(User::getName)
                .collect(Collectors.joining(", "));
        System.out.println(names);
    }
  /* ---结果---
   李星云, 陆林轩, 姬如雪, 袁天罡, 张子凡, 陆佑劫, 张天师, 蚩梦*/

18、分组

     public static void group(){
        Map<Integer, List<User>> map = users().stream()
                .collect(Collectors.groupingBy(User::getSex));
        System.out.println(new Gson().toJson(map));
        System.out.println();
        Map<Integer, Map<Integer,List<User>>> map2 = users().stream()
                .collect(Collectors.groupingBy(User::getSex,
                        Collectors.groupingBy(User::getAge)));
        System.out.println(new Gson().toJson(map2));
    }
 /*  ---结果---
{"0":[{"name":"李星云","age":18,"sex":0,"address":"渝州","money":1000},{"name":"袁天罡","age":99,"sex":0,"address":"藏兵谷","money":100000},{"name":"张子凡","age":19,"sex":0,"address":"天师府","money":900},{"name":"陆佑劫","age":45,"sex":0,"address":"不良人","money":600},{"name":"张天师","age":48,"sex":0,"address":"天师府","money":1100}],"1":[{"name":"陆林轩","age":16,"sex":1,"address":"渝州","money":500},{"name":"姬如雪","age":17,"sex":1,"address":"幻音坊","money":800},{"name":"蚩梦","age":18,"sex":1,"address":"万毒窟","money":800}]}

{"0":{"48":[{"name":"张天师","age":48,"sex":0,"address":"天师府","money":1100}],"18":[{"name":"李星云","age":18,"sex":0,"address":"渝州","money":1000}],"19":[{"name":"张子凡","age":19,"sex":0,"address":"天师府","money":900}],"99":[{"name":"袁天罡","age":99,"sex":0,"address":"藏兵谷","money":100000}],"45":[{"name":"陆佑劫","age":45,"sex":0,"address":"不良人","money":600}]},"1":{"16":[{"name":"陆林轩","age":16,"sex":1,"address":"渝州","money":500}],"17":[{"name":"姬如雪","age":17,"sex":1,"address":"幻音坊","money":800}],"18":[{"name":"蚩梦","age":18,"sex":1,"address":"万毒窟","money":800}]}}*/

19、分组合计

   
    public static void groupCount(){
        Map<Integer, Long> num = users().stream()
                .collect(Collectors.groupingBy(User::getSex, Collectors.counting()));
        System.out.println(num);
        Map<Integer, Long> num2 = users().stream()
                .filter(user -> user.getAge()>=18)
                .collect(Collectors.groupingBy(User::getSex, Collectors.counting()));
        System.out.println(num2);
    }
  /* ---结果---
   {0=5, 1=3}
   {0=5, 1=1}*/

20、分区

  public static void partitioningBy(){
        List<User> list = users();
        Map<Boolean, List<User>> part = list.stream()
                .collect(Collectors.partitioningBy(user -> user.getAge() <= 30));
        System.out.println(new Gson().toJson(part));
    }
 /*  ---结果---
    {"false":[{"name":"袁天罡","age":99,"sex":0,"address":"藏兵谷","money":100000},{"name":"陆佑劫","age":45,"sex":0,"address":"不良人","money":600},{"name":"张天师","age":48,"sex":0,"address":"天师府","money":1100}],"true":[{"name":"李星云","age":18,"sex":0,"address":"渝州","money":1000},{"name":"陆林轩","age":16,"sex":1,"address":"渝州","money":500},{"name":"姬如雪","age":17,"sex":1,"address":"幻音坊","money":800},{"name":"张子凡","age":19,"sex":0,"address":"天师府","money":900},{"name":"蚩梦","age":18,"sex":1,"address":"万毒窟","money":800}]}*/

21、计算Stream流长度

  public static void partitioningBy(){
        List<User> list = users();
        long size;
        size= list.stream().count();
        System.out.println(size);
    }
一叶知秋宇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最全的JavaStream操作集合教程
violets007的博客
03-13 1175
流式编程API集合数组I/O过滤映射排序归约。
Stream流常用操作
weixin_45119534的博客
01-14 497
Stream流用法
Stream:findFirst()高效简洁遍历集合中的一个元素
studyday1的博客
09-29 7547
业务开发中会运用到很多的List集合数据类型，存放我们需要的业务数据，比如说有个产品产量信息表T，业务需要用柱状图展示每个产品每个月的产量图示，那我们定义了一个实体类ProductVO来传递这些数据,包含了月份month,总数count,产品pro，通过dao.xml中对产量信息表进行SQL编程，将产量数按月份和产品分组求和，最终返回在一个List中。get方法则返回处理的元素。方法在此流中查找第一个元素作为。
Stream流分组
啥也没有
03-24 3万+
java Stream流分组案例
java的stream流方法
baidu_41564215的博客
09-15 230
一、流程： stream of elements -> filter -> sorted -> map -> collect 二、java格式 List<Integer> transactionsIds = widgets.stream() .filter(b -> b.getColor() == RED) .sorted((x,y) -> x.getWeight() - y.getWeight())
Stream流常用方法
12-22
以下将详细介绍从标题和描述中提及的Stream流的常用方法： 1. **获取Stream流** - **从Collection获取**：所有实现了`Collection`接口的类（如`List`, `Set`, `Queue`等）都提供了`stream()`方法，用于将集合转换...
详解JAVA Stream流
08-18
5. Stream<T> limit(long n)：用于截取流中的元素，只取用前n个元素，此方法是延迟方法，可以继续调用Stream流中的其他方法。 stream1.limit(2).forEach(name -> System.out.println(name)); Stream流还提供了其他...
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作...Java Stream 流实现合并操作是一个常见的操作，了解合并 Stream 流的方法和原理对于 Java 开发者来说是非常重要的。在实际开发中，我们应该根据实际情况选择合适的方法来合并 Stream 流。
Java Stream流知识总结
08-19
Java Stream流的常用方法： 1. filter()：用于对流元素进行过滤，例如 filter(s -> s.startsWith("张"))。 2. map()：用于对流元素进行转换，例如 map(s -> s.toUpperCase())。 3. sorted()：用于对流元素进行排序...
stream流操作demo
01-14
- 通过集合的`stream()`或`parallelStream()`方法创建。 - 使用`Arrays.stream()`或`IntStream.range()`等方法处理数组。 - I/O流也可以转换为Stream，如`Files.lines()`。 3. **中间操作（Intermediate ...
Java中的stream流的概念解析及实际运用总结
09-02
流是指传输时的数据,Java为流准备了很多内置类,尤其是IO输入输出流非常常用,这里我们来看一下Java中的stream流的概念解析及实际运用总结
JAVA——流（Stream）输入输出流
qq_34566673的博客
06-14 2000
什么是流？ 什么是流（Stream），流就是一系列的数据 流是个抽象的概念，是对输入输出设备的抽象，当不同的介质之间有数据交互的时候，JAVA就使用流来实现。 数据源可以是文件，还可以是数据库，网络甚至时候其他的程序 比如读取文件的数据到程序中，站在程序的角度来看，就叫做输入流 输入流：InputStream 输出流：OutputStream 文件输入流： 建立一个文件输入流，这个流可以用来把数据从硬盘的文件读取到JVM（虚拟机）内 这段代码只是建立一个流，并没有开始读取； import java.io.
java1.8输出语句_JAVA在JDK1.8中Stream流的使用
weixin_42360993的博客
02-25 489
Stream流的map使用转换大写List list3 = Arrays.asList("zhangSan", "liSi", "wangWu");System.out.println("转换之前的数据:" +list3);List list4 =list3.stream().map(String::toUpperCase).collect(Collectors.toList());System....
Java-Stream流方法学习及总结
大仙
08-16 1865
前言 Stream是一个来自数据源的元素队列并支持聚合操作，其中具有以下特性： Stream只负责计算，不存储任何元素，元素是特定类型的对象，形成一个队列 数据源可以实集合、数组、I/O channel、generator等 聚合操作有类似SQL的：filter、map、match、sorted等操作 Stream流的执行类似于懒加载，用户使用时才执行相应操作 可消费性；Stream只能被消费一次，被消费后需要重新生成 本文总结了部分在日常开发中经常接触到的一些Stream流相关的方法，不足之处或有错误
Java8的Stream流详解
长风
07-24 6万+
首先，Stream流有一些特性： Stream流不是一种数据结构，不保存数据，它只是在原数据集上定义了一组操作。 这些操作是惰性的，即每当访问到流中的一个元素，才会在此元素上执行这一系列操作。 Stream不保存数据，故每个Stream流只能使用一次。 关于应用在Stream流上的操作，可以分成两种：Intermediate(中间操作)和Terminal(终止操作)。中间操作的返回结果都是...
java8 Stream流
纯洁的小魔鬼
11-04 1092
1.流操作 分为两大类：中间操作和终端操作，可以连接起来的流操作称为中间操作，关闭流的操作称为终端操作。 2.中间操作和终端操作 例如filter等中间操作会返回另一个流,除非流水线上触发一个终端操作，否则中间操作不会执行任何处理，它们很懒。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。 流的使用一般包括三个步骤：生成流，中间操作，终端操作 常用的中间操作:filte......
java8 Stream语法详解
weixin_33738555的博客
07-19 2582
些Stream的例子可能让你产生疑惑，本文将会详细讲解Stream的使用方法（不会涉及Stream的原理，因为这个系列的文章还是一个快速学习如何使用的）。 1. Stream初体验 我们先来看看Java里面是怎么定义Stream的： A sequence of elements supporting sequential and parallel aggregate operations...
Java 8系列之Stream的基本语法详解
热门推荐
行云间
02-10 7万+
概述继Java 8系列之Lambda表达式之后，我们来了解Stream。Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。聚合操作为了学习聚合的使用，在这里，先定义一个数据类：public class Student { int no
JAVA输入输出 流（stream）
Unarmed_的博客
02-20 399
输入/输出（I/O）是指程序与外部设备或其他计算机进行交互的操作。 流（stream）的概念最早起源于UNIX操作系统中管道（pipe）的概念。 为了便于理解，读者可以将JAVA中的流想象成一种“数据流通的管道”，文件和程序之间一旦有了数据请求，二者之间就会建立某种形式的链接，从而形成数据流。 同时JAVA中的数据流也有不同的形式，既可以是基于二进制的字节流，也可以是基于某种编码方式的字节流。 流的方向是重要的，根据流的方向，流可以大致分成两类：输入流和输出流。 当程序需要读取数据时，就会开启一个通向数据源
stream流方法大全
最新发布
05-01
下面是Stream流方法的大全及其作用： 1. filter()：用于对元素进行过滤。 2. map()：用于对集合中的元素进行映射操作。 3. flatMap()：用于将一个元素映射成多个元素，并将多个流合并成一个流。 4. distinct()：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值