Java 8 Function函数式接口及函数式接口实例

函数式接口(functional interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为lambda表达式。

函数式接口可以现有的函数友好地支持 lambda。

介绍

函数式接口其实就是一个抽象接口类，在java 8之前已有的函数式接口有以下。

									java.lang.runnable

									java.util.concurrent.callable

									java.util.comparator

等等...

使用方法

其实上述所说的接口类只需要使用functionalinterface注解修饰，就成为了java中的函数式接口。比如jdk中callable接口定义

									@functionalinterface

									public interface callable<v> {

									  v call() throws exception;

									}

就这么简单。

现在来讲讲java 8新增function接口。下面是其定义

									// t 是传入参数

									// r 是返回参数

									@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;

									  }

									}

他可以理解为c语言中的函数指针(个人看法)。

在实际使用中，apply方法使用比较广泛。compose/andthen多用于两个以上函数接口并且执行上有先后顺序的场景下。

在具体业务代码中，我一般结合bifuncton/supplier一起使用。bifunction支持2个参数的，function只支持一个参数。supplier可以用来存储具体需要的值，通过get来获取。

例子

引用平时工作的代码。该例子主要规避了多个判断条件if/else造成代码臃肿的，同时也可以把相同的业务逻辑抽象出函数接口，从而可以在多处代码重用。具体代码如下。

									function<object, integer> actiontest1 = (object) -> {

									  // logic

									  return 0;

									};

									function<object, integer> actiontest2 = (object) -> {

									  // logic

									  return 0;

									};

									public supplier<map<integer, function<object, integer>>> actionsupplier = () -> {

									    map<integer, function<object, integer>> maps = new hashmap<>();

									    maps.put(1, actiontest1);

									    maps.put(2, actiontest2);

									    return maps;

									};

									// 具体使用

									public void test(int type, object object) {

									  optional.ofnullable(actionsupplier.get().get(type)).ifpresent(x -> x.apply(v, object));

									  // if/else 逻辑

									  if (type == 1) {

									    // test1 logic

									  } else if (type == 2) {

									    // test2 logic

									  }

									}

总结

个人认为，在业务逻辑分支判断较多的场景，是比较适合使用function的，而且还有以下几点好处

代码看上去比较简洁
相同逻辑可以重用(当然封装成函数也是可以的~)
代码后期比较好维护点。

函数式接口实例

predicate <t> 接口是一个函数式接口，它接受一个输入参数 t，返回一个布尔值结果。

该接口包含多种默认方法来将predicate组合成其他复杂的逻辑（比如：与，或，非）。

该接口用于测试对象是 true 或 false。

我们可以通过以下实例（java8tester.java）来了解函数式接口 predicate <t> 的使用：

									java8tester.java 文件

									import java.util.arrays;

									import java.util.list;

									import java.util.function.predicate; 

									public class java8tester {

									  public static void main(string args[]){

									   list<integer> list = arrays.aslist(1, 2, 3, 4, 5, 6, 7, 8, 9);

									   // predicate<integer> predicate = n -> true

									   // n 是一个参数传递到 predicate 接口的 test 方法

									   // n 如果存在则 test 方法返回 true    

									   system.out.println("输出所有数据:");    

									   // 传递参数 n

									   eval(list, n->true);

									   // predicate<integer> predicate1 = n -> n%2 == 0

									   // n 是一个参数传递到 predicate 接口的 test 方法

									   // 如果 n%2 为 0 test 方法返回 true

									   system.out.println("输出所有偶数:");

									   eval(list, n-> n%2 == 0 );

									   // predicate<integer> predicate2 = 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) {

									     if(predicate.test(n)) {

									      system.out.println(n + " ");

									     }

									   }

									  }

									}