Java函數語言程式設計原理以及應用
一. 函數語言程式設計
Java8所有的新特性基本基於函數語言程式設計的思想，函數語言程式設計的帶來，給Java注入了新鮮的活力。
下面來近距離觀察一下函數語言程式設計的幾個特點：
- 函式可以作為變數、引數、返回值和資料型別。
- 基於表示式來替代方法的呼叫
- 函式無狀態，可以併發和獨立使用
- 函式無副作用，不會修改外部的變數
- 函式結果確定性；同樣的輸入，必然會有同樣的結果。
下面jdk1.8裡面對函數語言程式設計的定義。只是一個 FunctionalInterface 介面。特別的簡單。
1 @Documented
2 @Retention(RetentionPolicy.RUNTIME)
3 @Target(ElementType.TYPE)
4 public @interface FunctionalInterface {}這個函式式介面有幾點以下的限制：
- 唯一的抽象方法，有且僅有一個 (即所有的函式式介面，有且只能有一個抽象方法)
- 加上標註,則會觸發JavaCompiler的檢查。對於符合函式介面的介面，加不加都無關緊要，但是加上則會提供一層編譯檢查的保障。如果不符合，則會報錯。
- 不能被覆蓋之後，再宣告為抽象方法，則不算抽象方法。例如介面實現了Object中的方法。
- 可用於lambda型別的使用方式
二. Java8新增函式式介面
Stream的操作是建立在函式式介面的組合之上的。Java8中新增的函式式介面都在java.util.function包下。這些函式式介面可以有多種分類方式。
2.1 Function
Function是從T到R的一元對映函式。將引數T傳遞給一個函式，返回R。即R = Function(T)
Function最常用的應該是 <R> Stream<R> map(Function<? super T, ? extends R> mapper);
比如List<Person> person裡面有age，name.... 我傳入age，他就會返回age的集合給我。
1 @FunctionalInterface
2 public interface Function<T, R> {
3
4 R apply(T t);
2.2 Predicate
Predicate是一個謂詞函式，主要作為一個謂詞演算推導真假值存在，返回布林值的函式。Predicate等價於一個Function的boolean型返回值的子集。
predicate最常用的莫過於 Stream<T> filter(Predicate<? super T> predicate);
比如我要過濾年齡 > 18 的人，我傳入age，判斷是否為true。為true則保留，false丟棄。
1 @FunctionalInterface
2 public interface Predicate<T> {
3
4 boolean test(T t);
5
6 default Predicate<T> and(Predicate<? super T> other) {
7 Objects.requireNonNull(other);
8 return (t) -> test(t) && other.test(t);
9 }
10
11 default Predicate<T> negate() {
12 return (t) -> !test(t);
13 }
14
15 default Predicate<T> or(Predicate<? super T> other) {
16 Objects.requireNonNull(other);
17 return (t) -> test(t) || other.test(t);
18 }
19
20 static <T> Predicate<T> isEqual(Object targetRef) {
21 return (null == targetRef)
22 ? Objects::isNull
23 : object -> targetRef.equals(object);
24 }
25 }
2.3 Consumer
Consumer是從T到void的一元函式，接受一個入參但不返回任何結果的操作。
Consumer最常用的肯定是 default void forEach(Consumer<? super T> action) {}
這是一段forEach迴圈的程式碼，傳入實現的方法，並不返回任何值。只是迴圈。
1 @FunctionalInterface
2 public interface Consumer<T> {
3
4 void accept(T t);
5
6 default Consumer<T> andThen(Consumer<? super T> after) {
7 Objects.requireNonNull(after);
8 return (T t) -> { accept(t); after.accept(t); };
9 }
10 }
三. Lambda表示式
3.1 基本語法
Lambda 的基本結構為 (arguments) -> body，有如下幾種情況：
- 引數型別可推導時，不需要指定型別，如
(a) -> System.out.println(a) - 當只有一個引數且型別可推導時，不強制寫
(), 如a -> System.out.println(a) - 引數指定型別時，必須有括號，如
(int a) -> System.out.println(a) - 引數可以為空，如
() -> System.out.println(“hello”) - body 需要用
{}包含語句，當只有一條語句時{}可省略
3.2 Lambda原理
比如如下程式碼：
1 List<Integer> list = new ArrayList<>();
2
3 list.stream().filter((x) -> x >= 18)
4
5 Stream<T> filter(Predicate<? super T> predicate);
6
7 @FunctionalInterface
8 public interface Predicate<T> {
9
10 boolean test(T t);
11
12 }
比如List裡面存個個人的年齡，現在篩選出年齡大於等於18的人。
此時我們就可以用 list.stream().filter((x) -> x >= 18) 這就是一個典型的lambda表示式
(x) -> x >= 18 傳給 Predicate 函式式介面。
原理其實是：
JVM幫我們動態生成了一個內部類，然後這個內部類實現了 Predicate 這個函式式介面。
重寫了裡面的test方法。生成的類似如下：
1 static final class Main$$Lambda$1 implements Predicate<Integer> {
2 private Main$$Lambda$1() {
3 }
4
5 @Override
6 public boolean test(Integer x) {
7 return x >= 18;
8 }
9 }
3.3 Lambda用法
1 public class Main {
2 public static void main(String[] args) {
3
4 List<Integer> list = new ArrayList<>();
5 list.add(40);
6 list.add(50);
7 list.add(20);
8 list.add(30);
9 List<Integer> collect = list.stream().filter(x -> x >= 30)
10 .map((x) -> x + 10).sorted((x, y) -> -x.compareTo(y))
11 .collect(Collectors.toList());
12 System.out.println(collect);
13 }
14 }
這個一段很典型的Lambda + Stream的用法。
- list.stream()獲取list的stream的流
- filter篩選出年齡大於30的人 (裡面是一個Predicate介面，返回真假)
- map做一個function對映
- sort排序，裡面是compartor
四. 總結
Lambda 表示式可以減少很多程式碼，能提高生產力。但也要理解其原理。比如3.3中的程式碼，為什麼filter裡面是斷言表示式，map裡面是function表示式。
這都要從lambda的原理入手，也就是JVM動態生成一個內部類，並繼承其中的抽象方法。
本次主要介紹了Java函數語言程式設計的原理以及應用，主要從Stream和lambda入手。通過一些簡單的概念，以及程式碼，更好的理解Java的函數語言程式設計。
掌握Java的函數語言程式設計，對平時我們開發程式碼，看其他人的程式碼，都有很大的幫助。
且行且珍惜，加油！
&n