/*
       * BiPredicate<T, U> , 传递两个参数，返回一个boolean值
         */
        BiPredicate<Integer, Integer> biPredicate = (x, y) -> x > y;
        System.out.println(biPredicate.test(3 ,4));

        // BooleanSupplier 代表了 boolean 值结果的提供方
        int num = 4;
        System.out.println(getMsg(() -> (num % 3 == 0)));

        DoublePredicate doublePredicate = x -> (x + 1) > 4;
        System.out.println(doublePredicate.test(5));

        filterAppleRed(new ArrayList<>(), red -> red.getColor().equals("red"));

        /*
         * 接受一个参数处理，没有返回值
         */
        Consumer<String> consumer = System.out::println;
        consumer.accept("ddd");

        DoubleConsumer doubleConsumer = System.out::println;
        doubleConsumer.accept(3d);

        /*
         * 接受两个参数处理，没有返回值BiConsumer<T, U>
         */
        BiConsumer<Integer, Integer> biConsumer = (x, y) -> System.out.println(x + y);
        biConsumer.accept(1, 1);

        /*
         * 三个参数BiFunction<T, U, R>, 如参数是T, U 返回 R
         */
        BiFunction<String, Integer, Apple> biFunction = Apple::new;
        System.out.println(biFunction.apply("gao", 111));
        /*
         * 返回一个double类型
         */
        DoubleFunction<Double> doubleFunction = (x) -> { return x * 2;};
        System.out.println(doubleFunction.apply(3));

        /*
         * BinaryOperator 继承 BiFunction，然后三个参数类型一致
         */
        BinaryOperator<Integer> binaryOperator = Integer::sum;
        System.out.println(binaryOperator.apply(2, 4));


        BinaryOperator<Apple> appleBinaryOperator = BinaryOperator.maxBy(Comparator.comparing(Apple::getWeight));
        Apple apply = appleBinaryOperator.apply(new Apple("red", 1), new Apple("red", 2));
        System.out.println(apply);

        /*
         * double 输入连个参数返回一个参数，就是固定的dubbo;
         */
        DoubleBinaryOperator doubleBinaryOperator = (x, y) -> x + y;
        System.out.println(doubleBinaryOperator.applyAsDouble(1d, 2.1d));

        /*
         * 通过double返回int
         */
        DoubleToIntFunction doubleToIntFunction = x -> (int) x + 1;
        System.out.println(doubleToIntFunction.applyAsInt(3.1d));

        IntFunction<Integer> intFunction = x -> x * 4;
        System.out.println(intFunction.apply(3));

        /*
         * 通过double返回long
         */
        DoubleToLongFunction doubleToLongFunction = s -> (long)s + 3;
        System.out.println(doubleToLongFunction.applyAsLong(333d));

        DoubleUnaryOperator doubleUnaryOperator = d -> d;
        System.out.println(doubleUnaryOperator.applyAsDouble(3d));


        IntBinaryOperator intBinaryOperator = (x, y) -> x+ y;
        intBinaryOperator.applyAsInt(1, 3);

        IntPredicate intPredicate = s -> (s + 1) > 4;
        System.out.println(intPredicate.test(3));

        IntToDoubleFunction intToDoubleFunction = s -> Double.parseDouble(String.valueOf(s));
        intToDoubleFunction.applyAsDouble(3);

        IntToLongFunction intToLongFunction = s -> (long) s;
        intToLongFunction.applyAsLong(4);

        IntUnaryOperator intUnaryOperator = s -> s + 1;
        intUnaryOperator.applyAsInt(3);

        LongBinaryOperator longBinaryOperator = (x, y) -> x + y;
        longBinaryOperator.applyAsLong(2L , 4L);

        LongConsumer longConsumer = s -> System.out.println(s);
        longConsumer.accept(3L);

        LongFunction<String> longFunction = String::valueOf;
        System.out.println(longFunction.apply(4));

        SayFunctionInterface sayFunctionInterface = (x ,y) -> System.out.println(x + y);
        sayFunctionInterface.accept("dd", 4);