函数式接口

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

咱们今天讨论下函数式接口

以Predicate为例，之前在分析山寨Stream API时，我们已经不知不觉使用过函数式接口：

// 1.用Lambda表达式实现Predicate接口的抽象方法test()，并赋值给函数式接口
Predicate ifHigherThan180 = user -> user.getHeight()>180;
// 2.作为参数传入filter(Predicate ifHigherThan180)，filter()会在内部调用test()用来判断
ifHigherThan180.test(user);

总的来说，就是把方法A（Lambda）传给方法B（filter），然后在方法B内部调用方法A完成一些操作：

public void methodB(method a) {
    // 操作1
    // 调用method a
    // 操作3
}

我们可以理解为Java8支持传递方法（之前只能传递基本数据类型和引用类型），也可以按原来面向对象的思维将Lambda理解为“特殊的匿名对象”。

为什么函数式接口很重要

有些同学应该会有疑问：

函数式接口有什么好讲的，我们不是在《Lambda表达式》中学过了吗？

不，当时只是向大家介绍了函数式接口的定义：

有且仅有一个抽象方法的接口（不包括默认方法、静态方法以及对Object方法的重写）

就我个人学习体会来看，函数式接口虽然不难，但作为参数类型出现时，经常会让初学者感到无所适从，甚至不知道该传递什么。比如Stream API中就大量使用了函数式接口接收形参：

CompletableFuture中也大量使用了函数式接口：

不知道大家是否曾经在调用filter()、supplyAsync()等方法时感到迷茫，起码我刚接触Java8时，每次调用这些方法都力不从心，不知道该传什么进去，也不知道Lambda表达式该怎么写。

如果你问我函数式接口难吗，我大概率会告诉你，它本身很简单。但如果你问我函数式接口重要吗，我会告诉你，它非常非常重要，能否熟练使用Java8的诸多新特性（Stream、CompletableFuture等）取决于你对函数式接口的熟悉程度。

函数式接口的类型

根据方法的出入参类型不同，各种排列组合后，其实有很多种类型，最常用的有以下4种函数式接口：

public class FunctionalInterfaceTest {

    /**
     * 给函数式接口赋值的格式：
     * 函数式接口 = 入参 -> 出参/制造出参的语句
     *
     * @param args
     */
    public static void main(String[] args) {
        FunctionalInterface1 interface1 = str -> System.out.println(str);
        FunctionalInterface2 interface2 = () -> {
            return "abc";
        };
        FunctionalInterface3 interface3 = str -> Integer.parseInt(str);
        FunctionalInterface4 interface4 = str -> str.length() > 3;
    }


    /**
     * 消费型，吃葡萄不吐葡萄皮：有入参，无返回值
     * (T t) -> {}
     */
    interface FunctionalInterface1 {
        void method(String str);
    }

    /**
     * 供给型，无中生有：没有入参，却有返回值
     * () -> T t
     */
    interface FunctionalInterface2 {
        String method();
    }

    /**
     * 映射型，转换器：把T转成R返回
     * T t -> R r
     */
    interface FunctionalInterface3 {
        int method(String str);
    }

    /**
     * 特殊的映射型：把T转为boolean
     * T t -> boolean
     */
    interface FunctionalInterface4 {
        boolean method(String str);
    }
}

大家看，以上函数式接口是我自定义瞎写的，但牢牢把握了住了出入参的特点（接口名、方法名不重要），代表了4种不同的函数式接口。正因为各自出入参不同，导致Lambda表达式的写法也不同。

函数式接口的作用

实际开发中，出入参类型的排列组合是有限的，所以JDK干脆内置了一部分函数式接口。一般来说，我们只需熟练掌握以下4大核心函数式接口即可：

• 消费型接口 Consumer    void accept(T t)
• 供给型接口 Supplier       T get()
• 函数型接口 Function   R apply(T t)
• 断定型接口 Predicate     boolean test(T t)

为什么JDK要在Java8这个版本引入函数式接口，并且提供这么多内置接口呢？

其实这些接口本不是给我们用的，而是JDK自己要用。

还记得前几章我编写的山寨Stream API吗？为了顺利构造出山寨Stream API，我自定义了Predicate接口和Function接口：

/**
 * 新建Predicate接口
 *
 * @param 
 */
@FunctionalInterface
interface Predicate {
    /**
     * 定义了一个test()方法，传入任意对象，返回true or false，具体判断逻辑由子类实现
     *
     * @param t
     * @return
     */
    boolean test(T t);
}

// Function接口 略...

同样的，我和Java8一样，也把Predicate接口作为形参类型（详见myPrint方法）：

public class MockStream {

    public static void main(String[] args) {

        Person bravo = new Person("bravo", 18);

        // 1.匿名对象，调用它的test()方法
        Predicate predicate1 = new Predicate() {
            @Override
            public boolean test(Person person) {
                return person.getAge() < 18;
            }
        };
        myPrint(bravo, predicate1); // false

        // 2.Lambda表达式，调用它的test()方法。
        // 按照Lambda表达式的标准，只要你是个函数式接口，那么就可以接收Lambda表达式
        Predicate predicate2 = person -> person.getAge() == 18;
        myPrint(bravo, predicate2); // true
    }

    public static void myPrint(Person person, Predicate filter) {
        if (filter.test(person)) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

JDK之所以要在Java8内置那么多函数式接口，本质原因和我的山寨Stream API一样，是为了配合Java8的各种API。单独发布Stream API和CompletableFuture是不现实的，它们的方法形参都依赖函数式接口呢。

Java8函数式接口的作用和我们自定义的Predicate接口一样：

• 接收Lambda表达式/方法引用
• 占坑

或者说，这两个作用是一体两面的。

所谓占坑，之前已经提过了，这里再说一下吧。

比如新冠病毒爆发时，我们需要对潜在感染者进行检测，但检测的手段有很多，比如CT和核酸测试。

虽然定义getHealthPerson()时并不确定实际会采用哪种方式进行新冠检测，可能是CT也可能是核酸测试，具体由子类实现。但不管怎么说，有一点是肯定的：一定要测试。

此时如果创建一个函数式接口，定义boolean test()方法，并将getHealthPerson()的形参定为getHealthPerson(List, Predicate)，就能保证未来无论是谁调用这个方法，都必须明确检测方法，也就是必须传入Predicate接口的实例或者Lambda表达式。

/**
 * 用Predicate占坑
 * @param uncheckPersonList
 * @param predicate
 * @return
 */
public static List getHealthPerson(List uncheckPersonList, Predicate predicate) {
    ArrayList healthyPersonList = new ArrayList<>();

    for (Person person : uncheckPersonList) {
        // 占坑，反正需要检测，但是具体拍CT还是核酸检测具体情况具体分析
        if (predicate.test(person)) {
            healthyPersonList.add(person);
        }
    }

    return healthyPersonList;
}

此后如果有其他方法调用getHealthPerson()，必须传入具体的检测手段：

public static void main(String[] args) throws JsonProcessingException {
    ArrayList uncheckPersonList = new ArrayList<>();
    uncheckPersonList.add(new Person("张三", 18));
    uncheckPersonList.add(new Person("李四", 20));
    
    // 传入Lambda表达式
    getHealthPerson(uncheckPersonList, person -> 核酸检测(person));
    getHealthPerson(uncheckPersonList, person -> 胸部CT(person));

}

这就是函数式接口的作用。

如何克服面向对象的思维惯性

对于函数式接口，上面已经讲得很多了，本身很简单，没什么好介绍的。这里主要聊一聊初学者应该如何习惯函数式接口传参的方式，以及关注点应该放哪里。换句话说，帮助初学者克服面向对象的思维惯性，学会用函数式编程的思维去使用Java8的诸多特性。

还是以Predicate为例，它唯一的抽象方法是：

boolean test(T t);

假设有个方法叫：getHealthPerson(List users, Predicate filter)，你知道该给filter传什么吗？

很多Java程序员会对这种传参形式感到眩晕，因为我们的潜意识一直无法摆脱面向对象的影响。当你看到getHealthPerson(List users, Predicate filter)时，你的大脑会告诉你Predicate是一个接口，所以应该传一个匿名对象给它。然后你的大脑自己也懵了，因为它突然发现光看Predicate接口，根本不知道该实现什么方法，甚至连入参和返回值都不清楚，怎么手写Lambda？

但之前介绍Python的函数时，我们很自然就接受了：

# encoding: utf-8

# abs是Python的内置函数
result = abs(-1)
print(result)

# 定义add()方法，f显然是一个函数
def add(x, y, f):
    return f(x) + f(y)

print(add(-1, -2, abs))

因为相比Python这些原本就支持函数式编程的语言来说，形参就是函数，不需要用接口做中间层过渡！而对于Stream这种面向对象世界中的异类，Java程序员还没准备好如何接纳它，看到接口形参第一时间想到的还是传匿名对象，突然要改成Lambda确实有点棘手，因为我们对接口内部的方法及出入参一概不知！

如何克服呢？两种方式：

• 以面向对象的思维直接new匿名对象，靠IDEA优化成Lambda（曲线救国，减少记忆负担）

• 每个函数式接口就一个方法，记住那个方法的出入参，看到接口就写对应方法的Lambda（需要记忆）

这里主要讲讲如何记忆函数式接口的方法。一定要注意，函数式接口的方法名字不重要，重要的是出入参：

• 消费型接口 Consumer     T t -> void     例：x -> System.out.println(x)
• 供给型接口 Supplier       () -> T t     例：() -> {return 1+2;}
• 映射型接口 Function   T t -> R r     例：user -> user.getAge()，T是入参，R是出参
• 断定型接口 Predicate    T t -> boolean    例：user -> user.getAge()>18

Consumer，消费型接口，是黑洞，只管吃(C)，不会往外吐，所以只有入参，没有返回值。

Supplier，供给型接口，是泉眼，不断往外涌出泉水(S)，不需要入参，有返回值。

Function，映射型接口，就是高中数学的函数映射，x --> f(x) --> result，所以有入参，也有返回值。

Predicate，断定型接口，是特殊的映射函数，x --> f(x) --> boolean，只会评(P)论true/false。

如果你觉得口诀很生硬，就把上面的例子记住，把每个函数式接口都和一个例子绑定，实际开发时去套用例子即可。

记住了接口对应的出入参，Lambda就好办了，其实传递的都是：

接口声明 = 入参 -> 出参/制造出参的语句

不信你可以重新看看上面给出的例子，比如Function：user -> user.getAge()，就是把User user映射为Integer age，user是入参，user.getAge()是制造出参的语句。又比如Predicate：user -> user.getAge()>18，user是入参，user.getAge()>18就是制造出参的语句，因为boolean test(T t)需要返回boolean。

所以要习惯函数式接口传参，最重要的是记住该接口对应的方法的出入参，然后编写Lambda时套用模板：

接口声明 = 入参（有无入参？） -> 出参/制造出参的语句（有无出参？什么类型？）

虽然我们还没正式学习Stream API，但已经可以试着写写啦：

public class FunctionalInterfaceTest {

    public static void main(String[] args) {

        List list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));

        /**
         * Predicate：特殊映射，只断是非   Function：T t --> f(x) --> boolean
         * Function：映射               Function：T t --> f(x) --> R r
         */
        list.stream().filter().map().collect(Collectors.toList());

        // Supplier，无源之水(S)，却滔滔不绝，没有入参，却可以get()
        CompletableFuture