package com.cnwy.j8;

import com.cnwy.modular.entity.student.service.Student;
import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class J {
    //Consumer(消费型)、supplier(供给型)、predicate(谓词型)、function(功能性)

    public static void main(String[] args) {

        Stream.of("1").forEach(getConsumer());
        //使用consumer接口实现方法
        dodo_consumer("222", new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o + "===");
            }
        });

        Double aDouble = dodo_supplier(1.0, new Supplier<Double>() {
            @Override
            public Double get() {
                return 8.0;
            }
        });
        System.out.println(aDouble);

        boolean b = dodo_predicate(2, new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 5;
            }
        });
        System.out.println(b);

        Integer id = dodo_function(new Student("jack", 1), new Function<Student, Integer>() {
            @Override
            public Integer apply(Student student) {
                return student.getId();
            }
        });
        System.out.println(id);

    }


    /***
     * Consumer接口是一个消费型的接口，只要实现它的accept方法，就能作为消费者来输出信息。
     * lambda、方法引用都可以是一个Consumer类型，因此他们可以作为forEach的参数，用来协助Stream输出信息。
     * Consumer还有很多变种，例如IntConsumer、DoubleConsumer与LongConsumer等，归根结底，
     * 这些变种其实只是指定了Consumer中的泛型而已，方法上并无变化。
     */
    private static Consumer<String> getConsumer() {
        return System.out::println;
    }

    private static void dodo_consumer(String aaa, Consumer<String> consumer) {
        consumer.accept(aaa);
    }


    /***
     * Supplier
     * Supplier是一个供给型的接口，我们可以无条件的从它这里获取东西。
     */
    private static void supplier() {
        Supplier<Double> supplier = new Supplier<Double>() {
            @Override
            public Double get() {
                return 9.0;
            }
        };
        System.out.println(supplier.get());
    }

    private static Double dodo_supplier(Double d, Supplier<Double> supplier) {
        return supplier.get() + d;
    }

    private static boolean predicate() {
        Predicate<Integer> predicate = i -> i > 5;
        return predicate.test(1);
    }

    private static boolean dodo_predicate(Integer i, Predicate<Integer> predicate) {
        return predicate.test(i);
    }



    /***
     * Function是一个转换型的接口，其中的apply可以将一种类型的数据转化成另外一种类型的数据。
     */
    public static void function() {
        Function<Student, Integer> function = new Function<Student, Integer>() {
            @Override
            public Integer apply(Student student) {
                return student.getId();
            }
        };
        Integer id = function.apply(new Student("jack", 1));
        System.out.println(id);
    }
    public static Integer dodo_function(Student student, Function<Student, Integer> function) {
        return function.apply(student);
    }


    @Data
    @AllArgsConstructor
    static class Student {
        private String name;
        private Integer id;
    }

}