函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。
一、基本定义和使用
import java.util.List; public class MyDemo { @FunctionalInterface interface GreetingService { void sayMessage(String message); } public static void main(String[] args) { GreetingService greetService1 = message -> System.out.println("Hello " + message); greetService1.sayMessage("World"); } }
二、在Java8 以前，已有大量函数式接口形式的接口（接口中只存在一个抽象方法），只是没有强制声明
- 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
三、Java8 新增加的函数接口在java.util.function 包下，它包含了很多类：
| 序号 | 接口 & 描述 |
|---|---|
| 1 | BiConsumer<T,U>
代表了一个接受两个输入参数的操作，并且不返回任何结果 |
| 2 | BiFunction<T,U,R>
代表了一个接受两个输入参数的方法，并且返回一个结果 |
| 3 | BinaryOperator<T>
代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果 |
| 4 | BiPredicate<T,U>
代表了一个两个参数的boolean值方法 |
| 5 | BooleanSupplier
代表了boolean值结果的提供方 |
| 6 | Consumer<T>
代表了接受一个输入参数并且无返回的操作 |
| 7 | DoubleBinaryOperator
代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。 |
| 8 | DoubleConsumer
代表一个接受double值参数的操作，并且不返回结果。 |
| 9 | DoubleFunction<R>
代表接受一个double值参数的方法，并且返回结果 |
| 10 | DoublePredicate
代表一个拥有double值参数的boolean值方法 |
| 11 | DoubleSupplier
代表一个double值结构的提供方 |
| 12 | DoubleToIntFunction
接受一个double类型输入，返回一个int类型结果。 |
| 13 | DoubleToLongFunction
接受一个double类型输入，返回一个long类型结果 |
| 14 | DoubleUnaryOperator
接受一个参数同为类型double,返回值类型也为double 。 |
| 15 | Function<T,R>
接受一个输入参数，返回一个结果。 |
| 16 | IntBinaryOperator
接受两个参数同为类型int,返回值类型也为int 。 |
| 17 | IntConsumer
接受一个int类型的输入参数，无返回值 。 |
| 18 | IntFunction<R>
接受一个int类型输入参数，返回一个结果 。 |
| 19 | IntPredicate
：接受一个int输入参数，返回一个布尔值的结果。 |
| 20 | IntSupplier
无参数，返回一个int类型结果。 |
| 21 | IntToDoubleFunction
接受一个int类型输入，返回一个double类型结果 。 |
| 22 | IntToLongFunction
接受一个int类型输入，返回一个long类型结果。 |
| 23 | IntUnaryOperator
接受一个参数同为类型int,返回值类型也为int 。 |
| 24 | LongBinaryOperator
接受两个参数同为类型long,返回值类型也为long。 |
| 25 | LongConsumer
接受一个long类型的输入参数，无返回值。 |
| 26 | LongFunction<R>
接受一个long类型输入参数，返回一个结果。 |
| 27 | LongPredicate
R接受一个long输入参数，返回一个布尔值类型结果。 |
| 28 | LongSupplier
无参数，返回一个结果long类型的值。 |
| 29 | LongToDoubleFunction
接受一个long类型输入，返回一个double类型结果。 |
| 30 | LongToIntFunction
接受一个long类型输入，返回一个int类型结果。 |
| 31 | LongUnaryOperator
接受一个参数同为类型long,返回值类型也为long。 |
| 32 | ObjDoubleConsumer<T>
接受一个object类型和一个double类型的输入参数，无返回值。 |
| 33 | ObjIntConsumer<T>
接受一个object类型和一个int类型的输入参数，无返回值。 |
| 34 | ObjLongConsumer<T>
接受一个object类型和一个long类型的输入参数，无返回值。 |
| 35 | Predicate<T>
接受一个输入参数，返回一个布尔值结果。 |
| 36 | Supplier<T>
无参数，返回一个结果。 |
| 37 | ToDoubleBiFunction<T,U>
接受两个输入参数，返回一个double类型结果 |
| 38 | ToDoubleFunction<T>
接受一个输入参数，返回一个double类型结果 |
| 39 | ToIntBiFunction<T,U>
接受两个输入参数，返回一个int类型结果。 |
| 40 | ToIntFunction<T>
接受一个输入参数，返回一个int类型结果。 |
| 41 | ToLongBiFunction<T,U>
接受两个输入参数，返回一个long类型结果。 |
| 42 | ToLongFunction<T>
接受一个输入参数，返回一个long类型结果。 |
| 43 | UnaryOperator<T>
接受一个参数为类型T,返回值类型也为T。 |
四、对于Java8中提供的这么多函数式接口，开发中常用的函数式接口有以下几个
Predicate，Consumer，Function，Supplier
五、函数式接口实例
1. Predicate
java.util.function.Predicate<T> 接口定义了一个名叫 test 的抽象方法，它接受泛型 T 对象，并返回一个boolean值。在对类型 T进行断言判断时，可以使用这个接口，通常称为断言性接口 。
import java.util.function.*; public class MyDemo { public static void main(String[] args) { Predicate<String> p01=(str)->str.isEmpty()||str.trim().isEmpty(); System.out.println(p01.test("")); System.out.println(p01.test(" ")); System.out.println(p01.test("admin")); } }
2. Consumer
java.util.function.Consumer<T>接口定义了一个名叫 accept 的抽象方法，它接受泛型T，没有返回值(void)。如果需要访问类型 T 的对象，并对其执行某些操作，可以使用这个接口，通常称为消费性接口。
import java.util.*; import java.util.function.*; public class MyDemo { public static void main(String[] args) { Consumer<Collection> c01 = (collection) -> { if (null != collection && collection.size() > 0) { for (Object c : collection) { System.out.println(c); } } }; List<String> list = new ArrayList<String>(); list.add("张三"); list.add("李四"); list.add("赵五"); // 遍历list 输出元素内容到控制台 c01.accept(list); } }
3. Function
java.util.function.Function<T, R>接口定义了一个叫作apply的方法，它接受一个泛型T的对象，并返回一个泛型R的对象。如果需要定义一个Lambda，将输入的信息映射到输出，可以使用这个接口，通常称为功能性接口。
import java.util.*; import java.util.function.*; public class MyDemo { public static void main(String[] args) { Function<String,String> f01=(password)->Base64.getEncoder().encodeToString(password.getBytes()); System.out.println(f01.apply("123456")); } }
4. Supplier
java.util.function.Supplier<T>接口定义了一个get的抽象方法，它没有参数，返回一个泛型T的对象，这类似于一个工厂方法，通常称为功能性接口。
import java.util.*; import java.util.function.*; public class MyDemo { // 随机产生totalNumber个整型集合 public static List<Integer> supplier(int totalNumber, Supplier<Integer> sup){ List<Integer> list = new ArrayList<Integer>(); for (int i = 0; i < totalNumber; i++) { list.add(sup.get()); } return list; } public static void main(String[] args) { Random ran = new Random(); List<Integer> list = supplier(10, () -> ran.nextInt(10)); for (Integer i : list) { System.out.println(i); } } }
本文参考：
https://www.cnblogs.com/lotbyte/p/10656999.html
https://www.runoob.com/java/java8-functional-interfaces.html