Java 8 函数式接口

浅浅的花香味﹌ 2021-12-23 09:45 250阅读 0赞

转自：https://www.runoob.com/java/java8-functional-interfaces.html

函数式接口(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>

--------------------

## 函数式接口实例 ##

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

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

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

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

## Java8Tester.java 文件 ##

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

转载于:https://www.cnblogs.com/sharpest/p/10787726.html