隨便聊聊 Java 8 的函數語言程式設計

樹岸發表於2021-04-13
Java函數程式設計

函數語言程式設計（Functional Programming）

首先，我們來了解一個叫做"程式設計正規化"的概念。

什麼是"程式設計正規化"呢？簡單來說就是指導我們程式設計的方法論，是一種教我們如何編寫程式碼、如何組織程式碼的"解題"思路。

業界普遍將程式設計正規化劃分為兩大類：指令式和過程式，當然每個大類也可以接著往下細分，下面只列出了一些比較常見的子分類：

  • 指令式（Imperative）
    • 過程式（Procedural），比如：Fortran、C
    • 物件導向（Object Oriented），比如：C++、Java
  • 宣告式（Declarative）
    • 邏輯式（Logic），比如：Prolog
    • 函式式（Functional），比如：Haskell、Erlang

在上面的分類中，有的同學看到 Java 被劃分到了指令式正規化的範疇可能會感覺到疑惑，其實指令式正規化與宣告式正規化之間並沒有絕對的界限，而且大有相互滲透的趨勢，上述的分類也只是一個廣義的劃分，不用太過較真，稍微有個概念就行了。

指令式正規化更關注過程，側重於描述"如何去做"，而宣告式正規化關注結果，側重於描述"去做什麼"。

來看一個 Java 計算階乘的例子：

// 給出明確的演算法實現（指令式）
public int factorialImperative(int n) {
    int f = 1;
    for (; n > 0; --n) {
        f *= n;
    }
    return f;
}
// 僅僅給出了階乘的遞迴定義（宣告式）
public int factorialDeclarative(int n) {
    return n == 0 ? 1 : n * factorialDeclarative(n - 1);
}

什麼是函數語言程式設計

關於什麼是函數語言程式設計貌似也沒有什麼官方的定義，我好像也沒有找到什麼權威的解釋，參考 wikipedia 以及自己的一些理解大概描述一下吧：

函數語言程式設計是一種宣告式的程式設計正規化（以目標為導向，側重於描述"去做什麼"），通過函式運算以及函式組合的方式構建程式，並且避免使用共享狀態（變數）以及可變物件。

好吧，總結的好像也比較抽象。沒關係，還是有個概念就好，多寫寫多看看就有感覺了。

說說函數語言程式設計中一些常見的概念吧：

  • First-class function（一言以蔽之：函式可以賦值給變數）
  • High-order function（一言以蔽之：函式可以作為另一個函式的入參或者出參）
  • Pure function（一言以蔽之：給定輸入，輸出總是固定的）
    • 補充說明，正是因為輸出總是依賴輸入，所以引申出一些其他的概念
      • Side Effect Free（沒有副作用的，即不會汙染上下文）
      • Reference Transparency（引用透明，即不依賴外部變數）
      • Lazy Evaluation（延遲求值，即呼叫的時機就不那麼重要了）
  • 不可變（這個很好理解，當一切都是不可變，也就不需要考慮鎖競爭了，也不用擔心併發問題了，並行也變得簡單起來）
  • 科裡化（一種模組化和重用程式碼的技術，說白了其實就是閉包的一種實踐）
  • 延遲列表、模式匹配還有結合器等等大家感興趣的話可以自己去谷歌一下

Java 8 的函數語言程式設計

Java 8 對函數語言程式設計的支援

眾所周知 Java 屬於物件導向程式語言，廣義上屬於指令式正規化的語言，但是沒必要較真這個正規化的分類，或是追求寫出標準的函數語言程式設計風格的程式碼，最重要的還是寫出好的程式碼，業務價值OK、擴充套件性OK、維護性OK（當然好程式碼可不止這些標準）。

下面我們就來看看 Java 為了支援函數語言程式設計，做了哪些努力。

首先，就是引數傳遞。Java 為了實現把函式當做引數來傳遞，引入了一個函式式介面（Functional Inteface）的概念。

函式式介面

簡單來說函式式介面就是隻定義一個方法的介面。比如我們經常會用到的 java.lang.Runnable 和 java.util.concurrent.Callable。

但是這樣的定義未免有點單薄，因為只要人為的在介面裡多新增一個方法，那麼這個介面就不是函式介面了，又或者說某個介面壓根兒就不是函式式介面，但是這個介面也只定義了一個方法，恰巧也符合函式式介面的語義，比如 java.lang.AutoCloseable，這就會給我們使用帶來很多歧義和誤導。

Java 8 提供了 @FunctionalInterface 註解來解決上面提到的問題。跟泛型和 @Override 類似，@FunctionalInterface 也同樣是編譯器來給程式碼做約束的，提供安全性的同時也提高了程式碼的可讀性（因為顯示的給你標記了嘛）。

當然，這個註解也不是必須的，還是舉 java.lang.AutoCloseable 這個例子，像下面的宣告編譯器也並不會報錯，但是這並沒有什麼實際意義，這些都是程式碼裡面的壞味道，切記不可這樣寫：

public static void main(String[] args) throws Exception {
    AutoCloseable unscientific = () -> {
        System.out.println("不科學的示例...");
    };
    unscientific.close();
}

在上面的示例程式碼中，引入了 Java 8 的一個新的語法特性，你應該注意到了，就是 () -> {}：一個引數塊+一個箭頭+一個程式碼塊，這就是 Lamdba 表示式。

Lambda 表示式

Java 8 引入 Lambda 表示式的主要作用就是簡化程式碼編寫，它只是一個語法糖而已，底層還是基於函式介面來實現的，如下面的示例那樣：

// 基於函式介面
Runnable task1 = new Runnable() {
    @Override
    public void run() {
        // business code
    }
};
// Lamdba 寫法
Runnable task2 = () -> {
    // business code
};

以前，我們只能通過匿名內部類將程式碼作為資料（也可以說是行為）來傳遞，寫過匿名內部類的小夥伴都知道，樣板程式碼你肯定是躲不開的，可讀性也沒那麼友好，而現在，Lambda 表示式給我們提供了一種更加緊湊的傳遞行為的方式。

可以把 Lambda 表示式理解為函式式介面的一個具體實現的例項。Java 8 也允許我們直接以內聯的形式直接編寫函式式介面的抽象實現，而且，還可以把整個表示式直接當成引數進行傳遞。

最簡單的 Lambda 表示式可以用逗號分隔的引數列表、-> 箭頭符號以及語句塊：

Arrays.asList("a", "b", "d")
        .forEach(e -> System.out.println(e));

Lambda表示式可能會有返回值，編譯器會根據上下文推斷返回值的型別，如果lambda的語句塊只有一行，可以省略return關鍵字。

// 傳統的方式
Arrays.asList("a", "d", "c").sort(new Comparator<String>() {
            @Override
            public int compare(String e1, String e2) {
                return e1.compareTo(e2);
            }
        });
// Lambda 語法
Arrays.asList("a", "d", "c").sort((e1, e2) -> {
            int result = e1.compareTo(e2); 
            return result;
        });
// Lambda 語法精簡
Arrays.asList("a", "d", "c").sort((e1, e2) -> e1.compareTo(e2));

關於 Lamdba 再說兩點：

  • 對區域性變數的限制
    我們在使用過程中，常常發現 Lamdba 引用區域性變數必須是final的或者說是隱式的final的，這主要是因為例項變數和區域性變數背後的實現有一個關鍵不同：例項變數都儲存在堆中，而區域性變數則儲存在棧上。堆是執行緒共享的，而棧是執行緒私有的，換句話說，Lambda 表示式引用的是值，而不是變數。
  • 方法引用
    Java 8 還提供了方法應用來進一步簡化程式碼的編寫，就像上個示例中程式碼，我們還能進一步簡寫為：
    // 方法引用
Arrays.asList("a", "b", "d").sort(String::compareTo);

好了，剛剛介紹了 Java 8 的函式式介面還有 Lambda 表示式，可以進入下一個階段了，就是流（Stream）。

流（Stream）

舉個電商計算 ROI（投資回報率）的簡單例子，公式如下：

ROI =［（收入－成本）／ 投入 ］＊100

常規操作可能寫成這樣：

multiply(divide(subtract(收入,成本),投入),100)

但如果我們換一種可讀性更高的寫法：

subtract(收入,成本).divide(投入).multiply(100)

是不是立馬眼前一亮！我們知道 . 操作符是 Java 裡面的方法呼叫，為了支援上面的這種級聯操作，Java 8 讓每個方法都返回一個通用的型別，即：Stream。

流有兩個特點

  • 流水線（簡單來說就是函式的級聯呼叫，可以類比SQL語句）
  • 內部迭代（簡單來說就是不需要像集合那樣顯示的處理迭代）

"流水線"這個特點就像剛剛計算ROI公式的那個例子，比較明瞭，我們來看看內部迭代：

在 Java 8 以前，我們大量的使用集合，對於稍微複雜一些的操作（過濾、分組、排序等組合操作）我們通常需要顯示的編寫大量的程式碼，當然，這也是無法避免的，這又回到文章開頭提到的指令式正規化的特點上面了，在沒有宣告式程式設計語法的支援下，你只能給出具體的演算法實現，這個就不舉例子了，大家應該深有體會，還是舉個簡單的例子吧：

int count=0;
 for (Person person : persons) {
     if (person.isFrom("江蘇"))){
         count++;
     }
 }

現在 Java 8 引入了流，在流上支援了宣告式的程式設計風格，一切就都變得豁然開朗起來，語義也更加豐滿起來了：

long count = persons.stream()
      .filter(person -> person.isFrom("江蘇"))
      .count()

流的惰性求值

  • Stream 上的有兩種操作：中間操作和終止操作
    • 中間操作仍然返回 Stream 物件，而終止操作返回的是具體的結果（或者說歸約，按照給定的規則對流中的元素進行加工，然後輸出到結果中）
    • 常見的中間操作：map、filter、limit
    • 常見的終止操作：max、collect、forEach
  • Stream 補充說明
    • 流的目的在於表達計算，集合講的是資料，而流講的是計算。粗略地說，集合與流之間的差異就在於什麼時候進行計算。流就像是一個延遲建立的集合：只有在消費者要求的時候才會計算值
    • 從有序集合生成流時會保留原有的順序，由列表生成的流其元素順序與列表一致
    • 流操作可以順序執行，也可以並行執行
    • 注意，和迭代器類似，流只能消費一次

常用的流操作

map

如果有一個函式可以將一種型別的值轉換成另外一種型別，map 操作就可以使用該函式，將一個流中的值轉換成一個新的流。

List<String> results = Stream.of("a", "c", "c")
        .map(String::toUpperCase)
        .collect(Collectors.toList());
// output: [A, B, C]
filter

遍歷資料並檢查其中的元素時，可嘗試使用 Stream 中提供的新方法 filter。

List<Integer> results = Stream.of("1", "2", "3")
        .map(Integer::parseInt)
        .filter(n -> n % 2 == 0)
        .collect(Collectors.toList());
// output: [2]
flatMap

flatMap 方法可用 Stream 替換值，然後將多個 Stream 連線成一個 Stream。

List<Integer> results = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4))
        .flatMap(List::stream)
        .collect(Collectors.toList());
// output: [1, 2, 3, 4]
reduce

reduce 操作可以實現從一組值中生成一個值。

int result1 = IntStream.of(1, 2, 3, 4)
        .sum();

int result2 = Stream.of(1, 2, 3, 4)
        .reduce(0, (acc, element) -> acc + element);

int result3 = Stream.of(1, 2, 3, 4)
        .reduce(0, Integer::sum);

// output: 10

Collector

最後，我們來看一看 Collector介面。Stream 介面中定義了一個 <R, A> R collect(Collector<? super T, A, R> collector); 的方法，接收一個 Collector 型別的引數。Collector 顧名思義，就是收集器，就是按照一定的規則，對流進行資料的歸約操作。

剛剛 map、filter 的示例中都用到了 Stream.collect(Collectors.toList()); ：將流中的元素輸出到一個 List 中去。

我們先看一下 Collector 的介面定義：

// 建立新的結果容器
Supplier<A> supplier();
// 將元素新增到結果容器
BiConsumer<A, T> accumulator();
// 合併兩個結果容器
BinaryOperator<A> combiner();
// 對結果容器應用最終轉換
Function<A, R> finisher();
// 定義了收集器的行為（尤其是關於流是否可以並行歸約），以及可以使用哪些優化的提示。
Set<Characteristics> characteristics();

如果我們想把流中的元素歸約到一個 List<Integer> 中，那麼首先，你得有一個收集結果的容器：

Supplier<List<Integer>> containerSupplier = ArrayList::new;

然後我們需要一個累加函式，將流中的一個個元素放到結果容器中：

BiConsumer<List<Integer>, Integer> accumulator = List::add;

然後，我們需要告訴編譯器這個流是否可以並行歸約，或是可以做哪些優化：

Set<Collector.Characteristics> characteristics = Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));

然後如果是在並行的場景下，我們需要將並行的各個部分進行合併，這個時候，就需要一個合併的函式：

BinaryOperator<List<Integer>> combiner = (List<Integer> left, List<Integer> right) -> {
    left.addAll(right);
    return left;
};

最後，我們需要一個型別轉換的函式，將流中的元素轉換成歸約的目標型別：

Function<Integer, Integer> finisher = (Integer i) -> (Integer) i;

所以整體思路就是動態新建了一個目標集合，然後遍歷這個流，將流中的元素依次新增到目標集合中，如果不考慮並行的情況，其實Collector就是幹了這麼一件事。如果你要實現自己的收集器，大體上，也就是跟這5個方法打交道了。

當然，Java 已經給我們提供了不少常用的收集器了，用於實現像 join、groupingBy 等常用操作，可以直接看一下 Collectors 的類註釋，官方很貼心的給我們提供了不少示例程式碼。

好了，就寫這麼多吧，希望對大家有所幫助。

相關文章