JAVA8新特性之函數式接口（一）

函數式接口是整個Lambda表達式的根源，也就是說，只有理解了函數式接口才能更好的掌握Lambda表達式。函數式接口就是有且僅有一個抽象方法，但是可以有多個非抽象方法的接口。也就是說他還可以有默認方法和靜態方法。默認方法在接口中的定義使用關鍵詞default。一般來說滿足一下幾點的都是函數接口：

一個接口有且只有一個抽象方法，（Object的public方法除外）那麼該接口就是一個函數式接口。

有FunctionalInterface註解，那麼編譯器就會認定爲函數式接口。

JDK1.8之前已有的函數式接口(在1.8之前一般都是用內部類處理)

java.lang.Runnable
java.util.concurrent.Callablejava.security.PrivilegedAction
java.util.Comparatorjava.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandlerjava.beans.PropertyChangeListener
java.awt.event.ActionListenerjavax.swing.event.ChangeListener

JDK1.8新增：

java.util.function

3.函數式接口解析
BiConsumer：
BiConsumer<T, U>接口是一個函數接口，該接口聲明瞭accept方法，並無返回值，該函數接口主要用來聲明一些預期操作。
其中還有一個andThen方法，該方法接受一個BiConsumer，返回一個組合的BiConsumer，並且按照順序執行操作。如果執行任一操作拋出異常，則將其傳遞給組合操作的調用者。如果執行此操作拋出異常，將不執行後操作(after)。

   public static void main(String[] args) {
        System.out.println("------BiConsumer------");
        BiConsumer<String,String> biConsumer = (x,y)-> System.out.println(x+"--------------"+y);
        BiConsumer<String,String> biConsumer2 = (x,y)-> System.out.println(x+">>>>>>>>"+y);
        biConsumer.accept("JACK","JAVA8");
        biConsumer.andThen(biConsumer2).accept("biConsumer2","JAVA8");
        System.out.println("------BiConsumer------");
    }

輸出內容爲：

------BiConsumer------
JACK--------------JAVA8
biConsumer2--------------JAVA8
biConsumer2>>>>>>>>JAVA8
------BiConsumer------

BiFunction:
BiFunction<T, U, R>接口是一個函數接口，聲明瞭apply方法，有返回值R.其中包含一個default的andThen(Function<? super R, ? extends V> after)，接受一個Function方法，返回一個結果。

   public static void main(String[] args) {
        System.out.println("------BiFunction------");
        BiFunction<Integer,Integer,Integer>    = (x, y)-> {return  x+y;};
        int result =  biFunction.apply(1,2);
        System.out.println("result:"+result);
        Function<Integer,Integer> function = (x)->{return (x*5);};
        System.out.println("andThen:"+biFunction.andThen(function).apply(8,9));
        System.out.println("------BiFunction------");
    }

------BiFunction------
result:3
andThen:85
------BiFunction------

上面的result:3是很容易理解的，就是1+2,也就是執行了biFunction,下面輸出的85,則是先執行了biFunction.apply(8,9)，然後在執行的自定義的function函數。最後計算公式也就是（8+9*5=85。

BinaryOperator：
代表了一個作用於於兩個同類型操作符的操作，並且返回了操作符同類型的結果。他繼承了BiFunction,因此可以使用BiFunction中的方法。

public class MainTest {
    public static void main(String[] args) {
        System.out.println("------BinaryOperator------");
        BinaryOperator<Integer> binaryOperator = (x,y)->x*y;
        System.out.println("BinaryOperator:"+binaryOperator.apply(3,8));
        Function<Integer,Integer> function1 = (x)->x*8;
        System.out.println("BinaryOperator andThen:" + binaryOperator.andThen(function1).apply(8,10));
        BinaryOperator<Integer> bi = BinaryOperator.maxBy(Comparator.naturalOrder());
        System.out.println("BinaryOperator maxBy:" + (bi.apply(100,99)));
        System.out.println("------BinaryOperator------");
    }
}

輸出結果：

------BinaryOperator------
BinaryOperator:24
BinaryOperator andThen:640
BinaryOperator maxBy:100
------BinaryOperator------

BiPredicate:
代表了一個兩個參數的boolean值方法。該接口是一個邏輯運算的函數接口；裏面包含了比較方法boolean test(T t, U u),邏輯與方法and(BiPredicate<? super T, ? super U> other),邏輯非方法negate()，以及邏輯或方法or(BiPredicate<? super T, ? super U> other)。
test(T t, U u) :判斷參數是否滿足條件。
and(BiPredicate<? super T, ? super U> other)：同時滿足。
negate()：非運算，類似“!”.
or(BiPredicate<? super T, ? super U> other):或運算。

  public class MainTest {
    public static void main(String[] args) {
        System.out.println("------BiPredicate------");
        BiPredicate<String,String> biPredicate = (x,y)-> x.equals(y);
        BiPredicate<String,String> biPredicate1 = (x,y)-> (x+"2").equals(y);
        System.out.println("False>>>>>:"+biPredicate.test("a","b"));
        System.out.println("True>>>>>:"+biPredicate.test("a","a"));
        //biPredicate和biPredicate1是否同時滿足
        System.out.println("and >>>>>:"+biPredicate.and(biPredicate1).test("xxx","xxx2"));
        //negate表示非運算，類似"!"
        System.out.println("negate >>>>>:"+biPredicate.negate().test("a","a"));
        System.out.println("negate >>>>>:"+biPredicate.negate().test("a","c"));
        //or或者
        System.out.println("or >>>>>:"+biPredicate.or(biPredicate1).test("xxx","xxx2"));
        System.out.println("or >>>>>:"+biPredicate.or(biPredicate1).test("xxx","xx"));
        System.out.println("------BiPredicate------");
    }
}

輸出結果：

------BiPredicate------
False>>>>>:false
True>>>>>:true
and >>>>>:false
negate >>>>>:false
negate >>>>>:true
or >>>>>:true
or >>>>>:false
------BiPredicate------

BooleanSupplier:
代表了boolean值結果的提供方,用於接收Lambda表達式所返回的boolean值結果。

 public class MainTest {
    public static void main(String[] args) {
        System.out.println("------BooleanSupplier------");
        BooleanSupplier booleanSupplier = ()->true;
        System.out.println(" booleanSupplier :" + booleanSupplier.getAsBoolean());
        int x=2;
        int y=3;
        BooleanSupplier booleanSupplier1 = ()->x>y;
        System.out.println(" booleanSupplier1 :" + booleanSupplier1.getAsBoolean());
        System.out.println("------BooleanSupplier------");
    }
}

輸出結果：

------BooleanSupplier------
 booleanSupplier :true
 booleanSupplier1 :false
------BooleanSupplier------

Consumer:
代表了接受一個輸入參數並且無返回的操作,給定一個參數，對其進行消費處理，處理方式可以是任意操作。

    public class MainTest {
    public static void main(String[] args) {
          System.out.println("------Consumer------");
        Consumer consumer = (m)-> System.out.println(">>>>>"+m);
        consumer.accept("這是第一個consumer");
        consumer.andThen(consumer).accept("This is second");
        System.out.println("------Consumer------");  
    }
}

輸出內容：

------Consumer------
>>>>>這是第一個consumer
>>>>>This is second
>>>>>This is second
------Consumer------

DoubleBinaryOperator:
代表了作用於兩個double值操作符的操作，並且返回了一個double值的結果。

  public class MainTest {
  public static void main(String[] args) {
      System.out.println("------DoubleBinaryOperator------");
      DoubleBinaryOperator doubleBinaryOperator = (a,b)->{
          if(a>b){
             return  a-b;
          }else{
              return  b-a;
          }
      };
      double d =  doubleBinaryOperator.applyAsDouble(6.1,9.1);
      double d1 =  doubleBinaryOperator.applyAsDouble(61.1,9.1);
      System.out.println("doubleBinaryOperator d>>"+d);
      System.out.println("doubleBinaryOperator d1>>"+d1);
      System.out.println("------DoubleBinaryOperator------");
      }
}

輸出內容：

------DoubleBinaryOperator------
doubleBinaryOperator d>>3.0
doubleBinaryOperator d1>>52.0
------DoubleBinaryOperator------

DoubleConsumer:
DoubleConsumer代表一個接受double值參數的操作，並且不返回結果。

   public class MainTest {
   public static void main(String[] args) {
 System.out.println("------DoubleConsumer------");
       DoubleConsumer doubleConsumer = System.out::println;
       doubleConsumer.accept(6.5);
       doubleConsumer.andThen(doubleConsumer).accept(18);
       System.out.println("------DoubleConsumer------");
       }
}

輸出內容：

------DoubleConsumer------
6.5
18.0
18.0
------DoubleConsumer------

DoubleFunction:
代表接受一個double值參數的方法，並且返回結果.

   public class MainTest {
   public static void main(String[] args) {
       System.out.println("------DoubleFunction------");
       DoubleFunction doubleFunction = (w)->{
           if (w>0){
               System.out.println("正double數據");
               return  w*2;
           }else{
               System.out.println("負double數據");
               return  w*2;
           }
       };
       System.out.println("DoubleFunction >>>>"+doubleFunction.apply(18));
       System.out.println("DoubleFunction >>>>"+doubleFunction.apply(-18));
       System.out.println("------DoubleFunction------");
       }
}

輸出內容：

------DoubleFunction------
正double數據
DoubleFunction >>>>36.0
負double數據
DoubleFunction >>>>-36.0
------DoubleFunction------

DoublePredicate:
代表一個擁有double值參數的boolean值方法.具體方法放在BiPredicate.

 ```java
public class MainTest {
public static void main(String[] args) {
    System.out.println("------DoublePredicate------");
    DoublePredicate doublePredicate = qw->qw>0;
    DoublePredicate doublePredicate2 = qe->qe>0;
    System.out.println("DoublePredicate test====="+doublePredicate.test(-11));
    System.out.println("DoublePredicate negate ====="+doublePredicate.negate().test(-11));
    System.out.println("DoublePredicate  and ====="+doublePredicate.and(doublePredicate2).test(111));
    System.out.println("DoublePredicate  or ====="+doublePredicate.or(doublePredicate2).test(111));
    System.out.println("------DoublePredicate------");
    }

}

輸出內容：
```java
------DoubleFunction------
------DoublePredicate------
DoublePredicate test=====false
DoublePredicate negate =====true
DoublePredicate  and =====true
DoublePredicate  or =====true
------DoublePredicate------
------DoubleFunction------

JAVA8新特性之函數式接口（一）

Spring中@Conditional註解的說明

赫夫曼編碼進行壓縮和解碼

簡單的雙向循環列表

Spring中@Autowired自動裝配總結

簡單的冒泡排序算法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結