java 8 新特性-函数式接口&lambda

妖狐艹你老母 2022-06-07 13:19 223阅读 0赞

# 目录 #

*  目录
    
     *  函数式接口
        
         *  函数式接口定义默认方法
         *  函数式接口定义静态方法
         *  函数式接口定义javalangObject里的public方法
         *  函数式接口里面允许子接口多继承
     *  接口注解
     *  接口的运用
     *  java8新增的函数式接口

## 函数式接口 ##

函数式接口（functional interface 也叫功能性接口），简单来说函数式接口就是只包含一个抽象方法的接口，Java标准库中的java.lang.Runnable和java.util.Comparator都是函数式接口。

### 1.函数式接口定义默认方法 ###

函数式接口里可以包含默认方法，因为默认方法不是抽象方法，其有一个默认实现，所以是函数式接口定义的；

### 2.函数式接口定义静态方法 ###

函数式接口可以包含静态方法，因为静态方法不能是抽象方法，是一个已经实现了的方法，所以是符合函数式接口定义的；

### 3.函数式接口定义java.lang.Object里的public方法： ###

函数式接口里是可以包含Object里的public方法，这些方法对于函数式接口来说，不被当成抽象方法（虽然他们是抽象方法）;因为任何一个函数式接口的实现，默认都继承了Object类，包含了来自java.lang.Object里对这些抽象方法的实现；

### 4.函数式接口里面允许子接口多继承 ###

函数式接口里面允许子接口继承多个父接口，但每个父接口都只能存在一个抽象方法，且必须相同的抽象方法。

*  下面几个为函数式接口的例子：

@FunctionalInterface
    public interface Predicate<T> {
    
        boolean test(T t);
    
        default Predicate<T> and(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
        }
    
        default Predicate<T> negate() {
            return (t) -> !test(t);
        }
    
        default Predicate<T> or(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
        }
    
        static <T> Predicate<T> isEqual(Object targetRef) {
            return (null == targetRef)
                    ? Objects::isNull
                    : object -> targetRef.equals(object);
        }
    }

@FunctionalInterface
    public interface Comparator<T> {
    
        int compare(T o1, T o2);
    
        boolean equals(Object obj);
    
        …………

@FunctionalInterface
    public interface A<T> extends Predicate, MyPredicate {
    
        /** * 1. * 父接口 MyPredicate与 Predicate中存在相同的抽象方法：boolean test(T t); * 因此子接口中的功能也只有 boolean test(T t); */
    
        /** * 2. * 如果多个父接口有各自不同的抽象方法，则子接口也会存在继承多个抽象方法 * 此时，子接口就不是函数式接口 */
    }

## 接口注解 ##

Java8特意为函数式接口提供了一个新的注解**@FunctionalInterface**，这个注解式非必须的，可以不写，但是如果你的同事在你的类里面添加了一个新的方法那你的接口实现就会报错了，添加上@FunctionalInterface你同事在编译期的时候就会报错误警告，算是一个规范吧。

## 接口的运用 ##

*  函数式接口也是接口，依旧可以通过之前的调用方式，通过实现类来使用接口。

public class FunctionalInterfaceTest<T> implements Predicate<T>{ 
    
        public static void main(String[] args) throws InterruptedException {
            Predicate p = new FunctionalInterfaceTest();
            System.out.println(p.test(1));
        }
    
        @Override
        public boolean test(T t) {
            return 1 % 2 == 0;
        }
    }

*  也可以通过Lambda表达式来实现抽象方法

public static void main(String[] args) throws InterruptedException {
        Predicate<Integer> p = a -> a % 2 == 1;
        System.out.println(p.test(5));
        System.out.println(p.test(2));
    }

*  函数式接口和以前编码的比较

/** * java 8 之前通常使用匿名内部类完成 */
    Collections.sort(dtoList, new Comparator<PlatformCouponOrderDTO>() {
    @Override
    public int compare(PlatformCouponOrderDTO a, PlatformCouponOrderDTO b) {
            return DateUtils.getMinutesBetween(a.getTime(), b.getTime());
            }
            });
    
    /** * java 8 之后使用Lambda表达式实现函数式接口，使代码量明显减少许多 */
            Collections.sort(dtoList, (a, b) -> DateUtils.getMinutesBetween(a.getTime(), b.getTime()));

*  使用函数式接口配合lambda表达式比以前通过内部类的方式实现简便了很多。

public class Demo1 {
        public static void main(String[] args) {
            runThreadByLambda();
            runThreadByInnerClass();
        }
    
        public static void runThreadByLambda() {
            /* Runnable就是一个函数式接口：他只有一个方法run()方法。 1、因为run()方法没有参数，所以 ->前面的()中不需要声明形参 2、run返回的是void，所以不需要return。 3、->后面写的代码其实就是定义在run方法内的代码。因为此处代码只有一行，所以{}也可以省略。如果此处多与一行，则无法省略。 */
            Runnable runnable = () -> System.out.println("这个是用拉姆达实现的线程");
            new Thread(runnable).start();
        }
    
        public static void runThreadByInnerClass() {
            Runnable runnable = new Runnable() {
    
                @Override
                public void run() {
                    System.out.println("这个是用内部类实现的线程");
    
                }
            };
            new Thread(runnable).start();
        }
    }

## java8新增的函数式接口 ##

*  java.util.function

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

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>接口 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <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;&amp;ltT&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>LongPredicateR接受一个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>

[java8新增特性][java8]  
[这篇文章也讲的很详细][Link 1]

[java8新特性终极篇\_超详细][java8 1]

[java8并行流和fork/join介绍][java8_fork_join]

[java8]: http://www.jb51.net/article/48304.htm
[Link 1]: https://www.cnblogs.com/seaspring/p/6187767.html
[java8 1]: http://www.importnew.com/11908.html#datetimeAPI
[java8_fork_join]: http://blog.csdn.net/timheath/article/details/71366448