函式式介面

概念

函式式介面在Java中是指：有且僅有一個抽象方法的介面

函式式介面，即適用于函式式編程場景的介面，而Java中的函式式編程體現就是Lambda，所以函式式介面就是可以適用于Lambda使用的介面，只有確保介面中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導，

格式

只要確保介面中有且僅有一個抽象方法即可：

修飾符 interface 介面名稱 { 
	public abstract 回傳值型別 方法名稱(可選引數資訊);
		 // 其他非抽象方法內容 
}

由于介面當中抽象方法的 public abstract 是可以省略的，所以定義一個函式式介面很簡單：

public interface MyFunctionalInterface { 
	void myMethod(); 
}

@FunctionalInterface注解

與 @Override 注解的作用類似，Java 8中專門為函式式介面引入了一個新的注解： @FunctionalInterface ，該注解可用于一個介面的定義上：

@FunctionalInterface
public interface MyFunctionalInterface { 
	void myMethod(); 
}

自定義函式式介面

對于剛剛定義好的 MyFunctionalInterface 函式式介面，典型使用場景就是作為方法的引數：

public class Demo01 {
    // 使用自定義的函式式介面作為方法引數
    private static void doSomething(MyFunctionalInterface inter) {
        inter.myMethod();
        // 呼叫自定義的函式式介面方法
    }

    public static void main(String[] args) {
        // 呼叫使用函式式介面的方法
        doSomething(()-> System.out.println("Lambda執行啦！"));
    }
}

@FunctionalInterface
interface MyFunctionalInterface {
    void myMethod();
}

函式式編程

Lambda的延遲執行

有些場景的代碼執行后，結果不一定會被使用，從而造成性能浪費，而Lambda運算式是延遲執行的，這正好可以作為解決方案，提升性能，

性能浪費的日志案例:
注:日志可以幫助我們快速的定位問題，記錄程式運行程序中的情況，以便專案的監控和優化， 一種典型的場景就是對引數進行有條件使用，例如對日志訊息進行拼接后，在滿足條件的情況下進行列印輸出：

public class Dome02 {
    public static void log(int level, String msg) {
        if (level == 1) {
            System.out.println(msg);
        }
    }

    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(1, msgA + msgB + msgC);
    }
}

這段代碼存在問題：無論級別是否滿足要求，作為 log 方法的第二個引數，三個字串一定會首先被拼接并傳入方法內，然后才會進行級別判斷，如果級別不符合要求，那么字串的拼接操作就白做了，存在性能浪費，

體驗Lambda的更優寫法:

public class Demo03 {
    private static void log(int level, MessageBuilder builder) {
        if (level == 1) {
            System.out.println(builder.buildMessage());
        }
    }

    public static void main(String[] args) { 
        String msgA = "Hello"; 
        String msgB = "World"; 
        String msgC = "Java"; 
        log(1, () -> msgA + msgB + msgC ); 
    } 
}

@FunctionalInterface
interface MessageBuilder {
    String buildMessage();
}

這樣一來，只有當級別滿足要求的時候，才會進行三個字串的拼接；否則三個字串將不會進行拼接，

證明Lambda的延遲:

public class Demo04 { 
    private static void log(int level, MessageBuilder builder) { 
        if (level == 1) { 
            System.out.println(builder.buildMessage()); 
        } 
    }
    public static void main(String[] args) { 
        String msgA = "Hello"; 
        String msgB = "World"; 
        String msgC = "Java";
        log(2, () -> { 
            System.out.println("Lambda執行！"); 
            return msgA + msgB + msgC; }); 
    } 
}

從結果中可以看出，在不符合級別要求的情況下，Lambda將不會執行，從而達到節省性能的效果，

使用Lambda作為引數和回傳值

如果拋開實作原理不說，Java中的Lambda運算式可以被當作是匿名內部類的替代品，如果方法的引數是一個函式式介面型別，那么就可以使用Lambda運算式進行替代，使用Lambda運算式作為方法引數，其實就是使用函式式介面作為方法引數，

例如 java.lang.Runnable 介面就是一個函式式介面，假設有一個 startThread 方法使用該介面作為引數，那么就 可以使用Lambda進行傳參，這種情況其實和 Thread 類的構造方法引數為 Runnable 沒有本質區別，

public class Demo05 { 
    private static void startThread(Runnable task) { 
        new Thread(task).start(); 
    }
    public static void main(String[] args) { 
        startThread(() -> System.out.println("執行緒任務執行！")); 
    } 
}

類似地，如果一個方法的回傳值型別是一個函式式介面，那么就可以直接回傳一個Lambda運算式，當需要通過一個方法來獲取一個 java.util.Comparator 介面型別的物件作為排序器時,就可以調該方法獲取

import java.util.Arrays;
import java.util.Comparator;
public class Demo06{
    private static Comparator<String> newComparator() {
        return (a,b) -> b.length() - a.length();
    }
    public static void main(String[] args) {
        String[] array = { "abc", "ab", "abcd" };
        System.out.println(Arrays.toString(array));
        Arrays.sort(array, newComparator());
        System.out.println(Arrays.toString(array));
    }
}

其中直接return一個Lambda運算式即可，

常用函式式介面

JDK提供了大量常用的函式式介面以豐富Lambda的典型使用場景，它們主要在 java.util.function 包中被提供， 下面是最簡單的幾個介面及使用示例，

Supplier介面

java.util.function.Supplier 介面僅包含一個無參的方法： T get() ，用來獲取一個泛型引數指定型別的物件資料，由于這是一個函式式介面，這也就意味著對應的Lambda運算式需要“對外提供”一個符合泛型型別的物件資料，

import java.util.function.Supplier; 
public class Demo07 { 
    private static String getString(Supplier<String> function) { 
        return function.get(); 
    }
    public static void main(String[] args) { 
        String msgA = "Hello"; 
        String msgB = "World"; 
        System.out.println(getString(() -> msgA + msgB)); 
    } 
}

Consumer介面

java.util.function.Consumer 介面則正好與Supplier介面相反，它不是生產一個資料，而是消費一個資料， 其資料型別由泛型決定，

抽象方法：accept

Consumer 介面中包含抽象方法 void accept(T t) ，意為消費一個指定泛型的資料，基本使用如：

import java.util.function.Consumer; 
public class Demo08 { 
    private static void consumeString(Consumer<String> function) { 
        function.accept("Hello"); 
    }
    public static void main(String[] args) { 
        consumeString(s -> System.out.println(s)); 
    } 
}

默認方法：andThen
如果一個方法的引數和回傳值全都是 Consumer 型別，那么就可以實作效果：消費資料的時候，首先做一個操作， 然后再做一個操作，實作組合，而這個方法就是 Consumer 介面中的default方法 andThen ，下面是JDK的源代碼：

default Consumer<T> andThen(Consumer<? super T> after) {
	 Objects.requireNonNull(after); 
	 return (T t) ‐> { 
	 accept(t); 
	 after.accept(t); }; 
}

Predicate介面

有時候我們需要對某種型別的資料進行判斷，從而得到一個boolean值結果，這時可以使用 java.util.function.Predicate 介面，
抽象方法：test Predicate 介面中包含一個抽象方法： boolean test(T t) ，用于條件判斷的場景：

import java.util.function.Predicate; 
public class Demo09 { 
    private static void method(Predicate<String> predicate) { 
        boolean veryLong = predicate.test("HelloWorld"); 
        System.out.println("字串很長嗎：" + veryLong); 
    }
    public static void main(String[] args) { 
        method(s -> s.length() > 5); 
    } 
}

條件判斷的標準是傳入的Lambda運算式邏輯，只要字串長度大于5則認為很長，

默認方法：and

既然是條件判斷，就會存在與、或、非三種常見的邏輯關系，其中將兩個 Predicate 條件使用“與”邏輯連接起來實作“并且”的效果時，可以使用default方法 and ，其JDK原始碼為：

default Predicate<T> and(Predicate<? super T> other) { 				 
	Objects.requireNonNull(other); 
	return (t) ‐> test(t) && other.test(t); 
}

默認方法：or
與 and 的“與”類似，默認方法 or 實作邏輯關系中的“或”，JDK原始碼為：

default Predicate<T> or(Predicate<? super T> other) { 
	Objects.requireNonNull(other); 
	return (t) ‐> test(t) || other.test(t); 
}

默認方法：negate
“與”、“或”已經了解了，剩下的“非”（取反）也會簡單，默認方法 negate 的JDK源代碼為：

default Predicate<T> negate() { 
	return (t) ‐> !test(t); 
}

Function介面

java.util.function.Function<T,R> 介面用來根據一個型別的資料得到另一個型別的資料，前者稱為前置條件， 后者稱為后置條件，

抽象方法：apply
Function 介面中最主要的抽象方法為： R apply(T t) ，根據型別T的引數獲取型別R的結果， 使用的場景例如：將 String 型別轉換為 Integer 型別，

import java.util.function.Function; 
public class Demo10{ 
    private static void method(Function<String, Integer> function) { 
        int num = function.apply("10"); 
        System.out.println(num + 20); 
    }
    public static void main(String[] args) { 
        method(s -> Integer.parseInt(s)); 
    } 
}

默認方法：andThen
Function 介面中有一個默認的 andThen 方法，用來進行組合操作，JDK源代碼如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { 
	Objects.requireNonNull(after); 
	return (T t) ‐> after.apply(apply(t)); 
}