java8 stream 的项目中的使用 经典案例！java新手必读

最新推荐文章于 2022-05-07 16:34:22 发布
最新推荐文章于 2022-05-07 16:34:22 发布
阅读量552 收藏
点赞数
分类专栏： JAVA基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34168515/article/details/111304936
版权
本文详细介绍了Java Stream API的使用，包括通过map获取对象字段集合、filter进行条件筛选、groupingBy进行分类、根据字段归类、使用peek进行对象字段替换、排序操作以及遍历列表并赋值等常见操作。示例代码清晰地展示了每个操作的实现，对于理解和应用Java Stream API非常有帮助。
摘要由CSDN通过智能技术生成

文章目录

前言

流的使用包括三件事：
数据源，集合
中间操作，流水线
终端操作，执行流水线，生成结果

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。

获取一个数据源（source）→ 数据转换 → 执行操作获取想要的结果

1. list T为一个对象，取出某一个字段的集合 （map）

        DxUser dxUserBuilder = DxUser.builder().id(1L).username("1哥").password("123456").build();
        DxUser dxUserBuilder1 = DxUser.builder().id(2L).username("2哥").password("123456").build();
        DxUser dxUserBuilder2 = DxUser.builder().id(3L).password("123456").build();
        DxUser dxUserBuilder3 = DxUser.builder().id(4L).username("4哥").password("123456").build();

        List<DxUser> list = new ArrayList<>();

        list.add(dxUserBuilder);
        list.add(dxUserBuilder1);
        list.add(dxUserBuilder2);
        list.add(dxUserBuilder3);

        //list取出id列
        List<Long> collect = list.stream().map(DxUser::getId).collect(Collectors.toList());
        collect.forEach(System.out::println);

        //list取出username列
        List<String> collect1 = list.stream().map(DxUser::getUsername).collect(Collectors.toList());
        collect1.forEach(System.out::println);

        //1
        //2
        //3
        //4
        //1哥
        //2哥
        //null
        //4哥

2. list T为一个对象，取出某一个字段，判断该字段值，进行分类 (filter)

        DxUser dxUserBuilder = DxUser.builder().id(1L).username("1哥").password("123456").build();
        DxUser dxUserBuilder1 = DxUser.builder().id(2L).username("2哥").password("123456").build();
        DxUser dxUserBuilder2 = DxUser.builder().id(3L).password("123456").build();
        DxUser dxUserBuilder3 = DxUser.builder().id(4L).username("4哥").password("123456").build();

        List<DxUser> list = new ArrayList<>();

        list.add(dxUserBuilder);
        list.add(dxUserBuilder1);
        list.add(dxUserBuilder2);
        list.add(dxUserBuilder3);

        //找出id大于2L的
        List<DxUser> collect = list.stream().filter(x -> x.getId() > 2).collect(Collectors.toList());

        collect.forEach(System.out::println);

        //大于2L 和 小于等于2进行 分组
        Map<Boolean, List<DxUser>> collect1 = list.stream().collect(Collectors.groupingBy(x -> x.getId() > 2));
        System.out.println("===大于2L==");
        collect1.get(true).forEach(System.out::println);
        System.out.println("===小于等于2L==");
        collect1.get(false).forEach(System.out::println);

3. 根据 list 获取 list t对象 (map)

        DxUser dxUserBuilder = DxUser.builder().id(1L).username("1哥").password("123456").build();
        DxUser dxUserBuilder1 = DxUser.builder().id(2L).username("2哥").password("123456").build();
        DxUser dxUserBuilder2 = DxUser.builder().id(3L).password("123456").build();
        DxUser dxUserBuilder3 = DxUser.builder().id(4L).username("4哥").password("123456").build();

        List<DxUser> list = new ArrayList<>();

        list.add(dxUserBuilder);
        list.add(dxUserBuilder1);
        list.add(dxUserBuilder2);
        list.add(dxUserBuilder3);

        List<Long> ids = Arrays.asList(2L, 3L, 4L);

        List<DxUser> dxUsers = ids.stream().map((x) -> {
                
        //     for (DxUser dxUser : list) {
        //         if(dxUser.getId().equals(x)){
        //             return dxUser;
        //         }
        //     }
        //     return null;

                List<DxUser> dxUserList = list.stream().filter(y -> y.getId().equals(x)).collect(Collectors.toList());
                return dxUserList.get(0);

        } ).collect(Collectors.toList());

        dxUsers.forEach(System.out::println);

4. 根据list T对象某个字段进行归类

  • 4.1 有几类就分几类 (Collectors.groupingBy)
  • 4.2 分为两类，true为符合条件，false不符合条件 (Collectors.partitioningBy)
        DxUser dxUserBuilder = DxUser.builder().id(1L).username("1哥").password("123456").department("java开发").build();
        DxUser dxUserBuilder1 = DxUser.builder().id(2L).username("2哥").password("123456").department("c#开发").build();
        DxUser dxUserBuilder2 = DxUser.builder().id(3L).password("123456").department("c++开发").build();
        DxUser dxUserBuilder3 = DxUser.builder().id(4L).username("4哥").password("123456").department("java开发").build();

        List<DxUser> list = new ArrayList<>();

        list.add(dxUserBuilder);
        list.add(dxUserBuilder1);
        list.add(dxUserBuilder2);
        list.add(dxUserBuilder3);

        //用部门进行分类,以上看出，分出三类
        Map<String, List<DxUser>> collect = list.stream().collect(Collectors.groupingBy(DxUser::getDepartment));

        collect.forEach((x,y)->{
            System.out.println("x: " + x);
            System.out.println("y: size:"+ y.size() + y);
        });

        //x: c++开发
        //y: size:1[DxUser(id=3, username=null, password=123456,department=c++开发)]
        //x: c#开发
        //y: size:1[DxUser(id=2, username=2哥, password=123456,department=c#开发)]
        //x: java开发
        //y: size:2[DxUser(id=1, username=1哥, password=123456,department=java开发), DxUser(id=4, username=4哥, password=123456,department=java开发)]
        System.out.println("==========");

        Map<Boolean, List<DxUser>> collect1 = list.stream().collect(Collectors.partitioningBy(x -> x.getDepartment().equals("java开发")));
        collect1.forEach((x,y)->{
            System.out.println("x: " + x);
            System.out.println("y: size:"+ y.size() + y);
        });

        //x: false
        //y: size:2[DxUser(id=2, username=2哥, password=123456 department=c#开发), DxUser(id=3, username=null, password=123456 department=c++开发)]
        //x: true
        //y: size:2[DxUser(id=1, username=1哥, password=123456 department=java开发), DxUser(id=4, username=4哥, password=123456 department=java开发)]

5 对 list 在的T进行替换，想对哪个字段替换就对哪个字段替换（peek）

        DxUser dxUserBuilder = DxUser.builder().id(1L).username("1哥").password("123456").department("java开发").build();
        DxUser dxUserBuilder1 = DxUser.builder().id(2L).username("2哥").password("123456").department("c#开发").build();
        DxUser dxUserBuilder2 = DxUser.builder().id(3L).password("123456").department("c++开发").build();
        DxUser dxUserBuilder3 = DxUser.builder().id(4L).username("4哥").password("123456").department("java开发").build();

        List<DxUser> list = new ArrayList<>();

        list.add(dxUserBuilder);
        list.add(dxUserBuilder1);
        list.add(dxUserBuilder2);
        list.add(dxUserBuilder3);

        //把字段进行替换。username+(?),loginname="登录名"
        List<Object> collect = list.stream().peek((x) -> {x.setUsername(x.getUsername() + "(?)");x.setLoginname("登录名");}).collect(Collectors.toList());
        collect.forEach(System.out::println);

6 排序，对list某个字段进行排序，但是只对基本数据类型有效

  • 6.1 正序 (sorted)
  • 6.2 倒序
  • 6.3 排序后再分组 （sorted,groupingBy）
        DxUser dxUserBuilder = DxUser.builder().id(1L).username("1哥").password("3").department("java开发").build();
        DxUser dxUserBuilder1 = DxUser.builder().id(-2L).username("2哥").password("4").department("c#开发").build();
        DxUser dxUserBuilder2 = DxUser.builder().id(13L).password("13").department("c++开发").build();
        DxUser dxUserBuilder3 = DxUser.builder().id(4L).username("4哥").password("-1").department("java开发").build();

        List<DxUser> list = new ArrayList<>();

        list.add(dxUserBuilder);
        list.add(dxUserBuilder1);
        list.add(dxUserBuilder2);
        list.add(dxUserBuilder3);

        //按照id进行排序
        List<DxUser> collect = list.stream().sorted(Comparator.comparing(DxUser::getId)).collect(Collectors.toList());
        collect.forEach(System.out::println);
        System.out.println("-------------------");
        //倒序
        List<DxUser> collect1 = list.stream().sorted(Comparator.comparing(DxUser::getId).reversed()).collect(Collectors.toList());
        collect1.forEach(System.out::println);
        System.out.println("-------------------");
        //分组后再排序
        Map<String, List<DxUser>> collect2 = list.stream().sorted(Comparator.comparing(DxUser::getId).reversed()).collect(Collectors.groupingBy(DxUser::getDepartment));

        collect2.forEach((x,y)->{
            System.out.println("x: " + x);
            System.out.println("y: size:"+ y.size() + y);
        });

7 遍历List后，向某个字段进行赋值

        DxUser dxUserBuilder = DxUser.builder().id(1L).status(32).username("1哥").password("3").department("java开发").build();
        DxUser dxUserBuilder1 = DxUser.builder().id(-2L).status(12).username("2哥").password("4").department("c#开发").build();
        DxUser dxUserBuilder2 = DxUser.builder().id(13L).status(10).password("13").department("c++开发").build();
        DxUser dxUserBuilder3 = DxUser.builder().id(4L).status(33).username("4哥").password("-1").department("java开发").build();

        List<DxUser> list = new ArrayList<>();

        list.add(dxUserBuilder);
        list.add(dxUserBuilder1);
        list.add(dxUserBuilder2);
        list.add(dxUserBuilder3);

        DxRole dxRole = DxRole.builder().sn("加入成功").build();

        List<DxUser> collect = list.stream().peek(x -> {
            if ("13".equals(x.getPassword())) {
                x.setRole(dxRole);
            }
        }).collect(Collectors.toList());

        collect.forEach(System.out::println);

参考文章

https://www.cnblogs.com/owenma/p/12207330.html

Student s1 = new Student("aa", 10,1);
Student s2 = new Student("bb", 20,2);
Student s3 = new Student("cc", 10,3);
List<Student> list = Arrays.asList(s1, s2, s3);
  
//装成list
List<Integer> ageList = list.stream().map(Student::getAge).collect(Collectors.toList()); // [10, 20, 10]
  
//转成set
Set<Integer> ageSet = list.stream().map(Student::getAge).collect(Collectors.toSet()); // [20, 10]
  
//转成map,注:key不能相同，否则报错
Map<String, Integer> studentMap = list.stream().collect(Collectors.toMap(Student::getName, Student::getAge)); // {cc=10, bb=20, aa=10}
  
//字符串分隔符连接
String joinName = list.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc)
  
//聚合操作
//1.学生总数
Long count = list.stream().collect(Collectors.counting()); // 3
//2.最大年龄 (最小的minBy同理)
Integer maxAge = list.stream().map(Student::getAge).collect(Collectors.maxBy(Integer::compare)).get(); // 20
//3.所有人的年龄
Integer sumAge = list.stream().collect(Collectors.summingInt(Student::getAge)); // 40
//4.平均年龄
Double averageAge = list.stream().collect(Collectors.averagingDouble(Student::getAge)); // 13.333333333333334
// 带上以上所有方法
DoubleSummaryStatistics statistics = list.stream().collect(Collectors.summarizingDouble(Student::getAge));
System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());
  
//分组
Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));
//多重分组,先根据类型分再根据年龄分
Map<Integer, Map<Integer, List<Student>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(Student::getType, Collectors.groupingBy(Student::getAge)));
  
//分区
//分成两部分，一部分大于10岁，一部分小于等于10岁
Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));
  
//规约
Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get(); //40
是潮汕的灿灿展吖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java8 Stream使用（超详细案例）
qq_38531706的博客
07-09 818
目录一、stream是什么？二、stream操作分类三、stream的使用3.1.forEach()3.2.map()3.3.filter()3.3.distinct()3.4.allMatch()3.5.anyMatch()3.6.noneMatch()3.7.sorted()3.7.skip() + limit()分页3.7.分组3.8.统计3.9.字符串拼接3.10.集合转换3.11.reduce()3.12.Optional （扩展）3.13.findFirst()3.14.findAny()3.1
java8中Stream的使用以及分割list案例
08-24
Java8中的Stream使用和分割List案例 Java8中Stream的使用可以大大提高编程效率，代码简洁易懂。Stream api可以用来处理大规模的数据，提高性能。下面将详细介绍Java8中Stream的使用和分割List案例。 一、Stream的...
20 个实例玩转 Java 8 Stream
方志朋的博客
05-02 140
点击关注公众号，Java干货及时送达先贴上几个案例，水平高超的同学可以挑战一下：1. 从员工集合中筛选出salary大于8000的员工，并放置到新的集合里。2. 统计员工的最高薪资、平均薪...
java8 Stream使用案例
weixin_34228662的博客
10-25 128
1. 原理 Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。 原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作； 高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如: 所有元素求和 过滤掉长度大于 10 的字符串 获取每个字符串的首字母 Stream 就...
java8 Stream 使用案例
son_of_a__bitch的博客
01-22 276
java8_Stream预定义示例参数filtermapmapToIntmapToLongmapToDoublepeekflatMapflatMapToIntdistinctsortedlimitforEachforEachOrderedreduceminAMaxcountmatchstream静态 预定义示例参数 static class TestUser { private Integer id; private String name; private
Java8 Stream 用法及案例
xie99lin的博客
05-08 254
Stream 使用一种类 SQL查询的方式来提供一种对Java集合运算和表达的高阶抽象。 可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。 ## Person 实体类： public class Person { private String name;...
Java8中Stream使用的一个注意事项
08-28
Java 8 中的 Stream 是一个强大的工具，它引入了一种新的数据处理方式，特别是对于集合对象的操作。Stream 不是存储数据的数据结构，而是用于处理数据的 API，它提供了丰富的操作，如过滤、映射、聚合等，使得代码...
Java8 stream 中利用 groupingBy 进行多字段分组求和案例
09-07
在Java 8中，Stream API引入了许多新的特性，极大地增强了处理集合数据的能力。其中，`groupingBy`方法就是其中一个非常实用的功能，它允许我们根据指定的条件对集合中的元素进行分组。在这个案例中，我们将探讨如何...
java8中Stream的使用示例教程
08-26
Java 8 中的 Stream API 是一个强大的工具，它极大地简化了集合操作，使得代码更加简洁、易读。Stream API 的引入是为了支持函数式编程风格，它不仅提供了串行处理的能力，还支持并行处理，从而提高了程序的执行效率...
如何在java 8 map中使用stream
08-19
Java 8 中使用 Stream 遍历 Map Java 8 中引入了 Stream 概念， Stream 是一种非常强大的功能，可以使我们更加简单的操作 Map 对象。Map 是 Java 中非常常用的一个集合类型，我们通常也需要去遍历 Map 去获取某些值...
通过实例解析java8中的parallelStream
08-25
主要介绍了通过实例解析java8中的parallelStream,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java新手8个小项目
09-21
特别适合java新手巩固java基础的项目，总共有8个项目的全部代码，都可以直接运行，代码有注释。
Java 8开发的4大顶级技巧
weixin_34216196的博客
12-19 239
我使用Java 8编码已经有些年头，既用于新的应用程序，也用来迁移现有的应用，感觉是时候写一些我发现的非常有用的“最佳实践”。我个人并不喜欢“最佳实践”这个说法，因为它意味着“一刀切”的解决方案，而编码不可能是这样的工作方式——我们需要亲自去发现什么样的解决方案才是有效的。但是我发现了一些Java 8代码中可以帮助我们的一些选择，让我们一起来看看吧。   1.Optional   Op...
实用技术：Java1.8工作中最常用的14个Stream详细小示例
公众号-老炮说Java
03-24 293
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达上一篇：这300G的Java资料是我师傅当年给我的，免费分享给大家（已修复）下一篇：昨天分享资料不小心把百度网盘深处的秘密泄露了...
JDK8 stream 在项目中的应用
daxiaoge111的博客
12-28 357
JDK8 stream会将复杂的代码实现用一行代码搞定。 1、将集合的某一个属性提取出来组成另一个集合 List<Integer> resultList = list.stream().map(Object::getMaintain_id).collect(Collectors.toList()); 2、将集合按照集合里的某一属性转换成map Map<Integer,...
Java stream常用实例代码
Neo.Yang的专栏
01-27 669
应用场景定义对象实体场景一 根据属性过滤对象场景二 提取对象中的属性场景三 按对象属性分组 定义对象实体 package com.elon.model; /** * 简单用户实体类 * * @author elon */ public class User { /** * 用户账号 */ private String account = ""; ...
Java8 Stream：常用实例，玩转集合
IT_Wallace的博客
02-23 384
Java8 Stream：常用实例，玩转集合
stream流在项目中常见操作
qq_42702331的博客
05-07 297
package org.hzero.demo.java300.JavaStream18; import com.alibaba.fastjson.JSONArray; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.hzero.demo.TestLeetCode.Son; import java.util.*; import ja.
java 8 stream 实战案例
zcc225的博客
08-13 210
Map<String, Phone> mapk = phonel.stream().collect(Collectors.toMap(Phone::getName, student -> student)); List<User> usrList = userl.stream().map(o->{ return toFamily(mapk.get(o.ge...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值