Java如何支援函數式程式設計？

背景

在很長的一段時間裡，Java一直是面向對象的語言，一切皆對象，如果想要調用一個函數，函數必須屬于一個類或對象，然後在使用類或對象進行調用。但是在其它的程式設計語言中，如JS、C++，我們可以直接寫一個函數，然後在需要的時候進行調用，既可以說是面向對象程式設計，也可以說是函數式程式設計。從功能上來看，面向對象程式設計沒什麼不好的地方，但是從開發的角度來看，面向對象程式設計會多寫很多可能是重複的代碼行。比如建立一個Runnable的匿名類的時候：

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("do something...");
    }
};

這一段代碼中真正有用的隻有run方法中的内容，剩餘的部分都是屬于Java程式設計語言的結構部分，沒什麼用，但是要寫。幸運的是Java 8開始，引入了函數式程式設計接口與Lambda表達式，幫助我們寫更少更優雅的代碼：

// 一行即可
Runnable runnable = () -> System.out.println("do something...");

現在主流的程式設計範式主要有三種，面向過程、面向對象和函數式程式設計。

函數式程式設計并非一個很新的東西，早在50多年前就已經出現了。近幾年，函數式程式設計越來越被人關注，出現了很多新的函數式程式設計語言，比如Clojure、Scala、Erlang等。一些非函數式程式設計語言也加入了很多特性、文法、類庫來支援函數式程式設計，比如Java、Python、Ruby、JavaScript等。除此之外，Google Guava也有對函數式程式設計的增強功能。

函數式程式設計因其程式設計的特殊性，僅在科學計算、資料處理、統計分析等領域，才能更好地發揮它的優勢，是以它并不能完全替代更加通用的面向對象程式設計範式。但是作為一種補充，它也有很大存在、發展和學習的意義。

什麼是函數式程式設計

函數式程式設計的英文翻譯是Functional Programming。

那到底什麼是函數式程式設計呢？實際上，函數式程式設計沒有一個嚴格的官方定義。嚴格上來講，函數式程式設計中的“函數”，并不是指我們程式設計語言中的“函數”概念，而是指數學“函數”或者“表達式”（例如：y=f(x)）。不過，在程式設計實作的時候，對于數學“函數”或“表達式”，我們一般習慣性地将它們設計成函數。是以，如果不深究的話，函數式程式設計中的“函數”也可以了解為程式設計語言中的“函數”。

每個程式設計範式都有自己獨特的地方，這就是它們會被抽象出來作為一種範式的原因。面向對象程式設計最大的特點是：以類、對象作為組織代碼的單元以及它的四大特性。面向過程程式設計最大的特點是：以函數作為組織代碼的單元，資料與方法相分離。那函數式程式設計最獨特的地方又在哪裡呢？實際上，函數式程式設計最獨特的地方在于它的程式設計思想。函數式程式設計認為程式可以用一系列數學函數或表達式的組合來表示。函數式程式設計是程式面向數學的更底層的抽象，将計算過程描述為表達式。不過，這樣說你肯定會有疑問，真的可以把任何程式都表示成一組數學表達式嗎？

理論上講是可以的。但是，并不是所有的程式都适合這麼做。函數式程式設計有它自己适合的應用場景，比如科學計算、資料處理、統計分析等。在這些領域，程式往往比較容易用數學表達式來表示，比起非函數式程式設計，實作同樣的功能，函數式程式設計可以用很少的代碼就能搞定。但是，對于強業務相關的大型業務系統開發來說，費勁吧啦地将它抽象成數學表達式，硬要用函數式程式設計來實作，顯然是自讨苦吃。相反，在這種應用場景下，面向對象程式設計更加合适，寫出來的代碼更加可讀、可維護。

再具體到程式設計實作，函數式程式設計跟面向過程程式設計一樣，也是以函數作為組織代碼的單元。不過，它跟面向過程程式設計的差別在于，它的函數是無狀态的。何為無狀态？簡單點講就是，函數内部涉及的變量都是局部變量，不會像面向對象程式設計那樣，共享類成員變量，也不會像面向過程程式設計那樣，共享全局變量。函數的執行結果隻與入參有關，跟其他任何外部變量無關。同樣的入參，不管怎麼執行，得到的結果都是一樣的。這實際上就是數學函數或數學表達式的基本要求。舉個例子：

// 有狀态函數: 執行結果依賴b的值是多少，即便入參相同，
// 多次執行函數，函數的傳回值有可能不同，因為b值有可能不同。
int b;
int increase(int a) {
  return a + b;
}

// 無狀态函數：執行結果不依賴任何外部變量值
// 隻要入參相同，不管執行多少次，函數的傳回值就相同
int increase(int a, int b) {
  return a + b;
}

不同的程式設計範式之間并不是截然不同的，總是有一些相同的程式設計規則。比如不管是面向過程、面向對象還是函數式程式設計，它們都有變量、函數的概念，最頂層都要有main函數執行入口，來組裝程式設計單元（類、函數等）。隻不過，面向對象的程式設計單元是類或對象，面向過程的程式設計單元是函數，函數式程式設計的程式設計單元是無狀态函數。

Java對函數式程式設計的支援

實作面向對象程式設計不一定非得使用面向對象程式設計語言，同理，實作函數式程式設計也不一定非得使用函數式程式設計語言。現在，很多面向對象程式設計語言，也提供了相應的文法、類庫來支援函數式程式設計。

Java這種面向對象程式設計語言，對函數式程式設計的支援可以通過一個例子來描述：

public class Demo {
  public static void main(String[] args) {
    Optional<Integer> result = Stream.of("a", "be", "hello")
            .map(s -> s.length())
            .filter(l -> l <= 3)
            .max((o1, o2) -> o1-o2);
    System.out.println(result.get()); // 輸出2
  }
}

這段代碼的作用是從一組字元串數組中，過濾出長度小于等于3的字元串，并且求得這其中的最大長度。

Java為函數式程式設計引入了三個新的文法概念：Stream類、Lambda表達式和函數接口（Functional Inteface）。Stream類用來支援通過“.”級聯多個函數操作的代碼編寫方式；引入Lambda表達式的作用是簡化代碼編寫；函數接口的作用是讓我們可以把函數包裹成函數接口，來實作把函數當做參數一樣來使用（Java 不像C那樣支援函數指針，可以把函數直接當參數來使用）。

Stream類

假設我們要計算這樣一個表達式：(3-1)*2+5。如果按照普通的函數調用的方式寫出來，就是下面這個樣子：

add(multiply(subtract(3,1),2),5);

不過，這樣編寫代碼看起來會比較難了解，我們換個更易讀的寫法，如下所示：

subtract(3,1).multiply(2).add(5);

在Java中，“.”表示調用某個對象的方法。為了支援上面這種級聯調用方式，我們讓每個函數都傳回一個通用的Stream類對象。在Stream類上的操作有兩種：中間操作和終止操作。中間操作傳回的仍然是Stream類對象，而終止操作傳回的是确定的值結果。

再來看之前的例子，對代碼做了注釋解釋。其中map、filter是中間操作，傳回Stream類對象，可以繼續級聯其他操作；max是終止操作，傳回的不是Stream類對象，無法再繼續往下級聯處理了。

public class Demo {
  public static void main(String[] args) {
    Optional<Integer> result = Stream.of("f", "ba", "hello") // of傳回Stream<String>對象
            .map(s -> s.length()) // map傳回Stream<Integer>對象
            .filter(l -> l <= 3) // filter傳回Stream<Integer>對象
            .max((o1, o2) -> o1-o2); // max終止操作：傳回Optional<Integer>
    System.out.println(result.get()); // 輸出2
  }
}

Lambda表達式

前面提到Java引入Lambda表達式的主要作用是簡化代碼編寫。實際上，我們也可以不用Lambda表達式來書寫例子中的代碼。我們拿其中的map函數來舉例說明。

下面三段代碼，第一段代碼展示了map函數的定義，實際上，map函數接收的參數是一個Function接口，也就是函數接口。第二段代碼展示了map函數的使用方式。第三段代碼是針對第二段代碼用Lambda表達式簡化之後的寫法。實際上，Lambda表達式在Java中隻是一個文法糖而已，底層是基于函數接口來實作的，也就是第二段代碼展示的寫法。

// Stream類中map函數的定義：
public interface Stream<T> extends BaseStream<T, Stream<T>> {
  <R> Stream<R> map(Function<? super T, ? extends R> mapper);
  //...省略其他函數...
}

// Stream類中map的使用方法示例：
Stream.of("fo", "bar", "hello").map(new Function<String, Integer>() {
  @Override
  public Integer apply(String s) {
    return s.length();
  }
});

// 用Lambda表達式簡化後的寫法：
Stream.of("fo", "bar", "hello").map(s -> s.length());

Lambda表達式包括三部分：輸入、函數體、輸出。表示出來的話就是下面這個樣子：

(a, b) -> { 語句1；語句2；...; return 輸出; } //a,b是輸入參數

實際上，Lambda表達式的寫法非常靈活。上面給出的是标準寫法，還有很多簡化寫法。比如，如果輸入參數隻有一個，可以省略 ()，直接寫成 a->{…}；如果沒有入參，可以直接将輸入和箭頭都省略掉，隻保留函數體；如果函數體隻有一個語句，那可以将{}省略掉；如果函數沒有傳回值，return語句就可以不用寫了。

Optional<Integer> result = Stream.of("f", "ba", "hello")
        .map(s -> s.length())
        .filter(l -> l <= 3)
        .max((o1, o2) -> o1-o2);
        
// 還原為函數接口的實作方式
Optional<Integer> result2 = Stream.of("fo", "bar", "hello")
        .map(new Function<String, Integer>() {
          @Override
          public Integer apply(String s) {
            return s.length();
          }
        })
        .filter(new Predicate<Integer>() {
          @Override
          public boolean test(Integer l) {
            return l <= 3;
          }
        })
        .max(new Comparator<Integer>() {
          @Override
          public int compare(Integer o1, Integer o2) {
            return o1 - o2;
          }
        });

Lambda表達式與匿名類的異同集中展現在以下三點上：

Lambda就是為了優化匿名内部類而生，Lambda要比匿名類簡潔的多得多。
Lambda僅适用于函數式接口，匿名類不受限。
即匿名類中的this是“匿名類對象”本身；Lambda表達式中的this是指“調用Lambda表達式的對象”。

函數接口

實際上，上面一段代碼中的Function、Predicate、Comparator都是函數接口。我們知道，C語言支援函數指針，它可以把函數直接當變量來使用。

但是，Java沒有函數指針這樣的文法。是以它通過函數接口，将函數包裹在接口中，當作變量來使用。實際上，函數接口就是接口。不過，它也有自己特别的地方，那就是要求隻包含一個未實作的方法。因為隻有這樣，Lambda表達式才能明确知道比對的是哪個方法。如果有兩個未實作的方法，并且接口入參、傳回值都一樣，那Java在翻譯Lambda表達式的時候，就不知道表達式對應哪個方法了。

函數式接口也是Java interface的一種，但還需要滿足：

一個函數式接口隻有一個抽象方法(single abstract method)；
Object類中的public abstract method不會被視為單一的抽象方法；
函數式接口可以有預設方法和靜态方法；
函數式接口可以用@FunctionalInterface注解進行修飾。

滿足這些條件的interface，就可以被視為函數式接口。例如Java 8中的Comparator接口：

@FunctionalInterface
public interface Comparator<T> {
    /**
     * single abstract method
     * @since 1.8
     */
    int compare(T o1, T o2);

    /**
     * Object類中的public abstract method 
     * @since 1.8
     */
    boolean equals(Object obj);

    /**
     * 預設方法
     * @since 1.8
     */
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    
    /**
     * 靜态方法
     * @since 1.8
     */
    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }

    //省略...
}

函數式接口有什麼用呢？一句話，函數式接口帶給我們最大的好處就是：可以使用極簡的lambda表達式執行個體化接口。為什麼這麼說呢？我們或多或少使用過一些隻有一個抽象方法的接口，比如Runnable、ActionListener、Comparator等等，比如我們要用Comparator實作排序算法，我們的處理方式通常無外乎兩種：

規規矩矩的寫一個實作了Comparator接口的Java類去封裝排序邏輯。若業務需要多種排序方式，那就得寫多個類提供多種實作，而這些實作往往隻需使用一次。
另外一種聰明一些的做法無外乎就是在需要的地方搞個匿名内部類，比如：

public class Test { 
    public static void main(String args[]) { 
        List<Person> persons = new ArrayList<Person>();
        Collections.sort(persons, new Comparator<Person>(){
            @Override
            public int compare(Person o1, Person o2) {
                return Integer.compareTo(o1.getAge(), o2.getAge());
            }
        });
    } 
}

匿名内部類實作的代碼量沒有多到哪裡去，結構也還算清晰。Comparator接口在Jdk 1.8的實作增加了FunctionalInterface注解，代表Comparator是一個函數式接口，使用者可放心的通過lambda表達式來執行個體化。那我們來看看使用lambda表達式來快速new一個自定義比較器所需要編寫的代碼：

Comparator<Person> comparator = (p1, p2) -> Integer.compareTo(p1.getAge(), p2.getAge());

-> 前面的 () 是Comparator接口中compare方法的參數清單，-> 後面則是compare方法的方法體。

下面将Java提供的Function、Predicate這兩個函數接口的源碼，摘抄如下：

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);  // 隻有這一個未實作的方法

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

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

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t); // 隻有這一個未實作的方法

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

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

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

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

@FunctionalInterface注解使用場景

我們知道，一個接口隻要滿足隻有一個抽象方法的條件，即可以當成函數式接口使用，有沒有 @FunctionalInterface 都無所謂。但是jdk定義了這個注解肯定是有原因的，對于開發者，該注解的使用一定要三思而後續行。

如果使用了此注解，再往接口中新增抽象方法，編譯器就會報錯，編譯不通過。換句話說，@FunctionalInterface 就是一個承諾，承諾該接口世世代代都隻會存在這一個抽象方法。是以，凡是使用了這個注解的接口，開發者可放心大膽的使用Lambda來執行個體化。當然誤用 @FunctionalInterface 帶來的後果也是極其慘重的：如果哪天你把這個注解去掉，再加一個抽象方法，則所有使用Lambda執行個體化該接口的用戶端代碼将全部編譯錯誤。

特别地，當某接口隻有一個抽象方法，但沒有用 @FunctionalInterface 注解修飾時，則代表别人沒有承諾該接口未來不增加抽象方法，是以建議不要用Lambda來執行個體化，還是老老實實的用以前的方式比較穩妥。

小結

函數式程式設計更符合數學上函數映射的思想。具體到程式設計語言層面，我們可以使用Lambda表達式來快速編寫函數映射，函數之間通過鍊式調用連接配接到一起，完成所需業務邏輯。Java的Lambda表達式是後來才引入的，由于函數式程式設計在并行處理方面的優勢，正在被大量應用在大資料計算領域。

Java如何支援函數式程式設計？

背景

什麼是函數式程式設計

Java對函數式程式設計的支援

Stream類

Lambda表達式

函數接口

小結

繼續閱讀

JS生成uuid的四種方法

線性表之順序表的實作

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

C++判斷素數、求最大公約數代碼判斷一個數是否為素數求兩個數的最大公約數

SequoiaDB巨杉資料庫C++驅動概述

OOM三種類型

工廠模式-三種類型

【python】netconf協定對接管理裝置

「Python 網絡自動化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 網絡裝置

【遞歸】高效率求2的n次幂

layui多任務上傳添加進度條

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

在python中建立excel并寫入

hdu7108哈希