必看：深入学习Java8中的函数式接口

港控/mmm° 2022-05-23 10:05 242阅读 0赞

## 引言 ##

目前由于系统已经全面切换为JDK8，所以有必要系统的了解一下Java8的一些新特性，以便后续在日常工作中可以使用一些高级特性来提高编程效率。  
因为Java8引入了函数式接口，在java.util.function包含了几大类函数式接口声明。这里第一篇主要研究一下Function相关的接口。  
**FunctionalInterface注解**  
Java8的新引入，包含函数式的设计，接口都有@FunctionalInterface的注解。就像这个注解的注释说明一样，它注解在接口层面，且注解的接口要有且仅有一个抽象方法。具体就是说，注解在Inteface上，且interface里只能有一个抽象方法，可以有default方法。因为从语义上来讲，一个函数式接口需要通过一个***逻辑上的***方法表达一个单一函数。那理解这个单一就很重要了，单一不是说限制你一个interface里只有一个抽象方法，单是多个方法的其他方法需要是继承自Object的public方法，或者你要想绕过，就自己实现default。函数式接口自己本身一定是只有一个抽象方法。同时，如果是Object类的public方法，也是不允许的。官方的说明翻译如下：

如果一个接口I，I有一组抽象方法集合M，且这些方法都不是Object类的public签名方法，那么如果存在一个M中的方法m，满足：   m的签名是所有M中方法签名的子签名。 
       m对于M中的每个方法都是返回类型可替换的。 此时，接口I是一个函数式接口。

怎么理解，看几个例子。  
比如：你声明一个接口：  
![012b8c1a0bec4db3afcfb76918e6e6b8.png][]  
这会编译错，编译器会告诉你*no target method*。而如果加一个方法：  
![17f0153ea3594e029f27628f5668f6a2.png][]  
这就OK了，一个函数式接口声明好了。再加一个呢？  
![722584407a7d4fc49f9e451716d9cc52.png][]  
不ok，明确说了只有一个抽象方法嘛。但是如果换一种函数签名：  
![105552f28ea84e4c90accb2caca0ffde.png][]  
错误依旧，因为这个方法签名是Object类的public方法。而再改一下：  
![79b8592fa5154590a183291f2e7ebc54.png][]  
这就OK了。一个抽象方法，一个Object的public方法，相安无事。Object还有其他方法，clone方法试试会怎么样？  
![597231984d374d27aa0fbf111f8614ee.png][]  
这又不行了，因为前面明确说了，要是Object的public方法，而clone是protected的。  
所以总结一句话就是：  
函数式接口，有且仅有一个抽象方法，Object的public方法除外。  
因为Java本身支持多接口实现，你定义一个Class可以implements多个interface。所以这个限制也没什么影响，如果想约定一个函数式接口来统一，也可以做一些默认的实现来达到一个接口多个抽象方法的目的，比如下面这种做法：  
一个普通接口NonFunc：  
![5f0d5bec5cb3454884607dfb0c430053.png][]  
函数式接口Func：  
![a99073f1579d4735acc9e7e595a20ed0_th.png][]  
实现的测试类：  
![cd04c58b20d34c29a9a60c74c7f8dc2b_th.jpeg][]  
函数式接口的一大特性就是可以被lambda表达式和函数引用表达式代替。也就是说声明这样的接口，是可以灵活的以方法来传参。看个例子：  
![5961eaa7b65d469aa04ae67a2b81b88b_th.jpeg][]  
上面例子列举了一个lambda模式和一个方法引用模式，这样就可以利用函数式编程强大的能力，将方法作为参数了。  
另一个大的话题是针对上文的***逻辑上的方法***。所谓逻辑上，就是说当你出现函数式接口多重继承其他接口时，如果继承的多个接口有相同的方法签名，那么也是OK的。而这种相同签名的方法，也包括了泛型的情况，以下的声明中的Z接口，都是函数式接口。  
![0dc3e1f4871a4aa7bc7082c4802b9a35.png][]  
但是要注意的是，这种泛型的支持，是因为函数式接口的官方声明规范里要求类型可替换和子签名，不是因为泛型擦除。  
比如下面的例子就不是函数式接口：  
![ba47c313487c47a3bcfafc498be7bc62.jpeg][]  
最后，Java8里关于函数式接口的包是java.util.function，里面全部是函数式接口。主要包含几大类：Function、Predicate、Supplier、Consumer和\*Operator（没有Operator接口，只有类似BinaryOperator这样的接口）。后面依次展开详细说明一下。  
**Function**  
关于Function接口，其接口声明是一个函数式接口，其抽象表达函数为  
![ff5302c5d96348c88d35587658b13fd2.png][]  
函数意为将参数T传递给一个函数，返回R。即  
**R=Function(T)**  
其默认实现了3个default方法，分别是**compose**、**andThen**和**identity**，对应的函数表达为：compose对应**V=Function(ParamFunction(T))**，体现嵌套关系；andThen对应**V=ParamFunction(Function(T))**，转换了嵌套的顺序；还有identity对应了一个传递自身的函数调用对应Function(T)=T。从这里看出来，compose和andThen对于两个函数f和g来说，f.compose(g)等价于g.andThen(f)。看个例子：  
![54749aa942fd4ae9b52910a5f9b2e5b6.jpeg][]  
**高阶函数**  
只是普通的lambda表达式，其能力有限。我们会希望引入更强大的函数能力——高阶函数，可以定义任意同类计算的函数。  
比如这个函数定义，参数是z，返回值是一个Function，这个Function本身又接受另一个参数y，返回z+y。于是我们可以根据这个函数，定义任意加法函数：  
![ac75024f4a1d49f79402c23628742072.jpeg][]  
由于高阶函数接受一个函数作为参数，结果返回另一个函数，所以是典型的函数到函数的映射。  
BiFunction提供了二元函数的一个接口声明，举例来说：  
![197523ac84f347bb9b911e6976b8927d.png][]  
其输出结果将是：f(z)=x\*y, when x=3,y=5, then f(z)=15。  
二元函数没有compose能力，只是默认实现了andThen。  
有了一元和二元函数，那么可以通过组合扩展出更多的函数可能。  
Function接口相关的接口包括：

**BiFunction ：R apply(T t, U u);**接受两个参数，返回一个值，代表一个二元函数；  
**DoubleFunction ：R apply(double value);**只处理double类型的一元函数；  
**IntFunction ：R apply(int value);**只处理int参数的一元函数；  
**LongFunction ：R apply(long value);**只处理long参数的一元函数；  
**ToDoubleFunction：double applyAsDouble(T value);**返回double的一元函数；  
**ToDoubleBiFunction：double applyAsDouble(T t, U u);**返回double的二元函数；  
**ToIntFunction：int applyAsInt(T value);**返回int的一元函数；  
**ToIntBiFunction：int applyAsInt(T t, U u);**返回int的二元函数；  
**ToLongFunction：long applyAsLong(T value);**返回long的一元函数；  
**ToLongBiFunction：long applyAsLong(T t, U u);**返回long的二元函数；  
**DoubleToIntFunction：int applyAsInt(double value);**接受double返回int的一元函数；  
**DoubleToLongFunction：long applyAsLong(double value);**接受double返回long的一元函数；  
**IntToDoubleFunction：double applyAsDouble(int value);**接受int返回double的一元函数；  
**IntToLongFunction：long applyAsLong(int value);**接受int返回long的一元函数；  
**LongToDoubleFunction：double applyAsDouble(long value);**接受long返回double的一元函数；  
**LongToIntFunction：int applyAsInt(long value);**接受long返回int的一元函数；

**Operator**  
Operator其实就是Function，函数有时候也叫作算子。算子在Java8中接口描述更像是函数的补充，和上面的很多类型映射型函数类似。  
算子Operator包括：UnaryOperator和BinaryOperator。分别对应单元算子和二元算子。  
算子的接口声明如下：  
![be923310193e40a8a79646a56637b151.png][]  
二元算子的声明：  
![ccc7c75d5f854cfb9c9768830a46775b_th.jpeg][]  
很明显，算子就是一个针对同类型输入输出的一个映射。在此接口下，只需声明一个泛型参数T即可。对应上面的例子：  
![bbab03dd95824b719dfdfecf6f91d8d1_th.jpeg][]  
例子里补充一点的是，BinaryOperator提供了两个默认的static快捷实现，帮助实现二元函数min(x,y)和max(x,y)，使用时注意的是排序器可别传反了：）  
其他的Operator接口：（不解释了）  
**LongUnaryOperator：long applyAsLong(long operand);**   
**IntUnaryOperator：int applyAsInt(int operand);**  
**DoubleUnaryOperator：double applyAsDouble(double operand);**  
**DoubleBinaryOperator：double applyAsDouble(double left, double right);**  
**IntBinaryOperator：int applyAsInt(int left, int right);**  
**LongBinaryOperator：long applyAsLong(long left, long right);**

**Predicate**  
predicate是一个谓词函数，主要作为一个谓词演算推导真假值存在，其意义在于帮助开发一些返回bool值的Function。本质上也是一个单元函数接口，其抽象方法test接受一个泛型参数T，返回一个boolean值。等价于一个Function的boolean型返回值的子集。  
![dd98482e6b78438e960e12c6e206f13e.png][]  
其默认方法也封装了and、or和negate逻辑。写个小例子看看：  
![7839cfba31a54de49d6e8bda8202b389_th.jpeg][]  
Predicate在Stream中有应用，Stream的filter方法就是接受Predicate作为入参的。这个具体在后面使用Stream的时候再分析深入。  
其他Predicate接口：  
BiPredicate：boolean test(T t, U u);接受两个参数的二元谓词  
DoublePredicate：boolean test(double value);入参为double的谓词函数  
IntPredicate：boolean test(int value);入参为int的谓词函数  
LongPredicate：boolean test(long value);入参为long的谓词函数  
**Consumer**  
看名字就可以想到，这像谓词函数接口一样，也是一个Function接口的特殊表达——接受一个泛型参数，不需要返回值的函数接口。  
![289a5e7cfca14ea1911d8b691c7a5042.png][]  
这个接口声明太重要了，对于一些纯粹consume型的函数，没有Consumer的定义真无法被Function家族的函数接口表达。因为Function一定需要一个泛型参数作为返回值类型（当然不排除你使用Function来定义，但是一直返回一个无用的值）。比如下面的例子，如果没有Consumer，类似的行为使用Function表达就一定需要一个返回值。  
![302f866e17104aee80e42c8b20053674_th.png][]  
其他Consumer接口：  
**BiConsumer：void accept(T t, U u);**接受两个参数  
**DoubleConsumer：void accept(double value);**接受一个double参数  
**IntConsumer：void accept(int value);**接受一个int参数  
**LongConsumer：void accept(long value);**接受一个long参数  
**ObjDoubleConsumer：void accept(T t, double value);**接受一个泛型参数一个double参数  
**ObjIntConsumer：void accept(T t, int value);**接受一个泛型参数一个int参数  
**ObjLongConsumer：void accept(T t, long value);**接受一个泛型参数一个long参数

**Supplier**  
最后说的是一个叫做Supplier的函数接口，其声明如下：  
![ecc9f0ea65584d2bbf55e0bf0c75f7ad.png][]  
其简洁的声明，会让人以为不是函数。这个抽象方法的声明，同Consumer相反，是一个只声明了返回值，不需要参数的函数（这还叫函数？）。也就是说Supplier其实表达的不是从一个参数空间到结果空间的映射能力，而是表达一种生成能力，因为我们常见的场景中不止是要consume（Consumer）或者是简单的map（Function），还包括了new这个动作。而Supplier就表达了这种能力。  
比如你要是返回一个常量，那可以使用类似的做法：  
这保证supplier对象输出的一直是1。  
如果是要利用构造函数的能力呢？就可以这样：  
![4281b4926d2c47c3900d69a9e128cd37.png][]  
这样的输出可以看到，全部的对象都是new出来的。  
这样的场景在Stream计算中会经常用到，具体在分析Java 8中Stream的时候再深入。  
其他Supplier接口：  
**BooleanSupplier：boolean getAsBoolean();**返回boolean  
**DoubleSupplier：double getAsDouble();**返回double  
**IntSupplier：int getAsInt();**返回int  
**LongSupplier：long getAsLong();**返回long

**总结**  
整个函数式接口的大概总结如下：  
![a2628994ebda43eca98c787a8b2577ba_th.jpeg][]

原文链接：[http://www.sohu.com/a/123958799\_465959][http_www.sohu.com_a_123958799_465959]

[012b8c1a0bec4db3afcfb76918e6e6b8.png]: /images/20220523/cc5d7e716ad2465e9b57881ad16c6a09.png
[17f0153ea3594e029f27628f5668f6a2.png]: /images/20220523/2340458d6a3d41f6a582938f915d7417.png
[722584407a7d4fc49f9e451716d9cc52.png]: /images/20220523/d20428ba66ba46c79b632b14cb4a2a6d.png
[105552f28ea84e4c90accb2caca0ffde.png]: /images/20220523/52451ed635b64ec2aeb165836f8157e1.png
[79b8592fa5154590a183291f2e7ebc54.png]: /images/20220523/707774ed157a44f7abd26af7b31b8c98.png
[597231984d374d27aa0fbf111f8614ee.png]: /images/20220523/42c0dd9776df497fb995c6738348a111.png
[5f0d5bec5cb3454884607dfb0c430053.png]: /images/20220523/0073b6c637b84ed4b6150927f0764a4f.png
[a99073f1579d4735acc9e7e595a20ed0_th.png]: /images/20220523/d426588b543d4d5481cf6c5472595d17.png
[cd04c58b20d34c29a9a60c74c7f8dc2b_th.jpeg]: /images/20220523/2ea3ae6e568348b5b6394d7236f98ddf.png
[5961eaa7b65d469aa04ae67a2b81b88b_th.jpeg]: /images/20220523/e2e988cf5532455cab31949a8244a5c5.png
[0dc3e1f4871a4aa7bc7082c4802b9a35.png]: /images/20220523/df79ba6a74e349d1a899dd011876e737.png
[ba47c313487c47a3bcfafc498be7bc62.jpeg]: /images/20220523/9a5d083955454ccebc9b884119e4576e.png
[ff5302c5d96348c88d35587658b13fd2.png]: /images/20220523/df9e0890d5574bc58f148172992135ca.png
[54749aa942fd4ae9b52910a5f9b2e5b6.jpeg]: /images/20220523/3064c31873c84193a7e1b92a9a01e872.png
[ac75024f4a1d49f79402c23628742072.jpeg]: /images/20220523/f29041d9ff1a452db9b9027f85a9494d.png
[197523ac84f347bb9b911e6976b8927d.png]: /images/20220523/110ac5abbf774555a8f0a0e437ee83f7.png
[be923310193e40a8a79646a56637b151.png]: /images/20220523/d08e7c45da1b4650a3fb077fd2063048.png
[ccc7c75d5f854cfb9c9768830a46775b_th.jpeg]: /images/20220523/0380f0fa420e4c87b031cc6556798af9.png
[bbab03dd95824b719dfdfecf6f91d8d1_th.jpeg]: /images/20220523/90caf1050c514476957bbc26b4958724.png
[dd98482e6b78438e960e12c6e206f13e.png]: /images/20220523/981021c4b0d743fd9d000a64400702b2.png
[7839cfba31a54de49d6e8bda8202b389_th.jpeg]: /images/20220523/d64566d6ff264f1ebbaedfafff95d207.png
[289a5e7cfca14ea1911d8b691c7a5042.png]: /images/20220523/7e4f2ccb9c504aa284af52e6a2e38f1c.png
[302f866e17104aee80e42c8b20053674_th.png]: /images/20220523/57bb21b9225b414c8162094376006c49.png
[ecc9f0ea65584d2bbf55e0bf0c75f7ad.png]: /images/20220523/750bea17201a44d798f303c690deabd4.png
[4281b4926d2c47c3900d69a9e128cd37.png]: /images/20220523/56e75805e17949bea15b7096af340456.png
[a2628994ebda43eca98c787a8b2577ba_th.jpeg]: /images/20220523/6cde178bc1f343ef973177b4195e80a8.png
[http_www.sohu.com_a_123958799_465959]: http://www.sohu.com/a/123958799_465959