栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

不会吧不会吧 JDK8已经10年了 你连Stream流都不知道怎么用? 常用的Stream流操作 方法

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

不会吧不会吧 JDK8已经10年了 你连Stream流都不知道怎么用? 常用的Stream流操作 方法

原文地址

BY Jason

文章目录
  • 原文地址
  • Stream流
  • Stream创建集合
    • 普通List创建集合
    • Arrays创建集合
    • Stream创建集合
  • Stream流转集合(collect)
    • List转Map
    • Map转List
    • groupingBy分组
  • Stream遍历(map、peek、forEach)
    • map
    • peek
    • forEach【迭代器】
    • 总结
  • Stream过滤(filter)
  • Stream排序(sort)
  • Stream使用案例
    • 菜单转树形结构
    • 集合泛型类型转换

Stream流

Java18都发布了,8也发布了十年了,你不会还在用for循环遍历集合吧?

本篇文章将对Stream流常用的方法进行介绍,主要为遍历(map,peek)、过滤(filter)、排序(sort)、集合转换(collect)。

Stream流map方法、Stream流排序、Stream流map和peek的区别、Stream流过滤filter…

    private static List getUserList() {
        User reba = User.builder().age(26).name("迪丽热巴").build();
        User nazha = User.builder().age(26).name("古力娜扎").build();
        User feng = User.builder().age(65).name("罗玉凤").build();

        // stream快速创建集合 .collect()
        List list = Stream.of(reba, nazha, feng).collect(Collectors.toList());
        Set set = Stream.of(reba, nazha, feng).collect(Collectors.toSet());
        return list;
    }
Stream创建集合 普通List创建集合
List userList = new ArrayList<>();
userList.add(reba);
userList.add(nazha);
userList.add(feng);
Arrays创建集合
// 本质是将一个数组转成list,数组的大小是固定的,所以此list不能添加元素
// 如果调用add方法增加新的元素,会报异常:java.lang.UnsupportedOperationException
List userList = Arrays.asList(reba, nazha, feng);
Stream创建集合
// stream流,创建的是动态数组,可以添加元素
List userList = Stream.of(reba, nazha, feng).collect(Collectors.toList());
Stream流转集合(collect) List转Map

用Collectors的toMap方法转换List,一般会遇到两个问题:

a. 转换map,key重复问题:

代码中使用(key1,key2)->key2表达式可以解决此类问题,如果出现重复的key就使用key2覆盖前面的key1,也可以定义成(key1,key2)->key1,保留key1,根据自己的业务场景来调整。

b. 空指针异常,即转为map的value是null。这个可以先用filter过滤;

		// stream list转map
        Map userMap = list.stream()
                .collect(Collectors.toMap(
                        // map key的值
                        User::getName,
                        // map value的值
                        user -> user,
                        // key重复保留后面的key
                        (key1, key2) -> key2)
                );
Map转List

本质就是遍历产生新集合

 		// map转list
        List collect = userMap.entrySet().stream()
            .map(Map.Entry::getValue)
            .collect(Collectors.toList());
groupingBy分组

总结:流的返回结果固定是Map,key为分组的值,valve为分组后流的输出结果,分组只能在collect中使用。

		Map> collect1 = list.stream()
            	// 按照年龄分组,分组后的流转List集合
                .collect(Collectors.groupingBy(User::getAge, Collectors.toList()));
Stream遍历(map、peek、forEach) map

总结:map可以返回一个新元素类型的流,可以改变原来集合流的泛型类型,可以在需要改变泛型类型的时候使用。

        List collect = userList.stream()
                // map遍历后可以改变集合的泛型类型
                // 直接返回转换后的对象即可
                .map(user -> Woman.builder()
                        .username(user.getName())
                        .age(user.getAge())
                        .build())
                .collect(Collectors.toList());
peek

总结:peek只能返回一个当前元素类型的流,不能改变原集合流的泛型类型。

		List girlList = userList.stream()
                // 无返回值:不改变集合泛型类型
                .peek(user -> {
                    user.setSex("女");
                })
                .collect(Collectors.toList());
forEach【迭代器】

总结:跟peek相似,foreach同样不能改变集合泛型类型,也不会继续返回stream流,不建议使用,直接【集合.foreach】即可,本质都是迭代器,foreach后就不是流了。

        // ========== 不建议使用 =====================
        userList.stream().forEach(
                user -> {
                    user.setSex("女");
                }
        );// 不会继续返回流,不能再对流进行操作。
        // ========== 使用此方法遍历集合 ==============
        userList.forEach(
                user -> user.setSex("女")
        );
总结
  • 需要改变原集合泛型类型时,使用map;

  • 不需要改变原集合泛型类型,并且还需要继续流操作时,使用peek;

  • 不需要改变原集合泛型类型,并且不需要流操作时,直接使用迭代器forEach;

Stream过滤(filter)

总结:lambda断言函数接口。返回值为true,则保留元素;返回值为false,移除掉元素。

		List users = userList.stream()
                // 返回年龄小于60的用户
                .filter(user -> user.getAge() < 60)
                .collect(Collectors.toList());
Stream排序(sort)

总结:比较函数接口 o1代表o2前一个元素,大于0(1)交换两元素位置,即:【o1 - o2:升序】 【o2 - o1:降序】

完整lambda写法:升序

        List collect = userList.stream()
                // 完整lambda表达式写法 按照年龄升序(o1 - o2) 
                .sorted(((o1, o2) -> {
                    return o1.getAge() - o2.getAge();
                })).collect(Collectors.toList());

省略lambda写法:降序

        collect = userList.stream()
                // 省略lambda表达式写法 按照年龄降序(o2 - o1)
                .sorted((o1, o2) ->  o2.getAge() - o1.getAge())
                .collect(Collectors.toList());

升序简便写法:

        collect = userList.stream()
                // 升序简便写法(返回需要按照升序排序的树形值即可)
                .sorted((Comparator.comparingInt(User::getAge)))
                .collect(Collectors.toList());
Stream使用案例 菜单转树形结构

可以通过Stream流操作、递归操作,将数据库查询出的菜单集合转树形结构。

	
    private List menusToTree(List entities) {
        // 组装成父子的树形结构
        return menuDTOS.stream()
                .filter(menu ->
                        // 获取一级菜单
                        menu.getParentId() == 0
                )
                // 遍历封装子菜单
                .peek(menu -> {
                    // 获取子菜单
                    menu.setChildren(getChildren(menu, menuDTOS));
                })
                // 一级菜单升序排序 sort越大越靠后
                .sorted(Comparator.comparingInt(MenuDTO::getSort))
                .collect(Collectors.toList());
    }

	
    private List getChildren(MenuDTO root, List all) {
        return all.stream()
                .filter(menu -> {
                    // 筛选出子菜单(父菜单ID = 子菜单父ID)
                    return menu.getParentId().equals(root.getId());
                })
                .peek(menu -> {
                    // 递归筛选子菜单
                    menu.setChildren(getChildren(menu, all));
                })
                // return 1-2,升序   return 2-1 降序 (结果为正交换位置)
                .sorted((menu1, menu2) -> {
                    return menu1.getSort() - menu2.getSort();
                }).collect(Collectors.toList());
    }
集合泛型类型转换
package com.feizhaiyou.blog.common.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;


@Slf4j
public class BeanHelper {

    
    public static  T copyProperties(Object source, Class target) {
        try {
            T t = target.newInstance();
            BeanUtils.copyProperties(source, t);
            return t;
        } catch (InstantiationException e) {
            throw new RuntimeException(target.getName() + "无法被实例化,可能是一个接口或抽象类");
        } catch (IllegalAccessException e) {
            throw new RuntimeException(target.getName() + "无法被实例化,构造函数无法访问");
        }
    }

    
    public static  List copyWithCollection(List sourceList, Class target) {
        return sourceList.stream()
            // 遍历集合返回新类型对象
            .map(s -> copyProperties(s, target))
            .collect(Collectors.toList());
    }

    
    public static  Set copyWithCollection(Set sourceList, Class target) {
        return sourceList.stream().map(s -> copyProperties(s, target)).collect(Collectors.toSet());
    }
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/980922.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号