jdk1.8中stream流式编程filter、map、collect、sort、foreach

╰半夏微凉° 2022-10-23 08:26 211阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70]

Stream流中map方法
    
    使用Stream流时发现其中的map方法使用有一些不太容易理解的地方，分析一下具体的流程，以一个小案例详细探讨Stream中map的使用。
    案例涉及：
    1、Stream中of方法传入可变参数
    2、Stream中map元素类型转化方法
    3、Function匿名接口，people匿名对象的使用
    4、String中split切割方法
    5、Lambda表达式
    匿名对象也可以使用Lambda替换，达到精简的效果，因为了便于理解只在forEach遍历下使用了Lambda表达式）。
    
    以下是程序：
    
    public class Demo { 
        public static void main(String[] args) { 
            Stream.of("小王:18","小杨:20").map(new Function<String, People>() { 
                @Override
                public People apply(String s) { 
                    String[] str = s.split(":");
                    People people = new People(str[0],Integer.valueOf(str[1]));
                    return people;
                }
            }).forEach(people-> System.out.println("people = " + people));
        }
    }
    程序分析：
    
    public class Demo { 
        public static void main(String[] args) { 
            Stream.of("小王:18","小杨:20")//使用Stream中的of方法传入两个字符串
                    .map(new Function<String, People>() { 
                        /*调用Stream中的map方法，使用匿名接口Function， 需要重写Function中的抽象方法apply，apply方法需要传入两个数据， 前一个为转化前的String类型，后一个为转化后的对象类型*/
                @Override
                public People apply(String s) { //传入要转变的参数
                    String[] str = s.split(":");
                    //调用String中的split方法，以：切割，定义一个字符串接收切割后的字符串数据
                    People people = new People(str[0],Integer.valueOf(str[1]));//对象家接收匿名对象切割后的元素。数组索引0为字符串，数组索引1为数字
                    return people;//返回people类型对象
                }
            }).forEach(people-> System.out.println("people = " + people));
            //使用Stream中的forEach遍历People中的对象，使用了Lambda方式，重写了方法遍历输出
        }
    }
    
    使用的People类：
    
    public class People { 
        private String name;
        private int age;
    
        public People(String name, int age) { 
            this.name = name;
            this.age = age;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "People{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    Stream流中的map方法可以将字符串转换为对象接收，使代码的灵活性更高，Lambda表达式的简洁效果让开发者的效率升高，虽然Lambda在可读性方面不太便捷，对于经常使用的人来说也是十分方便。
    参考： [https://blog.csdn.net/weixin_45531950/article/details/99664197](https://blog.csdn.net/weixin_45531950/article/details/99664197)

/** * * @param root 当前菜单 * @param all 所有集合 * @return */
        //递归查找所有菜单的子菜单
        private List<CategoryEntity> getChildrens(CategoryEntity root,List<CategoryEntity> all){ 
    
            List<CategoryEntity> children = all.stream().filter(categoryEntity -> { 
                return categoryEntity.getParentCid() == root.getCatId();
            }).map(categoryEntity -> { 
                //1、找到子菜单
                categoryEntity.setChildren(getChildrens(categoryEntity,all));
                return categoryEntity;
            }).sorted((menu1,menu2)->{ 
                //2、菜单的排序
                return (menu1.getSort()==null?0:menu1.getSort()) - (menu2.getSort()==null?0:menu2.getSort());
            }).collect(Collectors.toList());
    
            return children;
        }

/** * 获取商品分类的属性结构 * @return */
        @Override
        public List<CategoryEntity> listWithTree() { 
            //1、查出所有分类 查询所有没有条件，则传入null值
            List<CategoryEntity> entities = baseMapper.selectList(null);
    
            //2、组装成父子的树形结构
    
    // entities
    // .stream()
    // .filter(categoryEntity -> categoryEntity.getParentCid() == 0) //把boolen为true的放行
    // .map((menu) -> { 
    // menu.setChildren(getChildrens(menu,entities));
    // return menu;
    // })
    // .sorted((menu1,menu2) ->{ //排序返回的是一个int类型的数据
    // return (menu1.getSort()==null?0:menu1.getSort()) - (menu2.getSort()==null?0:menu2.getSort());
    // })
    // .collect(Collectors.toList());
    
    
            //2.1）、找到所有的一级分类
            List<CategoryEntity> level1Menus = entities.stream().filter(categoryEntity ->
                    categoryEntity.getParentCid() == 0
            ).map((menu)->{ 
                menu.setChildren(getChildrens(menu,entities));
                return menu;
            }).sorted((menu1,menu2)->{ 
                return (menu1.getSort()==null?0:menu1.getSort()) - (menu2.getSort()==null?0:menu2.getSort());
            }).collect(Collectors.toList());
            return level1Menus;
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zzandpbg_size_16_color_FFFFFF_t_70]: /images/20221023/6ab8778e3d824ef4ab4358cd46192315.png