JDK8系列之Functional Interfaces教程和示例

今天药忘吃喽~ 2021-09-09 01:18 358阅读 0赞

## JDK8系列之Functional Interfaces教程和示例 ##

在[前面章节][Link 1]的学习中，我们学习了JDK8的lambada表达式和方法引用，接着，本章节继续学习jdk8的一个重要特性Functional Interfaces，翻译过来就是函数式接口

### 1、什么是Functional Interfaces？ ###

什么是函数式接口，Functional Interfaces？函数式接口是jdk8的新特性之一，函数式接口是只包含一个抽象方法声明的接口。比如`java.lang.Runnable`就是一种函数式接口，在 Runnable 接口中只声明了一个方法 void run()

package java.lang;
    @FunctionalInterface
    public interface Runnable { 
        void run();
    }

> Lambda 表达式、构造函数、方法引用都能隐式地赋值给函数式接口

使用lambada表达式赋值给Runnable函数式接口

Runnable r = () -> System.out.println("hello world");

等价于：

new Runnable() { 
        @Override
        public void run() { 
            System.out.println("hello world");
        }
    };

### 2、@FunctionalInterface 注解 ###

使用@FunctionalInterface注解用于自定义一个函数式接口，下面给出一个例子：

*  ①定义一个@FunctionalInterface

@FunctionalInterface
     interface AddInterface { 
         int addMethod(int a , int b);
     }

*  ② 调用FunctionalInterface

// example 2 : FunctionalInterface自定义接口
     AddInterface addInterface = (a , b) -> a + b;
     System.out.println(String.format("两个数字相加:%s" , addInterface.addMethod(10,24)));

### 3、使用java.util.function的函数式接口 ###

`java.util.function`提供了很多的函数式接口，可以称之为 predefined functional interface

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

java.util.function里的函数式接口例子：

import java.util.function.BiConsumer;
    import java.util.function.Consumer;
    import java.util.function.Predicate;
    import java.util.function.Supplier;
    
    public class FunctionalInterfacesExample { 
    
        public static void main(String[] args) { 
            // example : java.util.function函数接口应用
            // Consumer接口接收一个参数,不返回参数
            consumerFun(1 , v -> { System.out.println(v);});
            // binConsumer 接收两个参数,返回0个参数
            binConsumerFun("hello", "world" , (a ,b) -> { 
                System.out.println(a + b);
            });
            // Predicate 接收一个参数,返回一个boolean值
            System.out.println(predicateFun(3 , a -> a ==3));
            // Predicate 接收0个参数,返回一个值
            System.out.println(supplierFun(() -> 1));
        }
    
        public static void consumerFun(int value, Consumer<Integer> c) { 
            c.accept(value);
        }
    
        public static void binConsumerFun(String a , String b, BiConsumer<String , String> binc) { 
            binc.accept(a , b);
        }
    
        public static boolean predicateFun(int value, Predicate<Integer> pre) { 
            return pre.test(value);
        }
    
        public static int supplierFun(Supplier<Integer> supplier) { 
            return supplier.get();
        }
    
       
    }

### 附录：参考资料 ###

*  [https://www.runoob.com/java/java8-functional-interfaces.html][https_www.runoob.com_java_java8-functional-interfaces.html]

[Link 1]: https://blog.csdn.net/u014427391/category_11200593.html
[https_www.runoob.com_java_java8-functional-interfaces.html]: https://www.runoob.com/java/java8-functional-interfaces.html