lambda表达式学习整理

最新推荐文章于 2025-08-23 11:22:27 发布

原创最新推荐文章于 2025-08-23 11:22:27 发布 · 1.5k 阅读

17 ·

CC 4.0 BY-SA版权

lambda 同时被 2 个专栏收录

4 篇文章

订阅专栏

Java

3 篇文章

订阅专栏

前言

以下是自己学习lambda整理的笔记还在完善，如有更好的写法欢迎各位大佬在下方提出

代码注释我写的很清楚多看注释

1.List存储对象取id 和name转成Map 集合

 //创建集合存储user对象
        List<UserInfo> userInfoList = new ArrayList<>();
        UserInfo user = new UserInfo();
        user.setUserId(1L);
        user.setRealName("张三");
        userInfoList.add(user);
        Map<Long, String> map = 
                  //创建一个并行流
                  userInfoList.parallelStream()
                  //添加过滤条件        
                .filter(u -> u != null)
                  //返回一个Map集合key是userId  value是用户姓名    
                .collect(toMap(UserInfo::getUserId, UserInfo::getRealName));
        //遍历打印
         map.forEach((k,v)->{
             System.out.println("key:"+k+"  "+"value: "+v);
         });

2.List存储对象条件过滤遍历

  //创建集合存储user对象
        List<UserInfo> userInfoList = new ArrayList<>();
        UserInfo user = new UserInfo();
        user.setUserId(1L);
        user.setRealName("zs");
        userInfoList.add(user);
        UserInfo user2 = new UserInfo();
        user2.setUserId(2L);
        user2.setRealName("ls");
        userInfoList.add(user2);
        //判断集合是否为空
        Optional.ofNullable(userInfoList)
                //集合为空返回默认
                .orElseGet(ArrayList::new)
                //创建并行流 相当于多线程无序
                .parallelStream()
                //过滤名字不能为空
                .filter(u -> StringUtils.isNotBlank(u.getRealName()))
                //转成list集合
                .collect(Collectors.toList())
                //遍历
                .forEach(u->{
                    System.out.println(u.getRealName());
                });

3.List存放string数据转为大小写

List<String> strList = Arrays.asList("a", "b", "d", "s", "n", "a", "s", "c", "d", null);
        //创建并行流
        strList.parallelStream()
                //过滤 非空判断
                .filter(s-> StringUtils.isNotBlank(s))
                //转成大写    toLowerCase转为小写
                .map(String::toUpperCase)
                //遍历
                .forEach(System.out::println);

4.获取List数据得到一个以逗号分隔的字符串

List<String> strList = Arrays.asList("a", "b", "d", "s", "n", "a", "s", "c", "d", "b","");
        String str = strList.parallelStream()
                //过滤条件
                .filter(s -> StringUtils.isNotBlank(s))
                //以逗号分隔数据
                .collect(Collectors.joining(","));
        //打印
        System.out.println(str);

5.List去重

List<String> strList = Arrays.asList("a","b","d","s","n","a","s","c","d", "b");
//原来集合长度
System.out.println(strList.size());
// 返回一个去掉重复元素之后的新的lis
List<String> noRepeatList = strList.stream()
//去重
.distinct()
//转为新集合
.collect(Collectors.toList());
//新集合长度
System.out.println(noRepeatList.size());

6.List存储int数据查找最大值最小值

       //创建集合存放int数据
        List<Integer> ints = Stream.of(1,2,4,3,5).collect(Collectors.toList());
        //创建并行流
        int asInt = ints.parallelStream()
                //查找最大值
                .max(comparing(i->i))
                //返回最大值
                .get();
        //打印
        System.out.println(asInt);

       //创建集合存放int数据
        List<Integer> ints2 = Stream.of(1,2,4,3,5).collect(Collectors.toList());
        //创建并行流
        int asInt = ints2.parallelStream()
                //查找最小值
                .min(comparing(i->i))
                //返回最小值
                .get();
 		// 集合中最大长度
        List<String> strList = Arrays.asList("a", "b", "d", "s", "n", "yu", "luo", "shuai", "spot", "xhuai");
        int max = strList.stream()
                // 判断条件:长度
                .mapToInt(s -> s.length())
                // 获取判断条件的最大值
                .max()
                // 转成int长度
                .getAsInt();
        //打印最大长度
        System.out.println(max);
                strList.stream()
                //过滤条件 查找元素中的最大值
                .filter(s -> s.length() == max)
                 //转成list集合       
                .collect(Collectors.toList())
                 //遍历打印
                .forEach(s->{
                    System.out.println(s);
                });

        // 集合中最小长度
        List<String> strList2 = Arrays.asList("a", "b", "d", "s", "nd", "yu", "luo", "shuai");
        //创建顺序流
        int min = strList2.stream()
                //判断条件： 长度
                .mapToInt(s -> s.length())
                //获取最小长度
                .min().getAsInt();
        //打印最小长度
        System.out.println(min);

7.List集合获取int元素的平方

 List<Integer> list = Arrays.asList(1, 2, 6, 9);
        //创建一个串行流
        list.stream()
                //取每个元素的平方
                .map(s -> s * s).collect(Collectors.toList())
                //打印
                .forEach(System.out::println);

8.List返回特定结果

		//返回特定结果
        List<String> strList = Arrays.asList("a", "b", "c", "d", "e", "f");
        //创建串行流
        strList.stream()
                .skip(2) // 扔掉前面2个元素
                .limit(3) // 返回前3个元素
                //转换成集合
                .collect(Collectors.toList())
                //打印
                .forEach(System.out::println);

9.List对int类型数据进行排序

   List<Integer> ints = Arrays.asList(5,8,9,4,3,2,7,1,6,2);
        //创建顺序流
        ints.stream()
                //排序规则后面－前面倒序排序
                //排序规则前面－后面正序排序
                .sorted((ln1, ln2) -> (ln1 - ln2)) // 排序
                .distinct()//去除重复元素 可选可不选 不用这个方法重复元素并列
                //转换成集合
                .collect(Collectors.toList())
                //遍历
                .forEach(System.out::println);

10.List匹配规则

       /**
         * allMatch: Stream 中全部元素符合传入的predicate, 返回true
         * anyMatch: Stream 中只要有一个元素符合传入的predicate, 返回true
         * noneMatch: Stream 中没有一个元素符合传入的predicate, 返回true
         */
        List<String> strList = Arrays.asList("a", "b", "d", "s", "n", "a", "s", "c", "d", "b");
        // 判断集合中有没有c元素, 返回值boolean
        boolean isExits = strList.stream().anyMatch(s -> s.equals("c"));
        //打印 true
        System.out.println(isExits);
        List<String> strList2 = Arrays.asList("a", "b", "d", "s", "n", "a", "s", "c", "d", "");
        // 判断集合是否全不为空
        boolean isFull = strList2.stream().allMatch(s -> s.isEmpty());
        //打印false
        System.out.println(isFull);
        //Stream 中没有一个元素符合传入的predicate, 返回true
        boolean isNotEmpty = strList2.stream().noneMatch(s -> s.isEmpty());
        //打印false
        System.out.println(isNotEmpty);

11.List存储对象数据按条件进行分组

       //创建集合存储user对象
        List<UserInfo> userInfoList = new ArrayList<>();
        UserInfo user = new UserInfo();
        user.setUserId(5L);
        user.setRealName("zs");
        userInfoList.add(user);
        UserInfo user2 = new UserInfo();
        user2.setUserId(3L);
        user2.setRealName("ls");
        userInfoList.add(user2);
        //返回一个map
        Map<Long, List<UserInfo>> map = userInfoList.parallelStream()
                //过滤条件 名字不能为空
                .filter(s -> StringUtils.isNotBlank(s.getRealName()))
                //使用userId进行分组
                .collect(groupingBy(UserInfo::getUserId));
            //遍历打印
            map.forEach((k,v)->{
                System.out.println("key:"+k+"  "+"value："+v);
            });

12.流中的归约用法

 		//创建集合存储user对象
        List<UserInfo> userInfoList = new ArrayList<>();
        UserInfo user = new UserInfo();
        user.setUserId(5L);
        user.setRealName("zs");
        userInfoList.add(user);
        UserInfo user2 = new UserInfo();
        user2.setUserId(3L);
        user2.setRealName("ls");
        userInfoList.add(user2);
        //归约求和
        Optional<Long> reduce = userInfoList.stream()
                //过滤
                .filter(u -> StringUtils.isNotBlank(u.getRealName()))
                //提取userInfo的id
                .map(UserInfo::getUserId)
                //归约求和
                .reduce(Long::sum);
        System.out.println(reduce.get());
        //归约求最大值
        Optional<Long> reduce1 = userInfoList.stream()
                //提取
                .map(UserInfo::getUserId)
                //求最大值
                .reduce(Long::max);
        System.out.println(reduce1.get());
        //归约求最小值
        Optional<Long> reduce2 = userInfoList.stream()
                //提取
                .map(UserInfo::getUserId)
                //求最小值
                .reduce(Long::min);
        System.out.println(reduce2.get());
        //求平均值
        OptionalDouble average = userInfoList.stream()
                //提取
                .mapToLong(UserInfo::getUserId)
                //求平均值
                .average();
        System.out.println(average.getAsDouble());
  		//计数
        long count = userInfoList.stream()
                //提取
                .mapToLong(UserInfo::getUserId)
                //计数
                .count();
        //打印
        System.out.println(count);

13.Java8 summaryStatijstics配合流使用

 
//创建集合存储user对象
        List<UserInfo> userInfoList = new ArrayList<>();
        UserInfo user = new UserInfo();
        user.setUserId(5L);
        user.setRealName("zs");
        userInfoList.add(user);
        UserInfo user2 = new UserInfo();
        user2.setUserId(3L);
        user2.setRealName("ls");
        userInfoList.add(user2);
					//summaryStatijstics使用
LongSummaryStatistics summaryStatistics = userInfoList.stream()
    			//提取
                .mapToLong(UserInfo::getUserId)
                .summaryStatistics();
        //求最大值
        System.out.println("最大值："+summaryStatistics.getMax());
        //求最小值
        System.out.println("最小值："+summaryStatistics.getMin());
        //求和
        System.out.println("求和："+summaryStatistics.getSum());
        //计数
        System.out.println("计数："+summaryStatistics.getCount());
 		//求平均值
        System.out.println("平均值："+summaryStatistics.getAverage());

14.Java8字符串转字符

		//字符串转字符数组
        List<String> strList = Arrays.asList("a", "b", "d", "s", "n", "yu", "luo", "shuai", "spot", "xhuai");
       //创建集合存放character元素
        List<Character> newList = new ArrayList<>();
                        //转换为char数组流
        strList.stream().map(String::toCharArray)
                //遍历存放character元素
                .forEach(s->{
                    //遍历每个元素
                    for (char c : s) {
                        //存放
                        newList.add(c);
                    }
                });
        //打印
        newList.stream().forEach(System.out::println);
	 //第二种写法
	 strList.stream().map(String::toCharArray)
                //对转换的char[]数组整合
                .flatMapToInt(chars -> CharBuffer.wrap(chars).chars())
                //转换为char类型
                .mapToObj(e -> (char) e)
                //转为集合存储
                .collect(Collectors.toList())
                //遍历
                .forEach(System.out::println);

15.取List中的数据返回一个新对象集合

       //构造测试数据
        List<Student> list = new ArrayList<>();
        Student stu = new Student();
        stu.setId(1L);
        stu.setName("ZS");
        list.add(stu);
        Student stu2 = new Student();
        stu2.setId(2L);
        stu2.setName("ls");
        list.add(stu2);
        list.add(null);
        System.out.println(list);
         List<Person> perList = list.stream()
                    //过滤条件
                    .filter(Objects::nonNull)
                    //构造信息
                    .map(s -> {
                        Person person = new Person();
                        //重新赋值
                        person.setId(s.getId());
                        person.setAge(18);
                        person.setName(s.getName());
                        return person;
                    })
                    //返回新集合
                    .collect(Collectors.toList());
            //打印
            perList.forEach(System.out::println);

16.把对象转为流并进行操作

//构造测试数据
       //构造测试数据
        UserInfoVO postUserInfo = new UserInfoVO();
        postUserInfo.setUserId(143L);
        postUserInfo.setCreateUserId(153L);
        postUserInfo.setMobile("12345678910");
        //构造要返回的参数
        OrderMessageRequest newOrderMessageRequest = Stream.of(postUserInfo)
                    .map(u -> {
                        //过滤条件
                        if ((!u.getCreateUserId().equals(u.getUserId())) && StringUtils.isNotBlank(u.getMobile())) {
                            //构造发送短信需要的数据
                            OrderMessageRequest orderMessageRequest = new OrderMessageRequest();
                            // 获取驿站人员手机号
                            orderMessageRequest.setMobile(u.getMobile());
                            //是驿站人员
                            orderMessageRequest.setIsCourierStation("1");
                            System.out.println("驿站重新赋值成功");
                            return orderMessageRequest;
                        } 
                            //不是驿站人员给运营人员发短信
                            OrderMessageRequest orderMessageRequest =  new OrderMessageRequest();
                            //不是驿站人员
                            orderMessageRequest.setIsCourierStation("0");
                            System.out.println("运营重新赋值成功");
                            return orderMessageRequest;
                    })
                 	//返回任意一个元素   这里只有一个元素因为我们只有一个对象
                    .findAny()
                    //为空返回默认
                    .orElseGet(OrderMessageRequest::new);

17.提取list集合对象中的某列数据转为新集合

 List<UserLoginInfoVO> list = new ArrayList<>();
        UserLoginInfoVO userLoginInfoVO = new UserLoginInfoVO();
        userLoginInfoVO.setMobile("15655654654");
        userLoginInfoVO.setPushToken("textPushToken");
        list.add(userLoginInfoVO);
        UserLoginInfoVO userLoginInfoVO2 = new UserLoginInfoVO();
        userLoginInfoVO2.setMobile("12345678910");
        userLoginInfoVO2.setPushToken("textPushToken2");
        list.add(userLoginInfoVO2);
        UserLoginInfoVO userLoginInfoVO3 = new UserLoginInfoVO();
        userLoginInfoVO3.setMobile("123565645567");
        userLoginInfoVO3.setPushToken("textPushToken3");
        list.add(userLoginInfoVO3);
        list.stream()
                //过滤
                .filter(u -> u != null)
                //提取
                .map(UserLoginInfoVO::getMobile)
                //转为新集合
                .collect(Collectors.toList())
                //打印
                .forEach(System.out::println);

18.提取list中的数据转为数组

List<UserLoginInfoVO> list = new ArrayList<>();
        UserLoginInfoVO userLoginInfoVO = new UserLoginInfoVO();
        userLoginInfoVO.setMobile("15655654654");
        userLoginInfoVO.setPushToken("textPushToken");
        list.add(userLoginInfoVO);
        UserLoginInfoVO userLoginInfoVO2 = new UserLoginInfoVO();
        userLoginInfoVO2.setMobile("12345678910");
        userLoginInfoVO2.setPushToken("textPushToken2");
        list.add(userLoginInfoVO2);
        UserLoginInfoVO userLoginInfoVO3 = new UserLoginInfoVO();
        userLoginInfoVO3.setMobile("123565645567");
        userLoginInfoVO3.setPushToken("textPushToken3");
        list.add(userLoginInfoVO3);
        String[] arrays = list.stream()
                //提取
                .map(UserLoginInfoVO::getMobile)
                //转为string数组
                .toArray(String[]::new);
        //打印
        Stream.of(arrays).forEach(System.out::println);

19.partitioningBy 按某个条件分组

/按某个条件分组
//给一组年龄，分出成年和未成年
List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
    Map<Boolean, List<Integer>> ageMap = ageList.stream()
            .collect(Collectors.partitioningBy(age -> age > 18));
    System.out.println("未成年：" + ageMap.get(false));
    System.out.println("成年：" + ageMap.get(true));
    // 输出结果
// 未成年：[11, 13, 14]
// 成年：[22, 25, 26]