Java 函数式接口说明

整理一下 Java8 之后的重要概念 函数式接口的说明和团队分享，这是函数式编程和 Lambda 表达式的基础。虽然现在 Java 都快发布13版本了，但是小伙伴们这个概念不清楚，用的也很少，有必要统一讲一下。

1. 引言

我们如果了解一点 JavaScript 的话，就知道 JS 里是可以用函数作为参数的，Java 8以前是不行的。我们先以 JavaScript 为举例：

function test(f,a){
  return f(a)+1;
}
function f1(i){
  return i*i;
}
function f2(i){
  return i+i;
}
console.log(test(f1,4)); //结果是17
console.log(test(f2,4));//结果是9

上面的例子可以看到，JS 的函数是可以作为其它函数的参数的。 而 Java 早期是不行的，Java 号称一切都是对象，对象是可以做为参数，但是函数不是对象。

2. 面向对象的方式

Java 早期如何实现以上的效果了？肯定是可以的，但是繁琐，第一种方式是用增加重复的test函数，这种方式不是好的方式，不建议使用，参考以下例子：

public static Integer test1(Integer i) {
    return f1(i)+1;
}
public static Integer test2(Integer i) {
    return f2(i)+1;
}
public static Integer f1(Integer i) {
    return i*i;
}
public static Integer f2(Integer i) {
    return i+i;
}
System.out.println(test1(4));
System.out.println(test2(4));

提供服务的函数可能有很多种，但是使用函数的使用方逻辑可能是一致的，第一种方式得不断的修改使用函数的逻辑显然是不合适的。第二种方式是使用继承的方式来实现，如下例子：

interface inf{
    Integer f(Integer i);
    default Integer test(Integer i){
        return f(i)+1;
    }
}
class f1 implements inf{
    @Override
    public Integer f(Integer i) {
        return i*i;
    }
}
class f2 implements inf{
    @Override
    public Integer f(Integer i) {
        return i+i;
    }
}
inf inf1 = new f1();
inf inf2 = new f2();
System.out.println(inf1.f(4));//结果是17
System.out.println(inf2.f(4));//结果是9

第二种方式要好，在一些复杂的场景，这种面向对象的方式显然是非常合理和常规的，但是在一些场景，太繁琐了。
我们需要像 JS 一样，把函数作为一个对象使用就能解决问题，定义一个函数，然后让一个对象引用指向它，我们就能对函数进行操作。

3. @FunctionalInterface

这里需要用到函数式接口和 lambda 表达式，Function是一种函数式接口。这里插一句，什么是函数式接口？函数式接口是一个 Java Interface，但是只有一个需要实现的抽象函数定义的 Interface（default的不算）。
JavaScript 定义一个函数变量非常容易：

var f0 = function(i){
    return i*i;
}
console.log(f0(3));
var f1 = f0;

Java实现类似功能就得用到一个特定的函数式接口 Function，它就是一个 Java 的 interface，有一个基本方法apply，以下代码就是对这个接口的匿名实现：

Function<Integer,Integer> f0 = new Function<Integer, Integer>() {
    @Override
    public Integer apply(Integer i) {
        return i*i;
    }
};
System.out.println(f0.apply(3));

我们接下来需要定义二个 Function 对象指向 f1 和 f2 函数，但是并不能直接等于函数名，而是改成 lamada 表达式的写法。

public Integer test(Function<Integer,Integer> f,Integer i) {
    return f.apply(i)+1;
}
public Integer f1(Integer i) {
    return i*i;
}
public Integer f2(Integer i) {
    return i+i;
}

Function<Integer,Integer> ff1 = i -> f1(i);
Function<Integer,Integer> ff2 = i -> f2(i);
System.out.println(test(ff1,4));
System.out.println(test(ff2,4));

大家可以看到这个写法和 JS 的基本一致。我们再利用 lamada 表达式的方式再次简化一下代码。

public Integer test(Function<Integer,Integer> f,Integer i) {
    return f.apply(i)+1;
}
Function<Integer,Integer> f1 = i -> i*i;
Function<Integer,Integer> f2 = i -> i+i;
System.out.println(test(f1,4));
System.out.println(test(f2,4));

再简化

public Integer test(Function<Integer,Integer> f,Integer i) {
    return f.apply(i)+1;
}
System.out.println(test(i -> i*i,4));
System.out.println(test(i -> i+i,4));

在这里我们就必须提一下函数式编程的特点是行为参数化，以前只能传递数据作为参数，现在可以传递行为也就是函数的定义（只包括参数和返回值类型，不包括实现）作为参数。
这样的好处就是可以抛开具体的实现而先定义更高层次的抽象，把可能会变化的和不变的逻辑代码分离开。

4. compose 和 andthen

我们还是以 JavaScript 的例子来说明会更清晰一点：

function f1(i){
  return i*i;
}
function f2(i){
  return i+i;
}
console.log(f2(f1(5))); //结果是50
console.log(f1(f2(5)));//结果是100

对应的 Java 实现方式是:

Function<Integer,Integer> f1 = i -> i*i;
Function<Integer,Integer> f2 = i -> i+i;
System.out.println(f2.apply(f1.apply(5)));//结果是50
System.out.println(f1.apply(f2.apply(5)));//结果是100

也可以通过 compose 和 andthen 先定义一个新的行为，再执行。

Function<Integer,Integer> f1 = i -> i*i;
Function<Integer,Integer> f2 = i -> i+i;
Function<Integer,Integer> f3 = f1.compose(f2); // 等同于f1(f2())
Function<Integer,Integer> f4 = f2.compose(f1); // 等同于f2(f1())
Function<Integer,Integer> f5 = f1.andThen(f2); // 等同于f2(f1())
Function<Integer,Integer> f6 = f2.andThen(f1); // 等同于f1(f2())

System.out.println(f3.apply(5));//结果是100
System.out.println(f4.apply(5));//结果是50
System.out.println(f5.apply(5));//结果是50
System.out.println(f6.apply(5));//结果是100

这样利用 Function 的这2个函数可以实现复杂的函数组合处理。

5. Consumer 和 Predicate以及自定义函数式接口

我们再来看看其它2个比较常用的函数式接口:

• Consumer 就是不带返回值的函数式接口，相比之下 Function 是带一个参数带返回值的函数式接口
• Predicate 就是带一个参数，固定返回布尔类型的函数式接口。
  我们来看例子：

String testString = "test1";
Consumer<String> f7 = s->testString = testString+s;
f7.accept("我");
System.out.println(testString); //test1我

Predicate<String> f8 = s -> "test".equals(s);
System.out.println(f8.test("hello")); // false

我们可以看看 Consumer 和 Predicate 的源码，它有 andthen 函数作为函数组合处理。Predicate 有 and or negate 方法对应布尔类型的&&、||和!操作。
Consumer 的 accept 和 Predicate 的 test 方法等同于 Function的 apply,表示执行这个函数。
最后我们来看自定义函数式接口。上面也提到了，只需要定义一个函数的 interface 就是函数式接口，而且注解 @Functioninterface 也不是必须写的。

@FunctionalInterface
interface Hello {
    String msg(String info);

}
Hello hello1 = param -> param + "world!";
Hello hello2 = new Hello() {
    @Override
    public String msg(String info) {
        return info + "world!";
    }
};
System.out.println(hello1.msg("hello,"));
System.out.println(hello2.msg("hello,"));

我们可以看到 hello2 的作用和 hello1 是完全一样的，但是 hello1 简洁太多了。

总之，如果熟悉 JavaScript 来理解和使用 Java 的函数式说明是很容易的，如果要了解更多实际的例子包括lambda可以参考 链接 和 链接