Lambda入门

函数编程演化历程

1、将业务逻辑直接写死在代码里
2、将单一维度的条件作为参数传入方法中。方法内根据参数进行业务逻辑实现
3、将多个维度的条件作为参数传入方法中。业务实现根据不同的参数处理不同的逻辑
4、将业务逻辑封装为一个实体类，方法接受实体类为参数，方法内部调用实体类的处理逻辑
5、调用方法时不再创建实体类，而是使用匿名函数的形式替代
6、使用Lambda表达式替代匿名函数的形式，作为方法的参数。真正实现判断逻辑参数化传递

lambda ：
(params) -> expression
(params) -> {statement;}

/**
     * 过滤不符合断言判断的数据
     */
    public void filterTest() {
        list.stream().filter(sku -> "sku1".equals(sku.getCategory()))
                .forEach(sku -> System.out.println(sku.getCategory()));
    }

    /**
     * 将一个元素转换成另一个元素
     */
    public void mapTest() {
        list.stream()
                .map(sku -> sku.getPrice())
                .forEach(price -> System.out.println(price));
    }

    /**
     * 将一个对象转换成一个流
     */
    public void flatMapTest() {
        list.stream()
                .map(sku -> Arrays.stream(sku.getName().split("")))
                .forEach(name -> System.out.println(name));
    }

    /**
     * 对流进行遍历操作 不会销毁
     */
    public void peek() {
        list.stream()
                .peek(sku -> System.out.println(sku.getName()))
                .forEach(sku -> System.out.println(sku.getName()));
    }

    /**
     * 排序
     */
    public void sortTest() {
        list.stream()
                .peek(sku -> System.out.println(sku.getName()))
                .sorted(Comparator.comparing(Sku::getPrice).reversed())
                .forEach(sku -> System.out.println(sku.getName()));
    }

    /**
     * 去重
     */
    public void distinctTest() {
        list.stream()
                .map(sku -> sku.getCategory())
                .distinct()
                .forEach(item -> System.out.println(item));
    }

    /**
     * 跳过
     */
    public void skipTest() {
        list.stream()
                .peek(sku -> System.out.println(sku.getName()))
                .sorted(Comparator.comparing(Sku::getPrice).reversed())
                .skip(3)
                .forEach(sku -> System.out.println(sku.getName()));
    }

    /**
     * 限制
     */
    public void limitTest() {
        list.stream()
                .peek(sku -> System.out.println(sku.getName()))
                .sorted(Comparator.comparing(Sku::getPrice).reversed())
                .limit(3)
                .forEach(sku -> System.out.println(sku.getName()));
    }

    /**
     * 全部匹配
     */
    public void allMatchTest() {
        boolean match = list.stream().allMatch(sku -> sku.getPrice() > 100);
        System.out.println(match);
    }

    /**
     * 部分满足
     */
    public void anyMatchTest() {
        boolean match = list.stream().anyMatch(sku -> sku.getPrice() > 100);
        System.out.println(match);
    }

    /**
     * 都不匹配
     */
    public void noneMatchTest() {
        boolean match = list.stream().noneMatch(sku -> sku.getPrice() > 100);
        System.out.println(match);
    }

    /**
     * 找到第一个元素
     */
    public void findFirstTest() {
        Optional<Sku> optional = list.stream().findFirst();
        System.out.println(optional.get());
    }

    /**
     * 找到任何一个
     */
    public void findAnyTest() {
        Optional<Sku> optional = list.stream().findAny();
        System.out.println(optional.get());
    }

    /**
     * 最大值
     */
    public void maxTest() {
        OptionalDouble optionalDouble = list.stream().mapToDouble(Sku::getPrice).max();
        System.out.println(optionalDouble.getAsDouble());
    }

    /**
     * 数量
     */
    public void countTest() {
        long count = list.stream().count();
        System.out.println(count);
    }

/**
     * 由数值直接构建流
     */
    public void streamFromValue() {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.forEach(System.out::println);
    }

    /**
     * 通过数组构建流
     */
    public void streamFromArray() {
        int[] number = {1, 2, 3};
        IntStream stream = Arrays.stream(number);
        stream.forEach(System.out::println);
    }

    /**
     * 通过文件构建流
     * @throws IOException
     */
    public void streamFromFile() throws IOException {
        Stream<String> stream = Files.lines(Paths.get(""));
        stream.forEach(System.out::println);
    }

    /**
     * 通过函数生成流
     */
    public void streamFromFunction() {
        Stream<Integer> stream1 = Stream.iterate(0, n -> n + 1);
        stream1.limit(50).forEach(System.out::println);
        Stream<Double> stream = Stream.generate(Math::random);
        stream.limit(50).forEach(System.out::println);
    }

/**
     * 集合收集器
     */
    public void toList() {
        List<Sku> cartList = CartService.getCartList();
        List<Sku> collect = cartList.stream().filter(sku -> sku.getPrice() > 1000)
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    /**
     * 分组
     */
    public void group() {
        List<Sku> cartList = CartService.getCartList();
        // Map<分组条件， 结果集合>
        Map<String, List<Sku>> collect = cartList.stream().collect(
                Collectors.groupingBy(sku -> sku.getCategory())
        );
        System.out.println(collect);
    }

    /**
     * 分区
     */
    public void partition() {
        List<Sku> cartList = CartService.getCartList();
        Map<Boolean, List<Sku>> collect = cartList.stream().collect(Collectors.partitioningBy(sku -> sku.getPrice() > 100));

    }