14年，Oracle公司如期釋出了Java 8正式版。現如今4年過去了，終於鼓起勇氣認真對待它，就好似雖然認識了好幾年的夥伴，突然感覺要成為情侶的感覺……
JDK 1.8 API包含了很多內建的函式式介面，在老Java中常用到的比如Comparator或者Runnable介面，這些介面都增加了@FunctionalInterface註解以便能用在lambda上。現如今，我們則從Function常用函式入口，真正瞭解一下。

標註為FunctionalInterface的介面被稱為函式式介面，該介面只能有一個自定義方法，但是可以包括從object類繼承而來的方法。如果一個介面只有一個方法，則編譯器會認為這就是一個函式式介面。是否是一個函式式介面，需要注意的有以下幾點：

• 該註解只能標記在”有且僅有一個抽象方法”的介面上。
• JDK8介面中的靜態方法和預設方法，都不算是抽象方法。
• 介面預設繼承java.lang.Object，所以如果介面顯示宣告覆蓋了Object中方法，那麼也不算抽象方法。
• 該註解不是必須的，如果一個介面符合”函式式介面”定義，那麼加不加該註解都沒有影響。加上該註解能夠更好地讓編譯器進行檢查。如果編寫的不是函式式介面，但是加上了@FunctionInterface，那麼編譯器會報錯。
• 在一個介面中定義兩個自定義的方法，就會產生Invalid ‘@FunctionalInterface’ annotation; FunctionalInterfaceTest is not a functional interface錯誤.

Function常用方法&&實踐

//將Function物件應用到輸入的引數上，然後返回計算結果。
R apply(T t);

//返回一個先執行當前函式物件apply方法再執行after函式物件apply方法的函式物件。
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

//返回一個先執行before函式物件apply方法再執行當前函式物件apply方法的函式物件
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

compose 和 andThen 的不同之處是函式執行的順序不同。compose 函式先執行引數，然後執行呼叫者，而 andThen 先執行呼叫者，然後再執行引數。

public static void main(String[] args) {
        Function<Integer, Integer> name = e -> e * 2;
        Function<Integer, Integer> square = e -> e * e;
        int value = name.andThen(square).apply(3);
        System.out.println("andThen value=" + value);
        int value2 = name.compose(square).apply(3);
        System.out.println("compose value2=" + value2);
        //返回一個執行了apply()方法之後只會返回輸入引數的函式物件
        Object identity = Function.identity().apply("huohuo");
        System.out.println(identity);
    }

直接看結果：

andThen value=36
compose value2=18
huohuo

apply基本應用

字串長度記錄返回

public class MyFunction implements Function<String,Integer>{

    @Override
    public Integer apply(String s) {
        return s.length();
    }
}

返回兩個字串的連線，BiFunction與Function的不同就是傳入兩個引數，依舊返回一個值。

public class MyBiFunction implements BiFunction<String, String, String> {
    @Override
    public String apply(String s, String s2) {
        return s+";"+s2;
    }
}

最後呼叫結果：

private static String hello = "Nice to meet you";
    private static String name = "my name is huohuo";

    public static void main(String[] args) {
        MyFunction myFunction = new MyFunction();
        MyBiFunction biFunction = new MyBiFunction();
        int num = myFunction.apply(hello);
        String valueBi = biFunction.apply(hello, name);
        //hello長度返回
        System.out.println(num);
        //語句整合返回
        System.out.println(valueBi);
    }

返回值：

16
Nice to meet you;my name is huohuo

其實使用的過程感覺這些都無所必要，但是對於新特性以及程式碼規範而言，即使是簡易程式碼，也有了一個整合的過程。Function簡單實踐僅此為止，下篇文章講述Predicate的使用。