JAVA系列---函数式接口

函数式接口的定义

1. 一个函数式接口有且仅有一个抽象方法(SAM，single abstract method)。对于接口来说抽象方法必须重写，默认方法可选重新，静态方法不可重新。
2. Object 类中的 public abstract method 不会被视为单一的抽象方法。这些方法对于函数式接口来说，不被当成是抽象方法（虽然它们是抽象方法）。因为任何一个函数式接口的实现，默认都继承了Object类，包含了来自java.lang.Object里对这些抽象方法的实现。
3. 函数式接口可以用@FunctionalInterface 注解进行修饰。但并不是必须用注解标注，一个接口只要满足只有一个抽象方法的条件就可以称为函数式接口。
   如果使用了此注解，再往接口中新增抽象方法，编译器就会报错，编译不通过。换句话说，@FunctionalInterface就是一个承诺，承诺该接口世世代代都只会存在这一个抽象方法。因此，凡是使用了这个注解的接口，开发者可放心大胆的使用lambda来实例化。当然误用@FunctionalInterface带来的后果也是极其惨重的：如果哪天你把这个注解去掉，再加一个抽象方法，则所有使用lambda实例化该接口的客户端代码将全部编译错误。所以当某接口只有一个抽象方法，但没有增加@FunctionalInterface，则代表该接口不承诺未来不增加抽象方法，所以建议不要用lambda来实例化，还是老老实实的用以前的方式比较稳妥。

函数式接口的示例

@FunctionalInterface
public interface HelloWorldService {void sayHello(String msg);default void doSomeWork1() {// Method body}default void doSomeWork2() {// Method body}static void printHello() {System.out.println("Hello");}@Overrideboolean equals(Object obj);}

函数式接口的用处

函数式接口带给我们最大的好处就是：可以使用极简的lambda表达式实例化接口。为什么这么说呢？我们或多或少使用过一些只有一个抽象方法的接口，比如 Runnable, ActionListener, Comparator …。比如，我们要用Comparator实现排序算法，我们的处理方式通常无外乎两种：

• 规规矩矩的写一个实现Comparator接口的java类去封装排序逻辑。若业务需要多种排序方式，那就得写多个类提供多种实现，而这些实现往往只需使用一次
• 另外一种聪明些的做法无外乎就是在需要的地方搞个匿名内部类。比如：

class Test { public static void main(String args[]) { List<Person> persons = new ArrayList<Person>();Collections.sort(persons, new Comparator<Person>(){@Overridepublic int compare(Person o1, Person o2) {return Integer.compare(o1.getAge(), o2.getAge());}});} 
} 

匿名内部类实现的代码量没有多到哪里去，结构也还算清晰。不过如今脚本语言横行无阻，无不以其简洁的语法为杀手锏，俘获程序员的欢心。jdk开发者们应该是意识到了这一点，我们从上面Comparator的实现就可以得到验证。该接口在jdk8的实现增加了FunctionalInterface注解，代表Comparator是一个函数式接口，使用者可放心的通过lambda表达式来实例化。那我们来看看使用lambda实例化所需编写的代码：

Comparator<Person> comparator = (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge());

lambda表达式

lambda这个名称是由美国数学家 Alonzo Church选择的，他在 1930 年代发展计算理论时需要一个希腊字母来表示函数抽象的运算符（λ）。所以其实没什么特殊意义，对于名称纠结症的可以放一放 了。

lambda表达式其实是快速创建函数式接口实例的语法糖； -> 就是lambda的语法标志。

lambda是什么

lambda表达式是实现函数式接口的一个快捷方式。下面这段代码是最直观的体现：

Runnable task = () -> System.out.println("i am coming...");

=号的前面是变量的声明，后面是一个lambda表达式。我们直接将lambda表达式赋值为Runnable类型的task变量，就意味着：lambda表达式是实现函数式接口的一个快捷方式。理解这一点是至关重要的。

lambda表达式语法

lambda表达式语法可抽象表示为：

(Type1 param1, Type2 param2, ..., TypeN paramN) -> {statment1;statment2;...return statmentN;
}

以Predicate判断年龄为例

Predicate<Person> predicate = (Person person) -> {Integer age = person.getAge();return age >= 18;
};

但上面的并不是我们常见的代码，那是因为我们常用的是极简风，以下是简化过程：参数类型省略-》参数占位省略-》返回语句省略。

1. 参数类型省略：因为编译器可以从上下文环境中推断出lambda表达式的参数类型

   (param1, param2, ..., paramN) -> {statment1;statment2;...return statmentN;
   }
   

   Predicate<Person> predicate = (person) -> {Integer age = person.getAge();return age >= 18;
   };
   

2. 参数占位省略：参数占位省略存在两种情况，当无参时，必须使用小括号来占位；当有一个参数时，省略小括号即可，参数直接占位。

   param -> {statment1;statment2;...return statmentN;
   }
   

   Predicate<Person> predicate = person -> {Integer age = person.getAge();return age >= 18;
   };
   

3. 表达式省略：当表达式只包含一条语句时，可以同时省略大括号和return关键字和语句结尾的分号。但需要注意的是三者必须同时省略或者同时不省略

   param -> statment;
   

   Predicate<Person> predicate = person -> person.getAge() >= 18
   

   Predicate<Person> predicate = person -> {return person.getAge() >= 18;}
   

lambda表达式与匿名类

lambda表达式与匿名类的异同集中体现在三点上：

• lambda就是为了优化匿名内部类而生，lambda要比匿名类简洁的多得多；
• lambda仅适用于函数式接口，匿名类不受限；
• 在匿名类内部，this关键字指向该抽象类实例，而lambda内部this指向闭包实例。如果需要在内部通过this关键字访问实例，必须使用匿名类；

函数式接口的使用

函数式接口为lambda表达式和方法引用(用冒号::来进行方法的调用)提供目标类型。每个功能接口都有一个抽象方法，称为该功能接口的功能方法，lambda表达式的参数和返回类型与之匹配或适配。功能接口可以在多个上下文中提供目标类型，例如赋值上下文，方法调用或强制转换上下文：

// Assignment context
Predicate<String> p = String::isEmpty;// Method invocation context
stream.filter(e -> e.getSize() > 10)...// Cast context
stream.map((ToIntFunction) e -> e.getSize())...

函数式接口可以使用lambda表达式，方法引用或构造函数引用创建功能接口的实例。

函数式接口有哪些

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

JDK1.8之前已有的函数式接口:

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

JDK1.8新增加的函数接口:

• java.util.function包

Predicate

接受一个输入参数，返回一个布尔值结果

/*** Represents a predicate (boolean-valued function) of one argument.* @param <T> the type of the input to the predicate* @since 1.8*/
@FunctionalInterface
public interface Predicate<T> {/*** Evaluates this predicate on the given argument.*/boolean test(T t);/*** Returns a composed predicate that represents a short-circuiting logical* AND of this predicate and another.  When evaluating the composed* predicate, if this predicate is {@code false}, then the {@code other}* predicate is not evaluated.*/default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}/*** Returns a predicate that represents the logical negation of this* predicate.*/default Predicate<T> negate() {return (t) -> !test(t);}/*** Returns a composed predicate that represents a short-circuiting logical* OR of this predicate and another.  When evaluating the composed* predicate, if this predicate is {@code true}, then the {@code other}* predicate is not evaluated.*/default Predicate<T> or(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) || other.test(t);}/*** Returns a predicate that tests if two arguments are equal according* to {@link Objects#equals(Object, Object)}.*/static <T> Predicate<T> isEqual(Object targetRef) {return (null == targetRef)? Objects::isNull: object -> targetRef.equals(object);}
}

示例

public static void main(String[] args) {Predicate<Person> predicate1 = (Person person) -> {Integer age = person.getAge();return age >= 18;};Predicate<Person> predicate2 = (Person person) -> {String name = person.getName();return name.startsWith("R");};Person rico = new Person();rico.setName("Rico");rico.setAge(16);System.out.println("Rico名字以R开头且年满18岁 : " + predicate1.and(predicate2).test(rico));System.out.println("Rico名字以R开头或年满18岁 : " +  predicate1.or(predicate2).test(rico));System.out.println("Rico名字不是以R开头 : " +  predicate1.negate().test(rico));
}
/*** outputRico名字以R开头且年满18岁 : falseRico名字以R开头或年满18岁 : trueRico名字不是以R开头 : true
*/

其它接口

迷糊过程

@FunctionalInterface
public interface Predicate<T> {boolean test(T t);default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}
}

使用：

Predicate<Integer> p = i -> i > 2;
System.out.println(p.and(i -> i < 10).test(5));

一开始不理解and方法的执行逻辑，and里面都已经调用过test方法了，为什么还能p.and.test, 原来and方法相当于二次函数式编程，and完毕之后其实相当于：

Predicate<Integer> p = i -> i > 2 && i < 10;
System.out.println(p.test(5));

函数式编程也不会改变java的核心：bean.method(param)，jvm只能将bean当参数，所以jvm其实还是将Lambda表达式的结果当成对象，由此表象上看似java支持了函数语句当参数。

Function

接受一个输入参数T，返回一个结果R

/*** Represents a function that accepts one argument and produces a result.* @param <T> the type of the input to the function* @param <R> the type of the result of the function* @since 1.8*/
@FunctionalInterface
public interface Function<T, R> {/*** Applies this function to the given argument.*/R apply(T t);/*** Returns a composed function that first applies the {@code before}* function to its input, and then applies this function to the result.* If evaluation of either function throws an exception, it is relayed to* the caller of the composed function.*/default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}/*** Returns a composed function that first applies this function to* its input, and then applies the {@code after} function to the result.* If evaluation of either function throws an exception, it is relayed to* the caller of the composed function.*/default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}/*** Returns a function that always returns its input argument.*/static <T> Function<T, T> identity() {return t -> t;}
}

方法表达式：

抽象方法：R=Function(T)
compose方法：V=Function(ParamFunction(T));
andThen方法：V=ParamFunction(Function(T));
identity方法：T=Function(T);

示例

public static void main(String[] args) {Function<Integer, Integer> func1 = x -> {return x + 1;};Function<Integer, Integer> func2 = y -> {return y * 7;};int x = 3, y = 5;System.out.println(func1.apply(x));System.out.println(func2.apply(y));System.out.println(func1.compose(func2).apply(x));System.out.println(func1.andThen(func2).apply(x));
}
/*** output4352228
*/

其它接口

Consumer

接受一个输入参数，没有返回值

/*** Represents an operation that accepts a single input argument and returns no* result. Unlike most other functional interfaces, {@code Consumer} is expected* to operate via side-effects.*  * @param <T> the type of the input to the operation*  * @since 1.8*/
@FunctionalInterface
public interface Consumer<T> {/*** Performs this operation on the given argument.*/void accept(T t);/*** Returns a composed {@code Consumer} that performs, in sequence, this* operation followed by the {@code after} operation. If performing either* operation throws an exception, it is relayed to the caller of the* composed operation.  If performing this operation throws an exception,* the {@code after} operation will not be performed.*/default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}
}

示例

public static void main(String[] args) {Person rico = new Person();rico.setName("Rico");rico.setAge(16);Consumer<Person> consumer = person -> System.out.println(person);consumer.accept(rico);
}/*** output{"age":16,"name":"Rico"}
*/

其它接口

Supplier

不需要任何参数，返回一个值

/*** Represents a supplier of results.** @param <T> the type of results supplied by this supplier** @since 1.8*/
@FunctionalInterface
public interface Supplier<T> {/*** Gets a result.*/T get();
}

示例

public static void main(String[] args) {Person rico = new Person();rico.setName("Rico");rico.setAge(16);Supplier<Person> supplier = () -> rico;System.out.println("supplier : " + supplier.get());
}
/*** outputsupplier : {"age":16,"name":"Rico"}
*/

其它接口