[进阶] list 过滤 stream 的lambda进阶操作, 这一篇就够了

已于 2024-02-17 10:35:02 修改
阅读量1.3k 收藏 6
点赞数 3
分类专栏： # java进阶工具类 文章标签： java mybatis list spring boot stream
于 2023-03-23 10:42:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pingzhuyan/article/details/127194365
版权

目录

1. list转化map基本操作

id最常用方式: 

-> 01  key-value值形式:

-> 02 id-> 对象本身

-> 03 id-> 对象本身的 lambda写法

->04  解决冲突的key

2. list计算操作

3. list转化泛型操作

4. List转成map的进阶操作

 ->4.1  有实体类的进阶操作(常用)

--->准备工作01 :  基础数据(User实体类)

--->4.1.1:  (1对1关系) 分组: 用户名-> 用户实体类对象User(String->T)

 --->4.1.2  (1对1关系) 用户名 -> 电话号(String-> String)

--->4.1.301:  (1对多) 分组01: 根据年龄分组  Integer-> List 

--->4.1.302:  (1对多) 分组01: 根据年龄分组  Integer-> List 方法二

--->4.1.4:  (1对多) 分组 根据年龄分出 年龄-> 用户 Integer -> List

-> 4.2 没有实体类的进阶操作

[待续未完....时间有限]

-> 5. 总结: 4整个的main方法

-> 5..1 不啰嗦 直接上代码

1. list转化map基本操作

id最常用方式: 

-> 01  key-value值形式:

Map<Integer,String>map = list.stream().collect(Collectors.toMap(User::getId,User::getRealName))

-> 02 id-> 对象本身

 Map<Integer,User> userMap3 = list.stream().collect(Collectors.toMap(User::getId, Function.identity()));

-> 03 id-> 对象本身的 lambda写法

Map<Integer,User> userMap2 = userList.stream().collect(Collectors.toMap(User::getId,User->User));

->04  解决冲突的key

Map<Integer,User> userMap4 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(),(key1,key2)->key2));

2. list计算操作

计算学生分数方法示例(举一反三案例)                                                                list.stream().map(User::getScore).reduce(BigDecimal.ZERO, BigDecimal::add) 
List<Long> testList = new ArrayList<>(Collections.nCopies(5, 0L));
        testList.set(0,1L);
        testList.set(1,2L);
        testList.set(2,3L);
        testList.set(3,4L);
        testList.set(4,5L);
        System.out.println("sum1 is " + testList.stream().reduce(0L, (a, b) -> a + b));
        // reduce根据初始值（参数1）和累积函数（参数2）依次对数据流进行操作，第一个值与初始值送入累积函数，后面计算结果和下一个数据流依次送入累积函数。
        System.out.println("sum2 is " + testList.stream().reduce(0L, Long::sum));
        System.out.println("sum3 is " + testList.stream().collect(Collectors.summingLong(Long::longValue)));
        // Collectors.summingLong()将流中所有元素视为Long类型，并计算所有元素的总和
        System.out.println("sum4 is " + testList.stream().mapToLong(Long::longValue).sum());
        System.out.println("***********************");
        List<Person> testList1 = new ArrayList<>(Collections.nCopies(5, new Person(1)));
        System.out.println("class sum1 is " + testList1.stream().map(e -> e.getAge()).reduce(0, (a,b) -> a + b));
        System.out.println("class sum2 is " + testList1.stream().map(e -> e.getAge()).reduce(0, Integer::sum));
        System.out.println("class sum3 is " + testList1.stream().collect(Collectors.summingInt(Person::getAge)));
        System.out.println("class sum4 is " + testList1.stream().map(e -> e.getAge()).mapToInt(Integer::intValue).sum());

3. list转化泛型操作

            List<User> list = userMapper.selectUserMessage(null);

            List<UserRespDTO> collect = list.stream().map(dto-> {
                UserRespDTO userRespDTO = new UserRespDTO();
                BeanUtils.copyProperties(dto, respDTO);
                return userRespDTO;
            }).collect(Collectors.toList());

4. List转成map的进阶操作

 ->4.1  有实体类的进阶操作(常用)

--->准备工作01 :  基础数据(User实体类)

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * 模拟用户实体类对象
 *
 * @author pzy
 * @version 0.1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class User {

    private String username;

    private Integer age;

    private String telephone;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date createTime;

}

---> 准备工作02: 

//1. 创建基础数据
        List<User> list = new ArrayList<>();
        User user1 = new User("张三", 33, "13345678913", new Date());
        User user2 = new User("李四", 44, "13345678914", new Date());
        User user3 = new User("王五", 55, "13345678915", new Date());
        User user4 = new User("李六", 55, "13345678916", new Date());

        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

--->4.1.1:  (1对1关系) 分组: 用户名-> 用户实体类对象User(String->T)

Map<String, User> map1 = list.stream().collect(Collectors.toMap(User::getUsername, each -> each, (value1, value2) -> value1));
        System.out.println(JSON.toJSONString(map1));

 //{"李四":{"age":44,"createTime":1679536527360,"telephone":"13345678914","username":"李四"},"张三":{"age":33,"createTime":1679536527360,"telephone":"13345678913","username":"张三"},"李六":{"age":55,"createTime":1679536527360,"telephone":"13345678916","username":"李六"},"王五":{"age":55,"createTime":1679536527360,"telephone":"13345678915","username":"王五"}}

 --->4.1.2  (1对1关系) 用户名 -> 电话号(String-> String)

  Map<String,String> map2 =  list.stream().collect(Collectors.toMap(User::getUsername,User::getTelephone,(value1, value2) -> value1));
        System.out.println(JSON.toJSONString(map2));
//{"李四":"13345678914","张三":"13345678913","李六":"13345678916","王五":"13345678915"}

--->4.1.301:  (1对多) 分组01: 根据年龄分组  Integer-> List<T> 

Map<Integer, List<User>> map301 = list.stream().collect(Collectors.groupingBy(User::getAge));
        System.out.println(JSON.toJSONString(map301));
//{33:[{"age":33,"createTime":1679536527360,"telephone":"13345678913","username":"张三"}],55:[{"age":55,"createTime":1679536527360,"telephone":"13345678915","username":"王五"},{"age":55,"createTime":1679536527360,"telephone":"13345678916","username":"李六"}],44:[{"age":44,"createTime":1679536527360,"telephone":"13345678914","username":"李四"}]}

--->4.1.302:  (1对多) 分组01: 根据年龄分组  Integer-> List<T> 方法二

Map<Integer,List<User>> map302 =  list.stream().collect(Collectors.toMap(User::getAge, Collections::singletonList,(value1, value2) -> {
            List<User> union = new ArrayList<>(value1);
            union.addAll(value2);
            return union;
        }));
        System.out.println(JSON.toJSONString(map302));
//{33:[{"age":33,"createTime":1679536527360,"telephone":"13345678913","username":"张三"}],55:[{"age":55,"createTime":1679536527360,"telephone":"13345678915","username":"王五"},{"age":55,"createTime":1679536527360,"telephone":"13345678916","username":"李六"}],44:[{"age":44,"createTime":1679536527360,"telephone":"13345678914","username":"李四"}]}

--->4.1.4:  (1对多) 分组 根据年龄分出 年龄-> 用户 Integer -> List<String>

业务: 想查看每个年龄下都有谁(姓名即可)

Map<Integer,List<String>> map4 = list.stream().collect(Collectors.toMap(User::getAge,each->Collections.singletonList(each.getUsername()),(value1, value2) -> {
            List<String> usernameList = new ArrayList<>(value1);
            usernameList.addAll(value2);
            return usernameList;
        }));
        System.out.println(JSON.toJSONString(map4));
//{33:["张三"],55:["王五","李六"],44:["李四"]}

---> 4.1.5 根据时间排序

倒序方式

userOnlineList.stream().sorted(Comparator.comparing(SysUserOnline::getLoginTime).reversed()).collect(Collectors.toList());

正序方式

userOnlineList.stream().sorted(Comparator.comparing(SysUserOnline::getLoginTime)).collect(Collectors.toList());

-> 4.2 没有实体类的进阶操作

[待续未完....时间有限]

-> 5. 总结: 4整个的main方法

-> 5..1 不啰嗦 直接上代码

 public static void main(String[] args) {

        //1. 创建基础数据
        List<User> list = new ArrayList<>();
        User user1 = new User("张三", 33, "13345678913", new Date());
        User user2 = new User("李四", 44, "13345678914", new Date());
        User user3 = new User("王五", 55, "13345678915", new Date());
        User user4 = new User("李六", 55, "13345678916", new Date());

        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        /*1. (1对1关系) 分组:  用户名-> 用户实体类对象User*/
        Map<String, User> map1 = list.stream().collect(Collectors.toMap(User::getUsername, each -> each, (value1, value2) -> value1));
        System.out.println(JSON.toJSONString(map1));
        //{"李四":{"age":44,"createTime":1679536527360,"telephone":"13345678914","username":"李四"},"张三":{"age":33,"createTime":1679536527360,"telephone":"13345678913","username":"张三"},"李六":{"age":55,"createTime":1679536527360,"telephone":"13345678916","username":"李六"},"王五":{"age":55,"createTime":1679536527360,"telephone":"13345678915","username":"王五"}}

        /*2. (1对1关系) 用户名 -> 电话号 */
        Map<String,String> map2 =  list.stream().collect(Collectors.toMap(User::getUsername,User::getTelephone,(value1, value2) -> value1));
        System.out.println(JSON.toJSONString(map2));
        //{"李四":"13345678914","张三":"13345678913","李六":"13345678916","王五":"13345678915"}

        /*301. (1对多关系) 分组01:  根据年龄分组  目的: 将年龄相等的进行分组 年龄->用户实体类 */
        Map<Integer, List<User>> map301 = list.stream().collect(Collectors.groupingBy(User::getAge));
        System.out.println(JSON.toJSONString(map301));
        //{33:[{"age":33,"createTime":1679536527360,"telephone":"13345678913","username":"张三"}],55:[{"age":55,"createTime":1679536527360,"telephone":"13345678915","username":"王五"},{"age":55,"createTime":1679536527360,"telephone":"13345678916","username":"李六"}],44:[{"age":44,"createTime":1679536527360,"telephone":"13345678914","username":"李四"}]}

        /*302. (1对多关系) 分组02:  根据年龄分组  目的: 将年龄相等的进行分组 年龄->用户实体类 */
        Map<Integer,List<User>> map302 =  list.stream().collect(Collectors.toMap(User::getAge, Collections::singletonList,(value1, value2) -> {
            List<User> union = new ArrayList<>(value1);
            union.addAll(value2);
            return union;
        }));
        System.out.println(JSON.toJSONString(map302));
        //{33:[{"age":33,"createTime":1679536527360,"telephone":"13345678913","username":"张三"}],55:[{"age":55,"createTime":1679536527360,"telephone":"13345678915","username":"王五"},{"age":55,"createTime":1679536527360,"telephone":"13345678916","username":"李六"}],44:[{"age":44,"createTime":1679536527360,"telephone":"13345678914","username":"李四"}]}

        /*4. (1对多关系) 分组 根据年龄分出 年龄-> 用户 业务: 想查看每个年龄下都有谁(姓名即可)*/
        Map<Integer,List<String>> map4 = list.stream().collect(Collectors.toMap(User::getAge,each->Collections.singletonList(each.getUsername()),(value1, value2) -> {
            List<String> usernameList = new ArrayList<>(value1);
            usernameList.addAll(value2);
            return usernameList;
        }));
        System.out.println(JSON.toJSONString(map4));
        //{33:["张三"],55:["王五","李六"],44:["李四"]}


    }

创作不易, 点个赞再走呗~~~

pingzhuyan
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
49天精通Java，第42天，java stream流详解，从集合遍历，看stream流操作
学Java，找哪吒
07-18 796
Java Stream 是 Java 8 引入的一个新特性，它提供了一个基于流的编程模型，可以让开发者以声明性和可组合的方式操作数据。例如，如果有一个非常大的数据流，可以使用skip()方法来跳过前几百万个元素，而不会将整个流加载到内存中。6、可以用Collection接口的stream方法将任何集合转为一个流，如何是一个数组，可以通过静态的Stream.of方法，将其转为流。Stream流提供并行计算的功能，可以将操作并行化，充分利用多核处理器的优势，提高计算速度和效率。
使用stream().filter()过滤List对象
xisheng_lx的博客
11-19 1万+
使用Java8或更高版本，使用stream().filter()来过滤一个List对象，查找符合条件的对象集合。 例子1：过滤要求，我们需要寻找年龄大于等于15的年轻人。 List<StudentInfo> lsYoungStudent = lsStudentData.stream().filter(a -> a.getAge() >= 15).collect(Collectors.toList()); 例子2：查找身高在1.8米及以上的男生 List<StudentIn
List stream 过滤
qq_43625640的博客
04-29 9512
List<XXXDO> list = this.baseMapper.listXXX(ids); //list 根据对象属性 过滤 List<XXXDO> addList = list.stream().filter(s -> "XX".equals(s.getId)).collect(Collectors.toList()); //获取某一个属性的 list List<String> strList= list.stream().map(XXXDO::getI
java8 List的Stream流操作 (实用篇 三)
最新发布
DJyzh的博客
06-17 1877
1、Stream筛选单元素、范围、多条件 2、Stream去重(distinct、concat、set、map) 3、Stream拼接（joining） 4、Stream分组即组装成map(groupingBy、toMap) groupingBy分组 toMap分组 5、Stream排序compareTo、Comparator.comparing() 6、Stream统计（count、sum、max、min、average） 7、Stream分页（skip、limit）
stream流对List进行过滤
chaosssock的博客
03-06 1313
【代码】stream流对List进行过滤。
lamda过滤_List集合的过滤之lambda表达式
weixin_40002009的博客
12-21 710
下面代码 是过滤List中的对象，->后面为条件，满足条件的才会放入List中java 8 中lambda表达式写法public static void filter(List stmtList) {stmtList = stmtList.stream().filter(stmt -> !(stmt instanceof OracleInsertStatement) &&amp...
JAVA语言-利用java8 stream().filter()过滤List对象（查找符合条件的对象集合）
热门推荐
西京刀客
11-12 2万+
Java8 使用 stream().filter()过滤List对象（查找符合条件的对象集合） 在Java8及以上版本中，使用stream().filter()来过滤一个List对象，查找符合条件的对象集合。 使用filter()过滤List //查找身高在1.8米及以上的男生 List<StudentInfo> boys = studentList.stream().filter(s->s.getGender() && s.getHeight() >= 1.8).c
Stream进阶
weixin_41563161的博客
11-11 420
Stream 1. 流式处理简介 比如我们希望对一个包含整数的集合中筛选出所有的偶数，并将其封装成为一个新的List返回，那么在java8之前，我们需要通过如下代码实现： List<Integer> evens = new ArrayList<>(); for (final Integer num : nums) { if (num % 2 == 0) { evens.add(num); } } 通过java8的流式处理，我们可以将代码简化为： Li
java 1.8 map lambda_Java进阶篇之十五 ----- JDK1.8的Lambda、Stream和日期的使用详解(很详细)...
weixin_33582311的博客
02-24 681
前言本篇主要讲述是Java中JDK1.8的一些新语法特性使用，主要是Lambda、Stream和LocalDate日期的一些使用讲解。LambdaLambda介绍Lambda 表达式(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda...
多线程高并发,这一篇你就进阶了
hotcsawp的博客
05-17 1183
多线程高并发等工具类，从源码理解原理
[Java语言程序设计-进阶篇(原书第8版)](高清）
03-01
- **Stream API**：基于Lambda表达式的流式数据处理框架，支持过滤、映射、聚合等操作。 ### 总结 以上内容涵盖了Java进阶篇中的几个重要知识点，包括集合框架、异常处理、输入/输出流、多线程编程、泛型与反射...
java list 过滤
08-05
NULL 博文链接：https://houlc.iteye.com/blog/2020481
list.stream().filter()过滤
erose的博客
08-06 1万+
文章转载自不忘初心，砥砺前行 内容简介 本文主要说明在Java8及以上版本中，使用stream().filter()来过滤一个List对象，查找符合条件的对象集合。 List对象类（StudentInfo） StudentInfo对象类 测试数据 //测试数据，请不要纠结数据的严谨性 List<StudentInfo> studentList = new ArrayList<>(); studentList.add(new StudentInfo("李小明",true,18,1.76
stream流操作：list过滤
你个无聊小demo的博客
04-27 3381
list过滤；stream使用
Java lambda Stream List过滤筛选、排序、分组（Java进阶）
y393016244的博客
03-15 1万+
重要！重要！重要！用起来很方便，舍弃for循环查找符合的对象 返回集合 在List中筛选出Map中“jzqklx”的值等于“abc”的Map，返回List集合 d为dayFwsl集合中的Map对象 List中可以是任意对象，如List判断条件可以.fiter(d->StringUtils.equals(d.getType(), “01”)) List<Map<String, Object>> dayFwsl = new ArrayList<>(); Lis.
Java小知识：使用Lambda表达式，过滤List集合
危险、的博客
09-14 2151
小知识上代码： List<SpImg> collect = spImgList().stream().filter(spImg -> "1".equals(spImg.getIsCover())).collect(Collectors.toList()); 以上代码就是过滤spImgList集合，IsCover字段等于1的spImg数据。
JAVA之List过滤
風林火山zyw的博客
11-27 9223
JAVA之List过滤
lamda表达式对List进行分组，List按条件过滤
qq_40813329的博客
08-30 1万+
示例对象 private Integer id; private String name; private BigDecimal money; private Integer num; public Apple(Integer id, String name, BigDecimal money, Integer num) { this.id = id; this.name = name; this.money = mon
List对象过滤
u013449407的博客
08-12 252
List materialInventoryList = materialInventories.stream().filter(mat -> mat.getQty().compareTo(BigDecimal.ZERO) > 0).collect(Collectors.toList()); stream().filter()方法可以过滤掉List的数据
对一个List<String>,使用lambda表达式和Stream完成过滤操作
05-20
可以使用`filter()`方法进行过滤操作。例如，假设我们有一个`List<String>`类型的列表，名为`stringList`，我们想要过滤出其中所有包含字母"a"的字符串，可以使用以下代码： ``` List<String> filteredList = stringList.stream() .filter(str -> str.contains("a")) .collect(Collectors.toList()); ``` 这里使用了`stream()`方法将列表转换为流，然后使用`filter()`方法过滤出符合条件的元素，最后使用`collect()`方法将流转换为一个新的列表。在`filter()`方法中，使用Lambda表达式`str -> str.contains("a")`表示对于每个元素`str`，只有当其包含字母"a"时才会被保留下来。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

pingzhuyan

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

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

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

打赏作者

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

抵扣说明：

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

余额充值