Lambda函数式接口

悠悠 2021-08-13 13:57 383阅读 0赞

### 函数式接口 ###

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。  
函数式接口可以被隐式转换为 lambda 表达式。  
Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。  
如定义了一个函数式接口如下：

@FunctionalInterface
    interface GreetingService 
    { 
        void sayMessage(String message);
    }

那么就可以使用Lambda表达式来表示该接口的一个实现(注：JAVA 8 之前一般是用匿名类实现的)：

GreetingService greetService1 = message -> System.out.println("Hello " + message);

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

JDK 1.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

JDK 1.8 新增加的函数接口：

*  java.util.function

java.util.function 它包含了很多类，用来支持 Java的 函数式编程，该包中的函数式接口有：

<table> 
 <tbody> 
 <tr> 
 <th>序号</th> 
 <th>接口 &amp; 描述</th> 
 </tr> 
 <tr> 
 <td>1</td> 
 <td>BiConsumer&lt;T,U&gt; 代表了一个接受两个输入参数的操作，并且不返回任何结果 </td> 
 </tr> 
 <tr> 
 <td>2</td> 
 <td>BiFunction&lt;T,U,R&gt; 代表了一个接受两个输入参数的方法，并且返回一个结果 </td> 
 </tr> 
 <tr> 
 <td>3</td> 
 <td>BinaryOperator&lt;T&gt; 代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果 </td> 
 </tr> 
 <tr> 
 <td>4</td> 
 <td>BiPredicate&lt;T,U&gt; 代表了一个两个参数的boolean值方法 </td> 
 </tr> 
 <tr> 
 <td>5</td> 
 <td>BooleanSupplier 代表了boolean值结果的提供方 </td> 
 </tr> 
 <tr> 
 <td>6</td> 
 <td>Consumer&lt;T&gt; 代表了接受一个输入参数并且无返回的操作 </td> 
 </tr> 
 <tr> 
 <td>7</td> 
 <td>DoubleBinaryOperator 代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。 </td> 
 </tr> 
 <tr> 
 <td>8</td> 
 <td>DoubleConsumer 代表一个接受double值参数的操作，并且不返回结果。 </td> 
 </tr> 
 <tr> 
 <td>9</td> 
 <td>DoubleFunction&lt;R&gt; 代表接受一个double值参数的方法，并且返回结果 </td> 
 </tr> 
 <tr> 
 <td>10</td> 
 <td>DoublePredicate 代表一个拥有double值参数的boolean值方法 </td> 
 </tr> 
 <tr> 
 <td>11</td> 
 <td>DoubleSupplier 代表一个double值结构的提供方 </td> 
 </tr> 
 <tr> 
 <td>12</td> 
 <td>DoubleToIntFunction 接受一个double类型输入，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>13</td> 
 <td>DoubleToLongFunction 接受一个double类型输入，返回一个long类型结果 </td> 
 </tr> 
 <tr> 
 <td>14</td> 
 <td>DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double 。 </td> 
 </tr> 
 <tr> 
 <td>15</td> 
 <td>Function&lt;T,R&gt; 接受一个输入参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>16</td> 
 <td>IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。 </td> 
 </tr> 
 <tr> 
 <td>17</td> 
 <td>IntConsumer 接受一个int类型的输入参数，无返回值 。 </td> 
 </tr> 
 <tr> 
 <td>18</td> 
 <td>IntFunction&lt;R&gt; 接受一个int类型输入参数，返回一个结果 。 </td> 
 </tr> 
 <tr> 
 <td>19</td> 
 <td>IntPredicate ：接受一个int输入参数，返回一个布尔值的结果。 </td> 
 </tr> 
 <tr> 
 <td>20</td> 
 <td>IntSupplier 无参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>21</td> 
 <td>IntToDoubleFunction 接受一个int类型输入，返回一个double类型结果 。 </td> 
 </tr> 
 <tr> 
 <td>22</td> 
 <td>IntToLongFunction 接受一个int类型输入，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>23</td> 
 <td>IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。 </td> 
 </tr> 
 <tr> 
 <td>24</td> 
 <td>LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。 </td> 
 </tr> 
 <tr> 
 <td>25</td> 
 <td>LongConsumer 接受一个long类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>26</td> 
 <td>LongFunction&lt;R&gt; 接受一个long类型输入参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>27</td> 
 <td>LongPredicate R接受一个long输入参数，返回一个布尔值类型结果。 </td> 
 </tr> 
 <tr> 
 <td>28</td> 
 <td>LongSupplier 无参数，返回一个结果long类型的值。 </td> 
 </tr> 
 <tr> 
 <td>29</td> 
 <td>LongToDoubleFunction 接受一个long类型输入，返回一个double类型结果。 </td> 
 </tr> 
 <tr> 
 <td>30</td> 
 <td>LongToIntFunction 接受一个long类型输入，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>31</td> 
 <td>LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。 </td> 
 </tr> 
 <tr> 
 <td>32</td> 
 <td>ObjDoubleConsumer&lt;T&gt; 接受一个object类型和一个double类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>33</td> 
 <td>ObjIntConsumer&lt;T&gt; 接受一个object类型和一个int类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>34</td> 
 <td>ObjLongConsumer&lt;T&gt; 接受一个object类型和一个long类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>35</td> 
 <td>Predicate&lt;T&gt; 接受一个输入参数，返回一个布尔值结果。 </td> 
 </tr> 
 <tr> 
 <td>36</td> 
 <td>Supplier&lt;T&gt; 无参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>37</td> 
 <td>ToDoubleBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个double类型结果 </td> 
 </tr> 
 <tr> 
 <td>38</td> 
 <td>ToDoubleFunction&lt;T&gt; 接受一个输入参数，返回一个double类型结果 </td> 
 </tr> 
 <tr> 
 <td>39</td> 
 <td>ToIntBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>40</td> 
 <td>ToIntFunction&lt;T&gt; 接受一个输入参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>41</td> 
 <td>ToLongBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>42</td> 
 <td>ToLongFunction&lt;T&gt; 接受一个输入参数，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>43</td> 
 <td>UnaryOperator&lt;T&gt; 接受一个参数为类型T,返回值类型也为T。 </td> 
 </tr> 
 </tbody> 
</table>

package pers.zhang.functional;
 
 
 /** * @author zhang * @date 2020/1/10 - 23:25 */
 public class FunctionalInterface { 
 public static void main(String[] args) { 
 /* 系统内置的函数式接口： ~ Predicate<T> ： 参数T 返回值boolean IntPredicate int -> boolean LongPredicate long -> boolean DoublePredicate double -> boolean ~ Consumer<T> ： 参数T 返回值void IntConsumer int -> void LongConsumer long -> void DoubleConsumer double -> void ~ Function<T, R> ： 参数T 返回值R IntFunction int -> R LongFunction long -> R DoubleFunction double -> R IntToLongFunction int -> long IntToDoubleFunction int -> double LongToIntFunction long -> int LongToDoubleFunction long -> double DoubleToIntFunction double -> int DoubleToLongFunction double -> long ~ Supplier<T> ： 无参数 返回值T UnaryOperator<T> ： 继承自Function 参数T 返回值T BiFunction<T, U, R> ： 参数T，U 返回值R BinaryOperator<T> ： 参数T，T 返回值T （继承自BiFunction） BiPredicate<T, U> ： 参数T，U 返回值boolean BiConsumer<T, U> ： 参数T，U 返回值void */
 }
 }

### 函数式接口实例 ###

Predicate 接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。

该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。

该接口用于测试对象是 true 或 false。

我们可以通过以下实例（Java8Tester.java）来了解函数式接口 Predicate 的使用：

Java8Tester.java 文件

import java.util.Arrays;
 import java.util.List;
 import java.util.function.Predicate;
 
 public class Java8Tester { 
 public static void main(String args[]){ 
 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
 
 // Predicate<Integer> predicate = n -> true
 // n 是一个参数传递到 Predicate 接口的 test 方法
 // n 如果存在则 test 方法返回 true
 
 System.out.println("输出所有数据:");
 
 // 传递参数 n
 eval(list, n->true);
 
 // Predicate<Integer> predicate1 = n -> n%2 == 0
 // n 是一个参数传递到 Predicate 接口的 test 方法
 // 如果 n%2 为 0 test 方法返回 true
 
 System.out.println("输出所有偶数:");
 eval(list, n-> n%2 == 0 );
 
 // Predicate<Integer> predicate2 = n -> n > 3
 // n 是一个参数传递到 Predicate 接口的 test 方法
 // 如果 n 大于 3 test 方法返回 true
 
 System.out.println("输出大于 3 的所有数字:");
 eval(list, n-> n > 3 );
 }
 
 public static void eval(List<Integer> list, Predicate<Integer> predicate) { 
 for(Integer n: list) { 
 
 if(predicate.test(n)) { 
 System.out.println(n + " ");
 }
 }
 }
 }

执行以上脚本，输出结果为：

$ javac Java8Tester.java 
    $ java Java8Tester
    输出所有数据:
    1 
    2 
    3 
    4 
    5 
    6 
    7 
    8 
    9 
    输出所有偶数:
    2 
    4 
    6 
    8 
    输出大于 3 的所有数字:
    4 
    5 
    6 
    7 
    8 
    9