预备知识
背景
Lambda 的设计者们为了让现有的功能与 Lambda 表达式良好兼容，考虑了很多方法，于是产生了函数接口这个概念。
什么是函数式接口？
函数式接口指的是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，这样的接口可以隐式转换为 Lambda 表达式。
但是在实践中，函数式接口非常脆弱，只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface，举个简单的函数式接口的定义：
@FunctionalInterface
public interface GreetingService {
void sayMessage(String message);
}
Java7 只能通过匿名内部类进行编程，例如：
GreetingService greetService = new GreetingService() {
@Override
public void sayMessage(String message) {
System.out.println("Hello " + message);
}
};
greetService.sayMessage("world");
Java8 可以采用 Lambda 表达方进行编程，例如：
GreetingService greetService = message -> System.out.println("Hello " + message);
greetService.sayMessage("world");
目前 Java 库中的所有相关接口都已经带有这个注解了，实践上java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子!
@FunctionalInterface注解
Java 8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。
正确例子，没有报错：
/**
* @Description FunctionalInterface
* @Author vchicken
* @Date 2022/9/24 14:46
*/
@FunctionalInterface
public interface TestFunctionalInterface {
void sayMessage(String message);
}
错误例子，接口中包含了两个抽象方法，违反了函数式接口的定义，Eclipse报错提示其不是函数式接口。
提醒：加不加@FunctionalInterface对于接口是不是函数式接口没有影响，该注解知识提醒编译器去检查该接口是否仅包含一个抽象方法。
四大函数式接口
1.Function接口
什么是Function接口？
从Function接口的源代码，我们可以看出，JDK1.8之后才加入这个接口。Functional接口类中只有一个抽象方法待实现，符合函数式接口(指的是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口)，因此Function接口可以用Lambda表达式——这个方法就是apply。
从源码可以看出，入参和出参类型，用泛型动态指定。apply的具体逻辑就相当于是入参转化为出参的具体逻辑。也就相当于是y = f(x)这个里面的，映射法则f。具体逻辑需要我们用匿名内部类或者Lambda，写方法体来实现。因此这个接口又叫函数型接口。
下面我们来用代码举栗如何使用Function接口：
public class FunctionTest {
public static void main(String[] args) {
// 如果入参为null，则回参为0，否则返回入参的值作为出参
Function<Integer, Integer> function1 = s -> s == null ? 0 : s;
// 将入参的值+1后作为回参返回
Function<Integer, Integer> function2 = s -> s + 1;
// 如果入参为null，则回参为""，否则返回入参的值作为出参
Function<String, String> function3 = s -> s == null ? "空的" : s;
System.out.println(function1.apply(null));
System.out.println(function1.apply(100));
System.out.println(function2.apply(10));
System.out.println(function3.apply(null));
System.out.println(function3.apply("hello world!"));
// andThen是先执行前面的操作，然后执行andThen之后的操作
Function<Integer, Integer> first = x -> x * x;
Function<Integer, Integer> after = y -> y * 2;
System.out.println(first.apply(3));
System.out.println(after.apply(3));
int res = first.andThen(after).apply(4);
System.out.println(res);
}
}
执行结果
0
100
11
空的
hello world!
9
6
32
从上面的栗子我们可以看出：
Java把这些映射规则，也就是y = f(x)中的【f】抽象成了这个Function接口的apply逻辑。然后x和y，自变量和因变量，也就是入参出参，Java使用了扩展性更强的泛型参数类型，而不是固定Object入参出参。因为固定Object的话还要涉及到类型转换，还有可能报ClassCast异常，很麻烦
再看一个栗子：
/**
* @author vchicken
* @version 1.0
* @description FunctionTest
* @date 2022/11/10 12:10:06
*/
public class FunctionTest<T,R> {
public static void main(String[] args) {
FunctionTest<Integer, Integer> functionTest1 = new FunctionTest<>();
System.out.println(functionTest1.functionTest(null, s -> s == null ? 0 : s));
System.out.println(functionTest1.functionTest(100, s -> s == null ? 0 : s));
System.out.println(functionTest1.functionTest(10, s -> s + 1));
FunctionTest<String, String> functionTest2 = new FunctionTest<>();
System.out.println(functionTest2.functionTest(null, s -> s == null ? "空的" : s));
System.out.println(functionTest2.functionTest("hello world!", s -> s == null ? "空的" : s));
}
public R functionTest(T in,Function<T,R> function){
return function.apply(in);
}
}
执行结果：
0
100
11
空的
hello world!
结合两个栗子我们可以看出来：
我们可以使用Function接口来将同一个方法的处理逻辑抽象出来，在调用方法的时候，将处理逻辑以Lambda表达式的形式传入，实现同一个方法可以处理不同的代码逻辑，而且使用泛型来表示方法的出入参，可以避免不必要的类型转换和异常发生。@vchicken
Function接口在JDK中的应用
在JDK1.8中的新属性Stream中，就使用到了Function接口，看下面的源码：
通过一个例子来看看怎样使用map这个接口
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(-1,0,1,2,3,4);
Stream<Integer> stream1 = stream.map(integer -> integer + 1);
stream1.forEach(System.out::println);
}
执行结果：
0
1
2
3
4
5
案例：将数组中的数，依次平方，等到一个一个新的数组
List<Integer> myList = new ArrayList<>();
myList.add(-2);
myList.add(0);
myList.add(1);
myList.add(3);
myList.add(5);
myList.add(7);
List<Integer> collect = myList.stream().map(integer -> integer*integer).collect(Collectors.toList());
collect.forEach(System.out::println);
执行结果：
4
0
1
9
25
49
2.Consumer接口
什么是Consumer接口？
从源码可以看出，Consumer与Function类似，只有一个accept抽象方法待实现，只不过唯一的区别是，Consumer的accept使用void修饰，没有返回值，而Function有返回值。
Consumer接口又称为消费型接口，顾名思义，入参传入后，被accept方法消费掉了，什么都没得到。
举个栗子：
public static void main(String[] args) {
Consumer<Object> consumer1 = new Consumer<Object>() {
@Override
public void accept(Object o) {
System.out.println("这次消费了:" + o.toString());
}
};
consumer1.accept("100w元在双十一！这下穷死了！");
Consumer<String> consumer2 = s -> System.out.println("这次消费了:" + s);
consumer2.accept("120w元在双十二！又穷死了！");
}
执行结果：
这次消费了:100w元在双十一！这下穷死了！
这次消费了:120w元在双十二！又穷死了！
同样的，我们可以提取公共方法为：
/**
* @author vchicken
* @version 1.0
* @description ComsumerTest
* @date 2022/11/10 17:14:11
*/
public class ConsumerTest<T> {
public static void main(String[] args) {
ConsumerTest<String> consumerTest = new ConsumerTest<>();
consumerTest.accept("100w元在双十一！这下穷死了！", s -> System.out.println("这次消费了:" + s));
consumerTest.accept("120w元在双十二！又穷死了！", s -> System.out.println("这次消费了:" + s));
}
public void accept(T in, Consumer<? super T> consumer) {
consumer.accept(in);
}
}
执行结果：
这次消费了:100w元在双十一！这下穷死了！
这次消费了:120w元在双十二！又穷死了！
Consumer接口在JDK中的应用
同样的，我们以Stream中的forEach为例，看下面的例子：
Stream<Integer> stream = Stream.of(-1,0,1,2,3,4);
stream.forEach(s-> System.out.println(s));
执行结果：
-1
0
1
2
3
4
同样的我们还可以使用方法引用来打印，效果一致
stream.forEach(System.out::println);
对于方法引用不了解的亲，也可以阅读这篇文章Java8 新特性 - 方法引用 @vchicken
3.Suppiler接口
什么是Suppiler接口？
既然我们上面说到了Consumer为消费型接口，按照惯例，那肯定有生产型接口或者也可以成为供给型接口——Supplier接口，看下图源码：
由源码我们可以看出，Supplier接口只有一个待实的get方法，属于无参有返回值的抽象方法。下面看一个例子：
public static void main(String[] args) {
// 生成一个字符串
Supplier<String> supplier1 = () -> "abcde";
// 生成一个随机数
Supplier<Integer> supplier2 = () -> new Random().nextInt(10);
// 产生一个运行时异常
Supplier<RuntimeException> supplier3 = () -> new RuntimeException();
System.out.println(supplier1.get());
System.out.println(supplier2.get().intValue());
System.out.println(supplier3.get());
}
执行结果：
abcde
2
java.lang.RuntimeException
Supplier接口在JDK中的应用
generate方法返回一个无限连续的无序流，其中每个元素由提供的供应商(Supplier)生成。generate方法用于生成常量流和随机元素流。看下面例子：
public static void main(String[] args) {
// 生成随机数
Stream.generate(() -> new Random().nextInt(10));
stream.forEach(System.out::println);
// 生成随机布尔流
Stream.generate(() -> new Random().nextBoolean())
.forEach(System.out::println);
// 生成常量流
Stream.generate(() -> "Hello World!")
.forEach(System.out::println);
}
执行结果：
2
5
1
--- #略
true
false
true
--- #略
Hello World!
Hello World!
Hello World!
--- #略
由于generate返回无限连续流，为了限制流中元素的数量，我们可以使用Stream.limit方法
public static void main(String[] args) {
Stream.generate(() -> new Random().nextInt(10)).limit(3)
.forEach(e -> System.out.println(e));
Stream.generate(() -> new Random().nextBoolean()).limit(3)
.forEach(e -> System.out.println(e));
Stream.generate(() -> "Hello World!").limit(3)
.forEach(e -> System.out.println(e));
}
执行结果：
3
6
3
true
false
false
Hello World!
Hello World!
Hello World!
4.Predicate接口
什么是Predicate接口？
Predicate接口又称为断言型接口，test()方法有参但是返回值类型是固定的boolean，看下面例子：
public static void main(String[] args) {
Predicate<String> predicate = (s) -> s.length() > 0;
// 测试字符串的长度是否>0
System.out.println(predicate.test("hello"));
// 结果取反
System.out.println(predicate.negate().test("hello"));
System.out.println("=====or / and======");
System.out.println(predicate.test(""));
// 增加或判断，二者满足其一则为true
System.out.println(predicate.or(s -> s.equals("")).test(""));
// 增加与判断，二者都满足则为true
System.out.println(predicate.and(s -> s.equals("hello")).test(""));
System.out.println(predicate.and(s -> s.equals("hello")).test("hello"));
System.out.println("=====isEqual======");
// 判断是否相等
System.out.println(Predicate.isEqual("hello").test(""));
System.out.println(Predicate.isEqual("hello").test("hello"));
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();
}
执行结果：
true
false
=====or / and======
false
true
false
true
=====isEqual======
false
true
Predicate接口在JDK中的应用
Stream中的filter方法，用来过滤不满足条件的元素，使用Predicate传入过滤条件。看下面例子：
Stream<Integer> stream = Stream.of(-1, 0, 1, 2, 3, 4);
stream.filter(s -> s > 0).forEach(System.out::println);
执行结果：
1
2
3
4
总结
关于JDK1.8为什么要新增这四大内置函数式接口，其实就是Java的开发者将常用于代码的一些普遍场景抽象出来成为接口，而我们可以根据实际业务需求，实现这些接口的具体逻辑。通过lambda表达式的方式，也可以使得代码更加简洁。JDK中的函数式接口还有很多，但基本都是在四大函数式接口的基础之上加以拓展，有兴趣的童鞋可以自行研究。
四大函数式接口的比较
| 函数式接口 | 对应程序逻辑的抽象 | 具体场景 |
|---|---|---|
| Function | 程序中映射逻辑的抽象 | 比如我们写得很多的函数：接收入参，返回出参，方法代码块就是一个映射的具体逻辑。 |
| Predicate | 程序中判断逻辑的抽象 | 比如各种if判断，对于一个参数进行各种具体逻辑的判定，最后返回一个if else能使用的布尔值 |
| Consumer | 程序中的消费型逻辑的抽象 | 就比如Collection体系的ForEach方法，将每一个元素取出，交给Consumer指定的消费逻辑进行消费 |
| Suppiler | 程序中的生产逻辑的抽象 | 就比如最常用的，new对象，这就是一个很经典的生产者逻辑，至于new什么，怎么new，这就是Suppiler中具体逻辑的写法了 |