函数式接口

第一章函数式接口

1.1 概念

函数式接口在java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖‘，但二者在原理上是不同的。

1.2 格式

只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息)
    //其它非抽象方法内容
}

由于接口当中抽象方法的public abstract是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface{
    void myMethod();
}

1.3 @FunctionalInterface注解

@FunctionalInterface注解
作用：可以检测是否是一个函数式接口
    是：编译成功
    否：编译失败（接口中没有抽象方法/抽象方法的个数多于一个）

第二章函数式编程

2.1 Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

性能浪费的日志案例

注：日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。

/*
    日志案例：
        发现以下代码存在一些性能浪费的问题:
            调用showLog方法，传递的第二个参数是一个拼接后的字符串
            先把字符串拼接好，然后才调用showLog方法
            showLog方法中如果传递的日志等级不是1级
            那么就不会使用拼接后的字符串
            所以感觉字符串就白拼接了，因此存在浪费！
 */
public class Demo1Logger {
    //定义一个根据日志的级别，显示日志信息的方法
    public static void showLog(int level,String message){
        //对日志的等级进行判断，如果是1级别，那么输出日志信息
        if(level == 1){
            System.out.println(message);
        }
    }

    public static void main(String[] args) {
        //定义三个日志信息
        String message1 = "Hello";
        String message2 = "World";
        String message3 = "Java";

        //调用showLog方法，传递日志级别和日志信息
        showLog(2,message1+message2+message3);
    }
}

证明Lambda的延迟

/*
    使用Lambda优化日志案例：
        Lambda的特点：延迟加载
        Lambda的使用前提：必须存在函数式接口
 */
public class Demo2Lambda {
    //定义一个显示日志的方法，方法的参数传递日志的等级和MessageBuilder接口
    public static void showLog(int level,MessageBuilder mb){
        //对日志等级进行判断，如果是1级，则调用MessageBuilder接口中的builderMessage()
        if(level == 1){
            System.out.println(mb.builderMessage());
        }
    }

    public static void main(String[] args) {
        //定义三个日志信息
        String message1 = "Hello";
        String message2 = "World";
        String message3 = "Java";

        //调用showLog方法，参数MessageBuilder是一个函数式接口，所以可以传递Lambda表达式
        /*showLog(2,() -> {
            //返回一个拼接好的字符串
            return message1+message2+message3;
        });*/

        /*
            使用Lambda表达式作为参数，仅仅是把参数传递到showLog()中
            只有满足条件，日志的等级是1级
                才会调用接口MessageBuilder中的方法builderMessage
                才会进行字符串的拼接
            如果条件不满足，日志的等级不是1级
                那么MessageBuilder接口中的方法builderMessage也不会执行
                所以拼接字符串的代码也不会执行
            因此，不会存在性能的浪费！
         */
         showLog(1,() -> {
             System.out.println("满足条件执行！");
            //返回一个拼接好的字符串
            return message1+message2+message3;
        });
    }
}

@FunctionalInterface
interface MessageBuilder {
    //定义一个拼接消息的抽象方法：返回被拼接的消息
    public abstract String builderMessage();
}

2.2 使用Lambda作为参数和返回值

/*Lambda作为参数：
    例如：java.lang.Runnable接口就是一个函数式接口
        假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参
        这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。
 */
public class Demo1Runnable {
    //定义一个startThread()，方法的参数使用函数式接口Runnable
    public static void startThread(Runnable run){
        //开启多线程
        new Thread(run).start();
    }

    public static void main(String[] args) {
        //调用startThread()，方法的参数是一个接口，可以传递这个接口的匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });

        //调用startThread()，方法的参数是一个接口，使用Lambda
        startThread(() -> {
            System.out.println(Thread.currentThread().getName() + "线程启动了");
        });

        //优化Lambda：
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
    }
}

import java.util.Arrays;
import java.util.Comparator;

/*
    Lambda作方法的返回值：
        如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达；
        当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时，就可以调该方法获取
 */
public class Demo2Comparator {
    //定义一个方法，方法的返回值类型使用函数式接口Comparator
    public static Comparator<String> getComparator(){
        //方法的返回值类型是一个接口，可以返回这个接口的匿名内部类
        /*return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串长度降序排序
                return o2.length() - o1.length();
            }
        };*/

        //方法的返回值类型是一个接口，可以返回Lambda表达式
        /*return (String o1,String o2) -> {
            return o2.length() - o1.length();
        };*/

        //优化Lambda：
        return (o1,o2) -> o2.length() - o1.length();
    }

    public static void main(String[] args) {
        //创建一个字符串数组
        String[] arr = {"aaa","b","cccccc","dddddddd"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));
        //调用Arrays中的sort方法，对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));
    }
}

第三章常用函数式接口

3.1 Supplier接口

3.1.1 抽象方法：get

package day11.functionalInterface.demo4Supplier;

import java.util.function.Supplier;

/*
    常用的函数式接口：
        java.util.function.Supplier<T>接口仅包含一个无参的方法：T get(); 用来获取一个泛型参数指定类型的对象数据

        Supplier<T>接口被称之为“生产者型接口“，指定接口的泛型是什么类型，接口中的get()就会生产什么类型的数据。
 */
public class Demo1Supplier {
    //定义一个方法,方法的参数传递Supplier<T>接口，泛型执行String，get方法就会返回一个String
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    //调用getString(),方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
    public static void main(String[] args) {
        /*String ss = getString(() -> {
           return "李大钊";
        });*/

        //优化Lambda：
        String ss = getString(() -> "李大钊");
        
        System.out.println(ss);
    }
}

3.1.2 练习：求数组元素最大值

package day11.functionalInterface.demo4Supplier;

import java.util.function.Supplier;

/*
    练习：求数组元素的最大值
        使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值
        提示：接口的泛型使用java.lang.Integer类
 */
public class Demo2Test {
    //定义一个方法，用于获取int类型数组中元素的最大值，方法的参数传递Supplier接口，泛型使用Integer
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        //定义一个int[],并赋值
        int[] arr = {8,28,6,-1,14,100};
        //调用getMax(),方法的参数传递Supplier是一个函数式接口，所以可以传递Lambda表达式
        int result = getMax(() -> {
            //获取数组的最大值，并返回
            //定义一个变量，把数组中的第一个元素赋值给该变量，记录数组中元素的最大值
            int max = 0;
            //遍历数组，获取数组中的其他元素
            for (int i : arr) {
                //使用其他元素和最大值比较
                if(i > max){
                    //如果i大于max，则替换max作为最大值
                    max = i;
                }
            }
            //返回最大值
            return max;
        });
        System.out.println("数组中元素的最大值是：" + result);
    }
}

3.2 Consumer接口

3.2.1 抽象方法：accept

package day11.functionalInterface.demo5Consumer;

import java.util.function.Consumer;

/*
    java.util.function.Consumer<T>接口则正好与Supplier接口相反，
        它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
    Consumer接口中包含抽象方法void accept(T t); 意为消费一个指定泛型的数据。

    Consumer接口是一个消费型接口，泛型执行什么类型，就可以使用accept方法消费什么类型的数据
    至于具体怎么消费(使用)，需要自定义(输出，计算...)
 */
public class demo1Consumer {
    /*
        定义一个方法：
            方法的参数传递一个字符串的姓名
            方法的参数传递Consumer接口，泛型使用String
            可以使用Consumer接口消费字符串的姓名
     */
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        //调用method方法，传递字符串姓名，方法的另一个参数是Consumer是一个函数式接口，可以传递Lambda表达式
        method("陈独秀",(String name) -> {
            //对传递的字符串进行消费
            //消费方式：直接输出字符串
            //System.out.println(name);

            //消费方式：把字符串进行反转输出
            String reName = new StringBuilder(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

3.2.2 默认方法：andThen

package day11.functionalInterface.demo5Consumer;

import java.util.function.Consumer;
/*
    Consumer接口的默认方法andThen
    作用：需要两个Consumer接口，可以把两个Consumer接口组合到一起，再对数据进行消费

    例如：
        Consumer<String> con1
        Consumer<String> con2
        String s = "hello";
        con1.accept(s);
        con2.accept(s);
        连接两个Consumer接口，再进行消费：
        con1.andThen(con2).accept(s); 谁写前边谁先消费。
 */
public class Demo2AndThen {
    //定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1,Consumer<String> con2){
        //con1.accept(s);
        //con2.accept(s);
        //使用andThen方法，把两个Consumer接口连接到一起，再消费数据
        con1.andThen(con2).accept(s); //con1连接con2，先执行con1消费数据，再执行con2消费数据
    }

    public static void main(String[] args) {
        //调用method方法
        method("Xzw",
                (s) -> {
                    //消费方式：将字符串转换为大写
                    System.out.println(s.toUpperCase());
                },(s) -> {
                    //消费方方式：将字符串转化为小写
                    System.out.println(s.toLowerCase());
                });
    }
}

3.2.3 练习：格式化打印信息

package day11.functionalInterface.demo5Consumer;
import java.util.function.Consumer;
/*
    练习：
        字符串数组当中存有多条信息，请按照格式“姓名：xx。性别：xx。”的格式将信息打印出来
        要求将打印姓名的动作作为第一个Consumer接口的Lambda实例
        将打印性别的的动作作为第二个Consumer接口的Lambda实例
        将两个Consumer接口按照顺序“拼接”到一起。
 */
public class Demo3Test {
    //定义一个方法，参数传递String[]和两个Consumer接口，泛型使用String
    public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){
        //遍历字符串数组
        for (String message : arr) {
            //使用andThen方法，连接两个Consumer接口，消费字符串
            con1.andThen(con2).accept(message);
        }
    }

    public static void main(String[] args) {
        //定义一个字符串数组
        String[] arr = {"陈独秀,男","李大钊,男","李星华,女"};
        //调用printInfo()，传递一个字符串数组和两个Lambda表达式
        printInfo(arr,
                (message) -> {
                    String s1 = message.split(",")[0];
                    System.out.print("姓名：" + s1 + "。");
                },
                (message) -> {
                    String s2 = message.split(",")[1];
                    System.out.println("性别：" + s2 + "。");
                });
    }
}

3.3 Predicate接口

3.3.1 抽象方法：test

package day11.functionalInterface.demo6Predicate;
import java.util.function.Predicate;
/*
    java.util.function.Predicate<T>接口
    作用：对某种数据类型的数据进行判断，结果返回一个boolean值

    Predicate接口中包含一个抽象方法：
        boolean test(T t); 用来对指定数据类型数据进行判断的方法
            结果：
                符合条件，返回true
                不符合条件，返回false
 */
public class demo1Predicate {
    /*
        定义一个方法：
            参数传递一个String类型的字符串
            传递一个Predicate接口，泛型使用String
            使用Predicate中的test()对字符串进行判断，并把判断的结果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcdef";
        //调用checkString方法
        boolean b = checkString(s,(String str) -> {
            //对参数传递的字符串进行判断，如果长度大于5，把判断的结果返回
            return str.length() > 5;
        });
        System.out.println(b);
    }
}

3.3.2 默认方法：and

import java.util.function.Predicate;
/*
    逻辑表达式：可以连接多个判断条件
        &&：与运算符，有false则false
        ||：或运算符，有true则true
        !：非（取反）运算符，非真则假，非假则真

    需求：判断一个字符串，有两个判断条件
        1.判断字符串的长度是否大于5
        2.判断字符串中是否包含a
    两个条件必须同时满足，我们可以使用&&运算符连接两个判断条件

    Predicate接口中有一个默认方法and,表示并且关系，也可以用于连接两个判断条件：
    源码：
        default Predicate<T> and(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
        }
    方法内部的两个判断条件，也是使用&&运算符连接起来的。
 */
public class demo2Predicate_and {
    /*
        定义一个方法：方法的参数传递一个字符串，
        传递两个Predicate接口
            一个用于判断字符串的长度是否大于5
            一个用于判断字符串中是否包含a
            两个条件必须同时满足。
     */
    public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s); //等价于return pre1.test(s) && pre2.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcdef";
        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s,
                (str) -> {
                    //判断字符串的长度是否大于5
                    return str.length() > 5;
                },
                (str) -> {
                    //判断字符串是否包含a
                    return str.contains("a");
                });
        System.out.println(b);
    }
}

3.3.3 默认方法：or

import java.util.function.Predicate;

/*
    需求：判断一个字符串，有两个判断条件
        1.判断字符串的长度是否大于5
        2.判断字符串中是否包含a
    满足一个条件即可，我们就可以使用||运算符连接两个判断条件

    Predicate接口中有一个默认方法or,表示或者关系，也可以用于连接两个判断条件：
    源码：
        default Predicate<T> or(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
        }
    方法内部的两个判断条件，也是使用||运算符连接起来的。
 */
public class demo3Predicate_or {
    /*
        定义一个方法：方法的参数传递一个字符串，
        传递两个Predicate接口
            一个用于判断字符串的长度是否大于5
            一个用于判断字符串中是否包含a
            满足一个条件即可。
     */
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) || pre2.test(s);
        return pre1.or(pre2).test(s); //等价于return pre1.test(s) || pre2.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "adef";
        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s,
                (str) -> {
                    //判断字符串的长度是否大于5
                    return str.length() > 5;
                },
                (str) -> {
                    //判断字符串是否包含a
                    return str.contains("a");
                });
        System.out.println(b);
    }
}

3.3.4 默认方法：negate

import java.util.function.Predicate;
/*
    需求：判断一个字符串长度是否大于5
        如果大于5，返回false
        如果小于5，返回true
    可以使用取反符号!对判断结果进行取反

    Predicate接口中有一个默认方法negate,表示取反的意思：
    源码：
        default Predicate<T> negate() {
            return (t) -> !test(t);
        }
 */
public class demo4Predicate_negate {
    /*
        定义一个方法，方法的参数，传递一个字符串
        使用Predicate接口判断字符串的长度是否大于5
     */
    public static boolean checkString(String s, Predicate<String> pre){
        //return !pre.test(s);
        return pre.negate().test(s); //等价于return !pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abc111";
        //调用checkString方法，参数传递字符串和Lambda表达式
        boolean b = checkString(s,(String str) -> {
            //判断字符串长度是否大于5，并返回结果
            return str.length() > 5 ;
        });
        System.out.println(b);
    }
}

3.3.5 练习：集合信息筛选

import java.util.ArrayList;
import java.util.function.Predicate;
/*
    练习：集合信息筛选
        数组中有多条“姓名+性别”的信息如下：
            String[] array = {"迪丽热巴,女","古力娜扎,女","上官皇甫,男","陈乔恩,女"};
            请通过Predicate接口的拼装将符合要求的字符串筛选到ArrayList集合中，
            需要同时满足两个条件：
                1.必须为女生
                2.姓名为4个字

        分析:
            1.有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
            2.必须同时满足两个条件，需使用and方法连接两个判断条件
 */
public class demo5Test {
    //定义一个方法
    public static ArrayList<String> filter(String[] arr, Predicate<String> pre1,Predicate<String> pre2){
        //定义一个ArrayList集合，存储过滤之后的信息
        ArrayList<String> list = new ArrayList<>();
        //遍历字符串数组
        for (String s : arr) {
            //使用Predicate接口中的test(),对获取到的字符串进行判断
            boolean b = pre1.and(pre2).test(s);
            //对得到的布尔值进行判断
            if(b){
                //条件成立，两个条件都满足，把信息存储到ArrayList集合中
                list.add(s);
            }
        }
        //把集合返回
        return list;
    }

    public static void main(String[] args) {
        //定义一个字符串数组
        String[] arr = {"迪丽热巴,女","古力娜扎,女","慕容云海,男","郑爽,女"};
        //调用filter方法，传递字符串数组和两个Lambda
        ArrayList<String> list = filter(arr,
                (String s) -> {
                    //获取字符串中的性别，判断是否为女
                    return s.split(",")[1].equals("女");
                },
                (String s) -> {
                    //获取字符串中的姓名，判断长度是否为4个字符
                    return s.split(",")[0].length() == 4;
                });
        //遍历集合
        for(String s : list){
            System.out.println(s);
        }
    }
}

3.4 Function接口

3.4.1 抽象方法：apply

import java.util.function.Function;
/*
    java.util.function.Function<T,R>接口，用来根据一个类型的数据得到另一个类型的数据，
        前者称为前置条件，后者称为后置条件。
    Function接口中最主要的抽象方法为：R apply(T t); 根据类型T的参数获取类型R的结果。
        使用的场景例如：将String类型转换为Integer类型
 */
public class demo1Function {
    /*
        定义一个方法:
            方法的参数传递一个字符串类型的整数，
            方法的参数传递一个Function接口，泛型使用<String,Integer>,
            使用Function接口中的方法apply，把字符串类型的数据转换为Integer类型的整数
     */
    public static void change(String s, Function<String,Integer> fun){
        Integer in = fun.apply(s);
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "828146";
        //调用change方法，传递字符串类型的整数，和Lambda表达式
        /*change(s,(String str) -> {
            //把字符串类型的整数转换为Integer类型的整数并返回
            return Integer.parseInt(str);
        });*/

        //优化Lambda：
        change(s,str -> Integer.parseInt(str));

        /*int i = Integer.parseInt("鲁迅"); //NumberFormatException! 数字格式异常！
        System.out.println(i);*/

    }
}

3.4.2 默认方法：andThen

import java.util.function.Function;
/*
    Function接口中的默认方法andThen：用来进行组合操作

    需求：
        把String类型的"123"，转换为Integer类型，把转换后的结果加10
        把增加之后的Integer类型的数据，转换为String类型

    分析：转换了两次
        第一次是把String类型转换为了Integer类型
            可以使用Function<String,Integer> fun1
                Integer i = fun1.apply("123");
        第二次是把Integer类型转换为了String类型
            可以使用Function<Integer,String> fun2
                String s = fun2.apply(i);
        通过andThen(): 把两次转换组合在一起使用
            String s = fun1.andThen(fun2).apply("123");
            fun1先调用apply方法，把字符串转换为Integer
            fun2再调用apply(),把Integer转换为字符串。
 */
public class Demo2Function {
    /*
        定义一个方法：String s = "123";
            方法的参数传递一个String类型的整数，
            方法的参数传递一个Function接口，泛型为<String,Integer>
            方法的参数传递一个Function接口，泛型为<Integer,String>
     */
    public static void changeAdd(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String apply = fun1.andThen(fun2).apply(s);
        System.out.println(apply);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "123";
        //调用changeAdd(): 传递一个字符串和两个Lambda表达式
        /*changeAdd(s,
                (String str) -> {
                    //把String类型整数转换为Integer类型数据，加10并返回
                    return Integer.parseInt(str) + 10;
                },
                (Integer in) -> {
                    //把Integer类型数据转换为字符串类型整数
                    return in + "";
                });*/

        //优化Lambda：
        changeAdd(s,str -> Integer.parseInt(str) + 10,in -> in + "");
    }
}

3.4.3 练习：自定义函数模型拼接

import java.util.function.Function;
/*
    练习：自定义函数模型拼接
        题目：请使用Function进行函数模型拼接，按照顺序需要执行的多个函数操作为：
            String str = "陈独秀,28";

        分析：
            1.将字符串截取数字年龄部分，得到字符串
                Function<String,String> "陈独秀,28" -> "28"
            2.将上一步的字符串转换为int类型的数字
                Function<String,Integer> "28" -> 28
            3.将上一步的int数字累加100，得到结果int数字
                Function<Integer,Integer> 28 -> 128
 */
public class Demo3Test {
    /*
        定义一个方法：
            方法的参数传递一个字符串，
            传递三个Function接口，其泛型分别为：
                        <String,String>
                        <String,Integer>
                        <Integer,Integer>
     */
    public static void show(String s, Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        Integer in = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定义一个String类型的整数
        String str = "陈独秀,28";
        //调用show()：传递字符串整数和三个Lambda表达式
        /*show(str,
                (String s) -> {
                    //"陈独秀,28" -> "28"
                    return s.split(",")[1];
                },
                (String s) -> {
                    //"28" -> 28
                    return Integer.parseInt(s);
                },
                (Integer i) -> {
                    //28 -> 128
                    return i + 100;
                });*/

        //优化Lambda：
        show(str,s -> s.split(",")[1],s -> Integer.parseInt(s),i -> i + 100);
    }
}

posted @ 2021-06-29 01:28 Sleepinglion 阅读(498) 评论(0) 收藏举报

刷新页面返回顶部

函数式接口

函数式接口

第一章 函数式接口

1.1 概念

1.2 格式

1.3 @FunctionalInterface注解

第二章 函数式编程

2.1 Lambda的延迟执行

性能浪费的日志案例

证明Lambda的延迟

2.2 使用Lambda作为参数和返回值

第三章 常用函数式接口

3.1 Supplier接口

3.1.1 抽象方法：get

3.1.2 练习：求数组元素最大值

3.2 Consumer接口

3.2.1 抽象方法：accept

3.2.2 默认方法：andThen

3.2.3 练习：格式化打印信息

3.3 Predicate接口

3.3.1 抽象方法：test

3.3.2 默认方法：and

3.3.3 默认方法：or

3.3.4 默认方法：negate

3.3.5 练习：集合信息筛选

3.4 Function接口

3.4.1 抽象方法：apply

3.4.2 默认方法：andThen

3.4.3 练习：自定义函数模型拼接

公告

第一章函数式接口

第二章函数式编程

第三章常用函数式接口