Lambda-流基本操作

        //filter 简单使用 过滤掉不符合断言的数据
        userMapper.getListPage(paramMap).stream()
                .filter(s ->"aa".equals(s.getFarmId()))
                .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                ));

        //map 简单使用  将  List<UserBean> 转换为 Sting 元素
        ///将一个元素转换为另一个元素
        userMapper.getListPage(paramMap).stream()
                .map(s -> s.getName())
                .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                ));

        //flatMap 简单使用  将 UserBean 转换为 Sting 元素流  将对象转换为流
        ///将一个元素转换为另一个元素的流
        userMapper.getListPage(paramMap).stream()
                    .flatMap(s -> Arrays.stream(
                            s.getName().split(""))
                    )
                    .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                    ));

        //peek操作  对流元素进行遍历操作  peek操作与foreach操作交替进行  因为peek是无状态的
        userMapper.getListPage(paramMap).stream()
                .peek(s -> System.out.print(s.getName()))
                .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                ));

        //sort操作  先执行peek之后才能执行foreach操作
        userMapper.getListPage(paramMap).stream()
                .peek(s -> System.out.print(s.getName()))
                .sorted(Comparator.comparing(UserBean :: getName))
                .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                ));

        //distinct操作  对元数进行去除 先执行peek之后才能执行foreach操作
        userMapper.getListPage(paramMap).stream()
                .peek(s -> System.out.print(s.getName()))
                .map(s -> s.getName())
                .distinct()
                .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                ));

        //skip操作  过滤跳过前几个数据
        userMapper.getListPage(paramMap).stream()
                .sorted(Comparator.comparing(UserBean :: getName))
                .skip(3)
                .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                ));

        //limit操作  只取前几个数据 有状态操作
        userMapper.getListPage(paramMap).stream()
                .sorted(Comparator.comparing(UserBean :: getName))
                .limit(3)
                .forEach(item -> System.out.print(
                        JSON.toJSONString(item,true)
                ));

        //allMatch 终端操作   所有元素匹配  返回TRUE  短路操作(一次消费 一个没消费就直接返回)
        userMapper.getListPage(paramMap).stream()
                .peek(s -> s.getName())
                .allMatch(s -> s.getName().equals("king"));

        //anyMatch 终端操作  任何元素匹配 返回TRUE   短路操作(只要消费 立即返回)
        userMapper.getListPage(paramMap).stream()
                .peek(s -> s.getName())
                .anyMatch(s -> s.getName().equals("king"));

        //noneMatch 终端操作 配合元素都不匹配 返回TRUE 短路操作(返回所有不符合要求的元素)
        userMapper.getListPage(paramMap).stream()
                .peek(s -> s.getName())
                .noneMatch(s -> s.getName().equals("king"));

        //findFirst 终端操作 找到第一个匹配元素 返回TRUE 短路操作
       Optional<UserBean> test1 = userMapper.getListPage(paramMap).stream()
                .peek(s -> s.getName())
                .findFirst();

        //findAny 终端操作 找到任何一个只要有就返回 返回TRUE 短路操作(
        Optional<UserBean> test2 = userMapper.getListPage(paramMap).stream()
                .peek(s -> s.getName())
                .findAny();

      
        //max 终端操作 返回最大值  非短路
         userMapper.getListPage(paramMap).stream()
                .mapToDouble(UserBean :: getAge())
                .max();

        //min 终端操作 返回最小值  非短路
         userMapper.getListPage(paramMap).stream()
                .mapToDouble(UserBean :: getAge())
                .min();

        //min 终端操作  查询个数 非短路
        long test5 = userMapper.getListPage(paramMap).stream().count();



        //流的创建四种形式
        //由值创建流    Stream.of(value)
       Stream stream = Stream.of(1,2,3,4,5);
        stream.forEach(System.out :: println);

        //由数组创建流    Arrays.stream(数组)
        int[] numbers = {1,2,3,4,5};
        IntStream intStream = Arrays.stream(numbers);
        stream.forEach(System.out :: println);

        //由文件创建流    Files.lines
        try {
            Stream<String> stringStream = Files.lines(Paths.get("C:/test.txt"));
            stream.forEach(System.out :: println);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //由函数生成流 注意流是无限流 注意限制
        stream = Stream.iterate(0,n -> n+2);
        stream = Stream.generate(Math::random);


    //常见收集器使用
        //返回List集合 集合收集器
       List<UserBean>  list = userMapper.getListPage(paramMap).stream()
                .filter(s ->"aa".equals(s.getFarmId()))
                .collect(Collectors.toList());

        //返回  按条件分组进行集合收集
        Map<Object,List<UserBean>>  listt = userMapper.getListPage(paramMap).stream()
                .collect(Collectors.groupingBy(UserBean :: getName));

        //返回  按条件分区进行集合收集 满足及不满足的集合
        Map<Boolean,List<UserBean>>  listtt = userMapper.getListPage(paramMap).stream()
                .collect(Collectors.partitioningBy(s -> s.getName().equals("king")));


       // reduce  初始化 计算逻辑 并行计算逻辑  .paraduce.reduce 启动并行计算逻辑

        //collect  汇总

        //判断map是否含有某个key          paramMap.containsKey()