Java8新特性（内置的核心函数式接口）

前言：

1.我们知道只要使用Lambda表达式，那么一定要有函数式接口的支持；但是如果我们没使用一个Lambda表达式都要自己创建一个接口，这样很造成很大的不便。于是java8的工程师们已经帮我们把常用的函数式接口都帮我们定义好，拿来直接使用即可。如果不能满足你的需求，那么这时你才需要自己定义函数式接口。下面是我们常用的函数式接口：

知识点一：消费性函数式接口

特点：

1.接受一个或者多个参数，没有返回值

典型函数式接口（常用）：

    1.Consumer<T>          void accept(T t);//接受一个泛型类型参数无返回    2.BiConsumer<T, U>        void accept(T t, U u);//接受两个泛型类型参数无返回    3.DoubleConsumer            void accept(double value);//接收double类型，无返回    4.IntConsumer        void accept(int value);//接收int类型，无返回    5.LongConsumer        void accept(long value);//接收long类型，无返回    6.ObjDoubleConsumer<T>        void accept(T t, double value);//接收两个参数，一个泛型，一个double    7.ObjIntConsumer<T>         void accept(T t, int value);//接收两个参数，一个泛型，一个int    8.ObjLongConsumer<T>        void accept(T t, long value);//接收两个参数，一个泛型，一个long

举例：这里使用Consumer举例，接收一个参数无返回值，其他的用法基本相同

//需求：消费给定的monkey,但是消费方式没有给定，需要具体消费的时候指定    @org.junit.Test    public void test1(){        //消费100，洗澡        consumerMonkey(100,(m) -> System.out.println("洗澡花费了100元"));        //消费200，吃饭        consumerMonkey(200,(m) -> System.out.println("洗澡花费了200元"));    }    /**     *  消费monkey，但是没有指定出使用什么方式消费     * */     *     public static void consumerMonkey(double money, Consumer<Double> policy){        policy.accept(money);    }

知识点二：供给型函数式接口

特点：

1.没有参数（无参），提供返回值

典型函数式接口（常用）:

1. Supplier<T>     T get(); //无参，返回泛型2. BooleanSupplier        boolean getAsBoolean(); //无参，返回boolean3. DoubleSupplier    double getAsDouble(); //无参，返回double4. LongSupplier    long getAsLong();   //无参，返回long

举例：以 Supplier 接收泛型类型为例，其他都基本一致

   @org.junit.Test    public void test2(){        // 返回给定的String类型        String s = get(() -> "Hello world !");        System.out.println(s); //打印hello world !        // 返回给定类型的 int 数据        int i = get(() -> 123);        System.out.println(i); //打印123    }    /**     *  获取给定类型的对象，在调用的时候指定类型     * */    public static <T> T get(Supplier<T> supplier){        return supplier.get();    }

知识点三：函数型函数式接口

特点：

1.接收一个或者多个参数，有返回值

典型函数式接口（常用）:

  1. Function<T, R>         R apply(T t); //接收一个泛型参数，返回一个泛型参数  2. BiFunction<T, U, R>        R apply(T t, U u);   //接收两个泛型参数，返回泛型参数  3. DoubleFunction<R>        R apply(double value);//接收一个double类型，返回一个泛型  4. DoubleToIntFunction        int applyAsInt(double value);  5. DoubleToLongFunction        long applyAsLong(double value);       6. IntFunction<R>         R apply(int value);  7. IntToDoubleFunction        double applyAsDouble(int value);  8. IntToLongFunction        long applyAsLong(int value);       9. LongFunction<R>             R apply(long value);  10.LongToDoubleFunction               double applyAsDouble(long value);    11.LongToIntFunction         int applyAsInt(long value);          12.ToDoubleBiFunction<T, U>         double applyAsDouble(T t, U u);       13.ToDoubleFunction<T>         double applyAsDouble(T value);  14.ToIntBiFunction<T, U>         int applyAsInt(T t, U u);        15.ToIntFunction<T>         int applyAsInt(T value);     16.ToLongBiFunction<T, U>          long applyAsLong(T t, U u);  17.ToLongFunction<T>         long applyAsLong(T value);                                                

举例：以 Function接收一个泛型类型，返回一个泛型类型为例，其他都基本一致

 @org.junit.Test    public void test3(){        //需求1：接收一个String，返回一个name等于给定String的Student对象        Student student = handleOperator("XiangYang", (t) -> new Student(t));        System.out.println(student); //打印：Student{name='XiangYang', age=0}        //需求二：就收一个String，返回List，并且list中包含传入的String        List list1 = handleOperator("XiangYang", (t) -> {            List list = new ArrayList<>();            list.add(t);            return list;        });        System.out.println(list1); //打印：[XiangYang]    }class Student{    private String name;    private int age;    public Student(String name, int age) {        this.name = name;        this.age = age;    }    public Student(String name) {        this.name = name;    }    public Student(int age) {        this.age = age;    }    public Student() {    }    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 "Student{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}

知识点四：断定性函数式接口

特点：

1.接收一个或者多个参数，返回一个boolean类型

常用的函数式接口：

1. Predicate<T>      boolean test(T t);2. BiPredicate<T, U>      boolean test(T t, U u);   3. DoublePredicate      boolean test(double value);4. IntPredicate      boolean test(int value);5. LongPredicate          boolean test(long value);    

举例：以 Predicate 为例

    @org.junit.Test    public void test4(){        //判断给定的整数是否大于50        boolean b = is(80, (n) -> n > 50);        System.out.println(b); //打印：true    }    public static <T>  boolean is(T t,Predicate<T> predicate){        return predicate.test(t);    }

总结：

    1.每一中类型都给出了泛型情况，可以传入任何类型；而对于常用的类型，都单独定义了接口；例如： int 、 long 、double