【Java8】函数式接口

一、前言

早期的程序员在JDK1.5时期，掌握泛型、枚举、反射基本上就可以了，随着JDK不断迭代升级，到相对于稳定的JDK1.8版本，扩展了大量的知识点，例如：lambda表达式，链式编程，函数式接口，Stream流式计算 这些新知识点的出现大大的简化了编程模型，减少了很多冗余代码，代码简洁，清晰明了，并且在迭代出来的底层架构大量得到了应用，所以，我们必须随着主流进行学习，避免阅读源码时都不知道其意。

二、函数式接口(Functional Interface)

函数式接口：只有一个方法的接口

有且仅有一个抽象方法的接口，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。Lambda就是Java中函数式编程的体现。

｜类型

主要分布在 java.util.function 包下，常见的 4大原始函数 接口为：Function (函数型接口)、Predicate (断定型接口)、Consumer (消费型接口)、Supplier (供给型接口)

｜@FunctionalInterface注解

Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface 。该注解放在接口上，表示此接口是一个函数式接口。并且提示编译器去检查接口是否仅包含一个抽象方法，即，是否符合函数式编程的定义。

注意：如果自定义一个符合规范的函数式接口，也可以不加@FunctionalInterface注解，此注解只是起到一个提示编译器进行规范检查的作用

日常开发中用的最多的函数式接口的，比如线程中的 Runnable

@FunctionalInterface
public interface Runnable {public abstract void run();
}

1. Function (函数型接口)

有一个输入参数，有一个输出

接口的源码如下：

@FunctionalInterface
public interface Function<T, R> {// 继承该接口需要实现的方法R apply(T t); default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}static <T> Function<T, T> identity() {return t -> t;}
}

apply ()方法就是该接口的唯一方法，也就是继承该Function接口，唯一需要实现的方法！

有小伙伴可能还会问，函数式接口不是有且只有一个方法吗？为什么存在default 和 static的方法

static：实现接口的类或子接口不会继承接口里的静态方法！
default：java8在接口中新增default方法，是为了在现有的类库中新增功能而不影响其实现类，也就是说，该接口的实现类可以直接调用default方法，而不需要实现它！

我们来具体使用下该接口

// 输出输入的参数：有一个输入参数，和一个输出
public static void main(String[] args) {// 1. 初始化，并且实现该接口的唯一实现方法Function<String,String> function = new Function<String, String>() {@Overridepublic String apply(String str) {return str;}};System.out.println(function.apply("abc"));
}

执行结果：str是一个参数传递到 Predicate 接口的 apply 方法。表示接受一个参数并产生结果

这就是一个标准的函数式接口，我们前面也说了：Lambda就是Java中函数式编程的体现 也就是说只要是函数式接口，就可以使用lambda表达式来简化代码！如下：

public static void main(String[] args) {// 使用lambda表达式Function<String,String> function = (str)->{return str;};//或者我们可以更简单点，把str的()括号去掉也是可以的// Function<String,String> function = str->{return str;};System.out.println(function.apply("abc"));
}

这就是典型的lambda表达式语法：()->{}；str是传入的参数，等同于我们线程中的Runnable用法：

// Thread内部是一个Runnable的函数式接口，run()是Runnable接口中唯一的方法
Thread thread = new Thread(new Runnable() {@Overridepublic void run() {System.out.println(1);}
});// 上述代码等同于：
Thread thread2 = new Thread(()->{System.out.println(1);});

2. Predicate (断定型接口)

有一个输入参数，返回值只能是布尔值

源码如下：

@FunctionalInterface
public interface Predicate<T> {// 在给定的参数上评估这个谓词boolean test(T t);
}

具体使用：

public static void main(String[] args) {/* Predicate<Integer> predicate = new Predicate<Integer>(){@Overridepublic boolean test(Integer n) {return n>0;}};*/// 使用lambda表达式  判断传入的值是否大于0Predicate<Integer> predicate =(n)->{return n>0;};System.out.println(predicate.test(2));
}

执行结果：n 是一个参数传递到 Predicate 接口的 test 方法，如果 n> 0，则test 方法返回 true

针对断定型接口，我们还可以更简洁的lambda表达式语法：

省略()和{}：要传入的参数->判断结果

public static void main(String[] args) {Predicate<Integer> predicate = n-> n>0;System.out.println(predicate2.test(2));
}

——可以用来判断字符串是否为空，以及求奇数偶数，例如：

/*** 断定型接口：有一个输入参数，返回值只能是布尔值*/
public class PredicateDemo {public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);/**  1.*  Predicate<Integer> predicate = n -> true*  n 是一个参数传递到 Predicate 接口的 test 方法*  n 如果存在则 test 方法返回 true*/System.out.println("输出全部：");eval(list, n->true);/** 2.*  Predicate<Integer> predicate1 = n -> n%2 == 0*  n 是一个参数传递到 Predicate 接口的 test 方法*  如果 n%2 为 0 test 方法返回 true*/System.out.println("输出所有偶数:");eval(list, n-> n%2 == 0 );/** 3.*  Predicate<Integer> predicate1 = n -> n > 3*  n 是一个参数传递到 Predicate 接口的 test 方法*  如果 n > 3  test 方法返回 true*/System.out.println("输出大于3 的所有数字:");eval(list, n-> n > 3 );}public static void eval(List<Integer> list, Predicate<Integer> predicate) {for(Integer n: list) {// test验证n的表达式的为true还是falseif(predicate.test(n)) {System.out.print(n + " ");}}System.out.println();}
}

执行结果：

3. Consumer (消费型接口)

只有入参，没有返回值

源码如下：

@FunctionalInterface
public interface Consumer<T> {// t 是输入参数void accept(T t);
}

具体使用：

public static void main(String[] args) {// 1.常规方式/* Consumer<String> consumer = new Consumer<String>(){@Overridepublic void accept(String str) {System.out.println(str);}};*/// 2.lambda表达式// Consumer<String> consumer = (str)-> {System.out.println(str)};// 更简洁的lambda表达式，省略()、{}Consumer<String> consumer = str-> System.out.println(str);consumer.accept("abc");
}

执行结果：消费型接口，即只消费，没有返回值

4. Supplier (供给型接口)

没有参数，只有返回值

源码如下：

@FunctionalInterface
public interface Supplier<T> {// 获得结果 T是结果的具体类型T get();
}

具体使用

public static void main(String[] args) {// 1.常规方式/* Supplier<Integer> consumer = new Supplier<Integer>(){@Overridepublic Integer get() {return 1024;}};*/// 2.lambda表达式//Supplier<Integer> supplier = ()-> {return 1024;};// 更简洁的lambda表达式，省略{}Supplier<Integer> supplier = ()-> 1024;System.out.println(supplier.get());
}

执行结果：供给型接口，顾名思义只提供，即返回结果，类似生产者

总结

函数型编程在Java8中得到大量的运用，比如Java8的新特性Stream流式计算，可参考文章：

优秀的判断力来自经验，但经验来自于错误的判断。