Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即Java不但可以支持OOP还可以支持OOF（面向函数编程）。

在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。

在Java8中，Lambda表达式就是一个函数式接口的实例。只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口适用于函数式编程场景的接口。可以通过 Lambda 表达式来创建该接口的对象。

若 Lambda 表达式抛出一个受检异常，即非运行时异常，那么该异常需要在目标接口的抽象方法上进行声明。

格式

只要确保接口中有且仅有一个抽象方法即可（可以有其他默认方法、静态方法、私有方法）：

修饰符 interface 接口名称 {public abstract 返回值类型 方法名称(可选参数信息); // 其他非抽象方法内容
}

由于接口当中抽象方法的public abstract是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface { void myMethod();
}

@FunctionalInterface注解

与@Override注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解，可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

// 函数式接口的定义：
@FunctionalInterface
public interface MyFunctionalInterface { void myMethod();
}// 函数式接口的使用：
public class DemoFunctionalInterface {// 使用自定义的函数式接口作为方法参数private static void doSomething(MyFunctionalInterface inter) { inter.myMethod(); // 调用自定义的函数式接口方法}public static void main(String[] args) {// 调用使用函数式接口的方法doSomething(() ‐> System.out.println("Lambda执行啦！"));}
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

四大核心函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在在java.util.function包中被提供。

Supplier接口

java.util.function.Supplier接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

import java.util.function.Supplier;
public class Demo08Supplier {private static String getString(Supplier function) { return function.get();}public static void main(String[] args) {String msgA = "Hello";String msgB = "World";System.out.println(getString(() ‐> msgA + msgB));}
}

Consumer接口

java.util.function.Consumer接口则与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

抽象方法accept

Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。基本使用如：

import java.util.function.Consumer;
public class Demo09Consumer {private static void method(String name, Consumer con) { con.accept(name);}public static void main(String[] args) {method("乔木先生", name -> System.out.println("我的名字是" + name));}
}

默认方法andThen

如果一个方法的参数和返回值全都是Consumer类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是Consumer接口中的default方法andThen。要想实现组合，需要两个或多个Lambda表达式即可，而andThen的语义正是“一步接一步”操作。例如两个步骤组合的情况：

import java.util.function.Consumer;
public class Demo10ConsumerAndThen {private static void consumeString(Consumer one, Consumer two) { one.andThen(two).accept("Hello");}public static void main(String[] args) {consumeString(s ‐> System.out.println(s.toUpperCase()),s ‐> System.out.println(s.toLowerCase()));}
}

运行结果将会首先打印完全大写的HELLO，然后打印完全小写的hello。当然，通过链式写法可以实现更多步骤的组合。

Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate接口。

抽象方法test

Predicate接口中包含一个抽象方法：boolean test(T t)。用于条件判断的场景：

import java.util.function.Predicate;
public class Demo15PredicateTest {private static void method(Predicate predicate) { boolean veryLong = predicate.test("HelloWorld");System.out.println("字符串很长吗：" + veryLong);}public static void main(String[] args) {method(s ‐> s.length() > 5);}
}

条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。

默认方法and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个Predicate条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法and。

如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：

import java.util.function.Predicate;
public class Demo16PredicateAnd {private static void method(Predicate one, Predicate two) { boolean isValid = one.and(two).test("Helloworld");System.out.println("字符串符合要求吗：" + isValid);}public static void main(String[] args) {method(s ‐> s.contains("H"), s ‐> s.contains("W"));}
}

默认方法or

与and的“与”类似，默认方法or实现逻辑关系中的“或”。

如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将and修改为or名称即可，其他都不变：

import java.util.function.Predicate;
public class Demo16PredicateAnd {private static void method(Predicate one, Predicate two) { boolean isValid = one.or(two).test("Helloworld");System.out.println("字符串符合要求吗：" + isValid);}public static void main(String[] args) {method(s ‐> s.contains("H"), s ‐> s.contains("W"));}
}

默认方法negate

从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行!取反而已。一定要在test方法调用之前调用negate方法，正如and和or方法一样：

import java.util.function.Predicate;
public class Demo17PredicateNegate {private static void method(Predicate predicate) {boolean veryLong = predicate.negate().test("HelloWorld"); System.out.println("字符串很长吗：" + veryLong);}public static void main(String[] args) {method(s ‐> s.length() < 5);}
}

Function接口

java.util.function.Function接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

抽象方法apply

Function 接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。

使用的场景例如：将String类型转换为Integer类型。

import java.util.function.Function;
public class Demo11FunctionApply {private static void method(Function function) { int num = function.apply("10");System.out.println(num + 20);}public static void main(String[] args) {method(s ‐> Integer.parseInt(s));}
}

当然，最好是通过方法引用的写法。

默认方法andThen

Function接口中有一个默认的andThen方法，用来进行组合操作。

import java.util.function.Function;
public class Demo12FunctionAndThen {private static void method(Function one, Function two) { int num = one.andThen(two).apply("10");System.out.println(num + 20);}public static void main(String[] args) {method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);}
}

第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过andThen按照前后顺序组合到了一起。

Function的前置条件泛型和后置条件泛型可以相同。

其他接口