認識 Java 函數式編程：從 Lambda 表達式到方法引用 | 3 種方法引用

我們將這兩個中文字分開來看… 在數學中，所謂的「包」，只函數與周圍的環境變數綑綁打包；而「閉」則是指這些變數是封閉的，不會與外界有關係，只為該函數服務

運用在函數式編程中，閉包在解決問題時就會使用「不可變的值」

● 那 Closure 與 Callback 又有什麼不同？

Closure 和 Callback 是程式設計中經常使用的概念，雖然它們在功能上有些相似，但在語義和應用上有所不同

● Closure 的特點在於「環境的綁定」，它可以捕捉並保存所屬環境中的變數，即使在閉包中已經超出了作用域

● Callback（回呼）是一個函數，它作為參數傳遞給另一個函數，並在某個時間點調用（通常是在某個操作完成後），並且「不需要捕捉外部變數」

回呼函數（Callback）允許非同步操作和事件驅動編程

● 函數式編程是學習大數據的基礎

● 經過編譯器優化後，函數式編程通常可以取得更好的效率

● 可以很好的運用在併發執行，並且這種運行是安全的

● 減少匿名類的使用，減低開銷

物件導向轉為函數編程有思想上的差距，我們可以透過下表來大致理解一下物件導向、函數式編程兩者個差異

A. 匿名類：以下的 Consumer 就是界面，而我們創建的 new Consumer 就是匿名類

// 這是匿名類
AsyncSubject.create().subscribe(
    new Consumer<String>() {
        @Override
        public void accept(String s) throws Throwable {
            System.out.println("AsyncSubject: " + s);
        }
    },
    new Consumer<Throwable>() {
        @Override
        public void accept(Throwable s) throws Throwable {
            System.out.println("AsyncSubject Error: " + s.toString());
        }
    },
    new Action() {
        @Override
        public void run() throws Throwable {
            System.out.println("AsyncSubject Complete");
        }
    }
);

B. Lambda 表達： 同樣的目的，但是以下使用 Lambda 的表達比起匿名類更加的精簡（可以用來簡化程式），而它又稱為「匿名函數」

// Lambda 表達

AsyncSubject.create().subscribe(
    s -> System.out.println("AsyncSubject: " + s),
    s -> System.out.println("AsyncSubject Error: " + s.toString()),
    () -> System.out.println("AsyncSubject Complete")
);

我們可以以 Java 原生提供的 Thread 類為例，Thread 建構函數會接收一個 Runnable 界面，同樣使用「匿名類」、「匿名函數, Lambda」看看兩者的表面差異

A. 使用匿名類表達 Runnable 界面

// Thread's Runnable 匿名類
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");     
    }
});

B. 使用 Lambda 表達：可以看到這樣表達起來更加的簡潔

// Lambda 表達
new Thread(() -> System.out.println("Hello World"));

符號 -> 以左是 Lambda 所需要的參數，以右是要處理的功能 (當 Func 被呼叫時會執行的代碼)

// 左側 -> 右側
// 參數* -> 功能

(參數*) -> {
    // Lambda body
    System.out.println("Runnable lambda");
};

● 每種不同的程式語言在使用 Lambda 表達式時會有不同的表達方式（eg. 像是 swift 就是使用 in 關鍵字）

● 如果 Lambda 表達式 Body 只有一行的話，則可以省略最外層的大括號

(參數*) -> System.out.println("Runnable lambda");

● 參數數量對 Lambda 表達式的影響

void noParamLambda() {
    
    Runnable runnable = () -> {
        System.out.println("Runnable lambda");
    };

    // 同上（由於 Lambda body 只有一行，所以可以省略大括號）
    Runnable runnable = () -> System.out.println("Runnable lambda");

}

void oneParamLambda() {

    Consumer<String> consumer = (msg) -> System.out.println("Consumer lambda: " + msg);

    Consumer<String> consumer2 = msg -> System.out.println("Consumer2 lambda: " + msg);

    Consumer<String> consumer3 = (String msg) -> System.out.println("Consumer lambda: " + msg);
    
}

void twoParamsLambda() {

    IntConvert intConvert = (value1, value2) -> System.out.println("Consumer lambda: " + (value1 + value2));

}

● 返回值對 Lambda 表達式的影響：Lambda 表達式如同一般的函數，返回值只能有一個

void lambdaWithReturn() {

    Comparable<Integer> comparable = value -> {
        int result = 0;
        if( value > 10) {
            result = 1;
        }
        return result;
    };

}

void lambdaWithReturnSingleLine() {

    // 由於 Body 只有一行，所以可以省略 return
    Comparable<Integer> comparable = value -> (value > 10 ? 1 : 0);

}

A. 該註解只能註解在介面（interface）上

B. 介面中 只有一個抽象方法 (但可以使用 default、static 定義)，稱為函數式介面

A. 沒有用註釋修飾，編譯器並不會檢查 (Source)，並且擁有一個以上的方法即不是函數式編程，無法取得函數式編程的好處、優點

B. 透過註釋修飾，檢查正確 (一個抽象介面)，也可正常轉 Lambda 表達式

C. 雖然通過註釋修飾，但是超過一個以上的方法，無法編譯過

public class TestLambda {

    public static void main(String []args) {

        NonSymbol n = new NonSymbol() {
            @Override
            public void Print(String s) {
                System.out.println("Non Symbol");
            }

            @Override
            public void Print(String s, String s2) {

            }
        };

        HaveSymbol h = s -> System.out.println("Have Symbol");
    }
}

// "1. "        Okay, but not lambda
interface NonSymbol {
    void Print(String s);
    void Print(String s, String s2);
}

// "2. "        Okay
@FunctionalInterface
interface HaveSymbol {
    void Print(String s);
    default void Print(String s, String s2) {
        System.out.println(s + s2);
    }
    static void Print () {
        System.out.println("Static");
    }
}

// "3. "        Error
@FunctionalInterface
interface HaveTwoMethid {
    void Print(String s);
    void Print(String s, String s2);
}

範例如下：鄉民有 30 cm 的判斷

public class TestJavaAPI {

    public static void main(String []args) {
        boolean result = TestPredicate(31, 
                                       // 傳入 Lambda 表達式
                                       integer -> integer >= 30);
        System.out.println("鄉民有 30cm ? " + result);
    }

    private static  <T> boolean TestPredicate(T value, 
                                              Predicate<T> predicate) {
        return predicate.test(value);
    }
}

範例如下：將傳入的數值，乘以三倍並打印出來

public class TestJavaAPI {

    public static void main(String []args) {
        TestConsumer(30, 
                     // 傳入 Lambda 表達式
                     (t) -> System.out.println("Value * 3 = " + t * 3));
    }

    private static <T extends Integer> void TestConsumer(T value, Consumer<T> consumer) {
        consumer.accept(value);
    }

範例如下：傳入一個字符串返回其長度

public class TestJavaAPI {

    public static void main(String []args) {
        int length = TestFunction("Alien_Pan", s -> s.length());

        System.out.println("Test String Len: " + length);
    }

    public static <T extends String , U extends Integer> U TestFunction (T value, Function<T, U> function) {
        return function.apply(value);
    }
}

範例如下：創建小明個人資料，姓名、身高、體重

class MyInfo {
    String name;
    int height, weight;
    MyInfo(String name, int height, int weight) {
        this.name = name;
        this.height = height;
        this.weight = weight;
    }
}
@RequiresApi(api = Build.VERSION_CODES.N)
public class TestJavaAPI {
    public static void main(String []args) {
        /*  原型
        TestSupplier(new Supplier<MyInfo>() {
            @Override
            public MyInfo get() {
                return null;
            }
        });
         */
        MyInfo info = TestSupplier(() -> new MyInfo("Alien", 170, 65));
        System.out.println("Name: " + info.name);
        System.out.println("Height: " + info.height);
        System.out.println("Weight: " + info.weight);
    }

    public static <T> T TestSupplier(Supplier<T> supplier) {
        return supplier.get();
    }

A. 物件::建構函數

B. 類::靜態方法

C. 類::實例方法

public static void main(String []args) {
    // 1. static 方法
    //Consumer<String> consumer = s -> System.out.println(s);       原型
    Consumer<String> consumer = System.out::println;

    // 2. 與引用方法的參數列表不一致，所以不能使用方法引用
    Consumer<String> consumer_1 = s -> System.out.println("Name: " + s);    

    // 3. 並無修改參數，可使用引用 static
    BinaryOperator<Integer> b = Math::max;

    // 4. 類普通方法的引用
    String s = TestUnaryOperator("Alien", String::toUpperCase);
    System.out.println(s);
}

public static String TestUnaryOperator(String str, UnaryOperator<String> unaryOperator) {
    return unaryOperator.apply(str);
}

其引用的格式為 ClassName::new… 只要函數介面與建構器的參數列表匹配，就可以自動與介面中的方法相容（即與介面中的參數列表相吻合）；以下是一個範例

class MyInfo {
    String name;
    int height, weight;
    MyInfo() {
    }

    MyInfo(String name, int height, int weight) {
        this.name = name;
        this.height = height;
        this.weight = weight;
    }
}

public static void TestMethod_2() {
    //"1. " 參數列表不吻合，Supplier 是一個無參介面
    Supplier<MyInfo> s1 = () -> new MyInfo("Alien", 100, 35);
    
    //"2. " 使用無參構造器與無參介面吻合，可以使用建構函數引用
    Supplier<MyInfo> s2 = () -> new MyInfo();
    Supplier<MyInfo> s3 = MyInfo::new;
}

A. Supplier<MyInfo> s1 = () -> new MyInfo("Alien", 170, 65); 說明：

此處的參數列表不匹配，因為 Supplier 介面是一個無參界面，而建構函數 MyInfo(String name, int height, int weight) 需要三個參數。因此不能使用建構函式引用

B. Supplier<MyInfo> s2 = () -> new MyInfo(); 和 Supplier<MyInfo> s3 = MyInfo::new; 說明：

這兩個範例中使用了無參構造器，符合 Supplier 介面的無參要求，因此可以使用建構子來參考 MyInfo::new 來取代 Lambda 表達式 () -> new MyInfo()

它使用類似於構造函數引用的語法，即 Type[]::new，並且需要與目標函數接口的參數列表相匹配… 這種方法引用可以使代碼更加簡潔和易讀

範例如下：

public static void TestMethodArray() {
    MyInfo[] m = new MyInfo[3];

    // Java 原型
    Function<Integer, MyInfo[]> function = new Function<Integer, MyInfo[]>() {
        @Override
        public MyInfo[] apply(Integer integer) {
            return new MyInfo[integer];
        }
    };

    // 1. Lambda 原型
    Function<Integer, MyInfo[]> function1 = integer -> new MyInfo[integer];

    // 2. 數組引用
    Function<Integer, MyInfo[]> function2 = MyInfo[]::new;
}

A. Lambda 原型

B. 數組引用