1. 什麼是λ表示式

λ表示式本質上是一個匿名方法。讓我們來看下面這個例子：

    public int add(int x, int y) {
        return x + y;
    }

轉成λ表示式後是這個樣子：
   
    (int x, int y) -> x + y;

引數型別也可以省略，Java編譯器會根據上下文推斷出來：

    (x, y) -> x + y; //返回兩數之和
 
或者

    (x, y) -> { return x + y; } //顯式指明返回值

可見λ表示式有三部分組成：引數列表，箭頭（->），以及一個表示式或語句塊。

下面這個例子裡的λ表示式沒有引數，也沒有返回值（相當於一個方法接受0個引數，返回void，其實就是Runnable裡run方法的一個實現）：

    () -> { System.out.println("Hello Lambda!"); }

如果只有一個引數且可以被Java推斷出型別，那麼引數列表的括號也可以省略：

    c -> { return c.size(); }

2. λ表示式的型別（它是Object嗎？）

λ表示式可以被當做是一個Object（注意措辭）。λ表示式的型別，叫做“目標型別（target type）”。λ表示式的目標型別是“函式介面（functional interface）”，這是Java8新引入的概念。它的定義是：一個介面，如果只有一個顯式宣告的抽象方法，那麼它就是一個函式介面。一般用@FunctionalInterface標註出來（也可以不標）。舉例如下：

    @FunctionalInterface
    public interface Runnable { void run(); }
   
    public interface Callable<V> { V call() throws Exception; }
   
    public interface ActionListener { void actionPerformed(ActionEvent e); }
   
    public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); }

注意最後這個Comparator介面。它裡面聲明瞭兩個方法，貌似不符合函式介面的定義，但它的確是函式介面。這是因為equals方法是Object的，所有的介面都會宣告Object的public方法——雖然大多是隱式的。所以，Comparator顯式的聲明瞭equals不影響它依然是個函式介面。

你可以用一個λ表示式為一個函式介面賦值：
 
    Runnable r1 = () -> {System.out.println("Hello Lambda!");};
   
然後再賦值給一個Object：

    Object obj = r1;
   
但卻不能這樣幹：

    Object obj = () -> {System.out.println("Hello Lambda!");}; // ERROR! Object is not a functional interface!

必須顯式的轉型成一個函式接口才可以：

    Object o = (Runnable) () -> { System.out.println("hi"); }; // correct
   
一個λ表示式只有在轉型成一個函式介面後才能被當做Object使用。所以下面這句也不能編譯：

    System.out.println( () -> {} ); //錯誤! 目標型別不明
   
必須先轉型:

    System.out.println( (Runnable)() -> {} ); // 正確

假設你自己寫了一個函式介面，長的跟Runnable一模一樣：

    @FunctionalInterface
    public interface MyRunnable {
        public void run();
    }
   
那麼

    Runnable r1 =    () -> {System.out.println("Hello Lambda!");};
    MyRunnable2 r2 = () -> {System.out.println("Hello Lambda!");};

都是正確的寫法。這說明一個λ表示式可以有多個目標型別（函式介面），只要函式匹配成功即可。
但需注意一個λ表示式必須至少有一個目標型別。

JDK預定義了很多函式介面以避免使用者重複定義。最典型的是Function：

    @FunctionalInterface
    public interface Function<T, R> { 
        R apply(T t);
    }

這個介面代表一個函式，接受一個T型別的引數，並返回一個R型別的返回值。   

另一個預定義函式介面叫做Consumer，跟Function的唯一不同是它沒有返回值。

    @FunctionalInterface
    public interface Consumer<T> {
        void accept(T t);
    }

還有一個Predicate，用來判斷某項條件是否滿足。經常用來進行篩濾操作：
   
    @FunctionalInterface
    public interface Predicate<T> {
        boolean test(T t);
    }
   
綜上所述，一個λ表示式其實就是定義了一個匿名方法，只不過這個方法必須符合至少一個函式介面。
       
3. λ表示式的使用

3.1 λ表示式用在何處

λ表示式主要用於替換以前廣泛使用的內部匿名類，各種回撥，比如事件響應器、傳入Thread類的Runnable等。看下面的例子：

    Thread oldSchool = new Thread( new Runnable () {
        @Override
        public void run() {
            System.out.println("This is from an anonymous class.");
        }
    } );
   
    Thread gaoDuanDaQiShangDangCi = new Thread( () -> {
        System.out.println("This is from an anonymous method (lambda exp).");
    } );

注意第二個執行緒裡的λ表示式，你並不需要顯式地把它轉成一個Runnable，因為Java能根據上下文自動推斷出來：一個Thread的建構函式接受一個Runnable引數，而傳入的λ表示式正好符合其run()函式，所以Java編譯器推斷它為Runnable。

從形式上看，λ表示式只是為你節省了幾行程式碼。但將λ表示式引入Java的動機並不僅僅為此。Java8有一個短期目標和一個長期目標。短期目標是：配合“集合類批處理操作”的內部迭代和並行處理（下面將要講到）；長期目標是將Java向函數語言程式設計語言這個方向引導（並不是要完全變成一門函數語言程式設計語言，只是讓它有更多的函數語言程式設計語言的特性），也正是由於這個原因，Oracle並沒有簡單地使用內部類去實現λ表示式，而是使用了一種更動態、更靈活、易於將來擴充套件和改變的策略（invokedynamic）。

3.2 λ表示式與集合類批處理操作（或者叫塊操作）

上文提到了集合類的批處理操作。這是Java8的另一個重要特性，它與λ表示式的配合使用乃是Java8的最主要特性。集合類的批處理操作API的目的是實現集合類的“內部迭代”，並期望充分利用現代多核CPU進行平行計算。
Java8之前集合類的迭代（Iteration）都是外部的，即客戶程式碼。而內部迭代意味著改由Java類庫來進行迭代，而不是客戶程式碼。例如：

    for(Object o: list) { // 外部迭代
        System.out.println(o);
    }

可以寫成：

    list.forEach(o -> {System.out.println(o);}); //forEach函式實現內部迭代

集合類（包括List）現在都有一個forEach方法，對元素進行迭代（遍歷），所以我們不需要再寫for迴圈了。forEach方法接受一個函式介面Consumer做引數，所以可以使用λ表示式。

這種內部迭代方法廣泛存在於各種語言，如C++的STL演算法庫、python、ruby、scala等。

Java8為集合類引入了另一個重要概念：流（stream）。一個流通常以一個集合類例項為其資料來源，然後在其上定義各種操作。流的API設計使用了管道（pipelines）模式。對流的一次操作會返回另一個流。如同IO的API或者StringBuffer的append方法那樣，從而多個不同的操作可以在一個語句裡串起來。看下面的例子：

    List<Shape> shapes = ...
    shapes.stream()
      .filter(s -> s.getColor() == BLUE)
      .forEach(s -> s.setColor(RED));

首先呼叫stream方法，以集合類物件shapes裡面的元素為資料來源，生成一個流。然後在這個流上呼叫filter方法，挑出藍色的，返回另一個流。最後呼叫forEach方法將這些藍色的物體噴成紅色。（forEach方法不再返回流，而是一個終端方法，類似於StringBuffer在呼叫若干append之後的那個toString）

filter方法的引數是Predicate型別，forEach方法的引數是Consumer型別，它們都是函式介面，所以可以使用λ表示式。

還有一個方法叫parallelStream()，顧名思義它和stream()一樣，只不過指明要並行處理，以期充分利用現代CPU的多核特性。

    shapes.parallelStream(); // 或shapes.stream().parallel()

來看更多的例子。下面是典型的大資料處理方法，Filter-Map-Reduce：

    //給出一個String型別的陣列，找出其中所有不重複的素數
    public void distinctPrimary(String... numbers) {
        List<String> l = Arrays.asList(numbers);
        List<Integer> r = l.stream()
                .map(e -> new Integer(e))
                .filter(e -> Primes.isPrime(e))
                .distinct()
                .collect(Collectors.toList());
        System.out.println("distinctPrimary result is: " + r);
    }

第一步：傳入一系列String（假設都是合法的數字），轉成一個List，然後呼叫stream()方法生成流。

第二步：呼叫流的map方法把每個元素由String轉成Integer，得到一個新的流。map方法接受一個Function型別的引數，上面介紹了，Function是個函式介面，所以這裡用λ表示式。

第三步：呼叫流的filter方法，過濾那些不是素數的數字，並得到一個新流。filter方法接受一個Predicate型別的引數，上面介紹了，Predicate是個函式介面，所以這裡用λ表示式。

第四步：呼叫流的distinct方法，去掉重複，並得到一個新流。這本質上是另一個filter操作。

第五步：用collect方法將最終結果收集到一個List裡面去。collect方法接受一個Collector型別的引數，這個引數指明如何收集最終結果。在這個例子中，結果簡單地收集到一個List中。我們也可以用Collectors.toMap(e->e, e->e)把結果收集到一個Map中，它的意思是：把結果收到一個Map，用這些素數自身既作為鍵又作為值。toMap方法接受兩個Function型別的引數，分別用以生成鍵和值，Function是個函式介面，所以這裡都用λ表示式。

你可能會覺得在這個例子裡，List l被迭代了好多次，map，filter，distinct都分別是一次迴圈，效率會不好。實際並非如此。這些返回另一個Stream的方法都是“懶（lazy）”的，而最後返回最終結果的collect方法則是“急（eager）”的。在遇到eager方法之前，lazy的方法不會執行。

當遇到eager方法時，前面的lazy方法才會被依次執行。而且是管道貫通式執行。這意味著每一個元素依次通過這些管道。例如有個元素“3”，首先它被map成整數型3；然後通過filter，發現是素數，被保留下來；又通過distinct，如果已經有一個3了，那麼就直接丟棄，如果還沒有則保留。這樣，3個操作其實只經過了一次迴圈。

除collect外其它的eager操作還有forEach，toArray，reduce等。

下面來看一下也許是最常用的收集器方法，groupingBy：

    //給出一個String型別的陣列，找出其中各個素數，並統計其出現次數
    public void primaryOccurrence(String... numbers) {
        List<String> l = Arrays.asList(numbers);
        Map<Integer, Integer> r = l.stream()
            .map(e -> new Integer(e))
            .filter(e -> Primes.isPrime(e))
            .collect( Collectors.groupingBy(p->p, Collectors.summingInt(p->1)) );
        System.out.println("primaryOccurrence result is: " + r);
    }

注意這一行：

    Collectors.groupingBy(p->p, Collectors.summingInt(p->1))

它的意思是：把結果收集到一個Map中，用統計到的各個素數自身作為鍵，其出現次數作為值。

下面是一個reduce的例子：

    //給出一個String型別的陣列，求其中所有不重複素數的和
    public void distinctPrimarySum(String... numbers) {
        List<String> l = Arrays.asList(numbers);
        int sum = l.stream()
            .map(e -> new Integer(e))
            .filter(e -> Primes.isPrime(e))
            .distinct()
            .reduce(0, (x,y) -> x+y); // equivalent to .sum()
        System.out.println("distinctPrimarySum result is: " + sum);
    }

reduce方法用來產生單一的一個最終結果。
流有很多預定義的reduce操作，如sum()，max()，min()等。

再舉個現實世界裡的栗子比如：

    // 統計年齡在25-35歲的男女人數、比例
    public void boysAndGirls(List<Person> persons) {
        Map<Integer, Integer> result = persons.parallelStream().filter(p -> p.getAge()>=25 && p.getAge()<=35).
            collect(
                Collectors.groupingBy(p->p.getSex(), Collectors.summingInt(p->1))
        );
        System.out.print("boysAndGirls result is " + result);
        System.out.println(", ratio (male : female) is " + (float)result.get(Person.MALE)/result.get(Person.FEMALE));
    }

3.3 λ表示式的更多用法

    // 巢狀的λ表示式
    Callable<Runnable> c1 = () -> () -> { System.out.println("Nested lambda"); };
    c1.call().run();

    // 用在條件表示式中
    Callable<Integer> c2 = true ? (() -> 42) : (() -> 24);
    System.out.println(c2.call());

    // 定義一個遞迴函式，注意須用this限定
    protected UnaryOperator<Integer> factorial = i -> i == 0 ? 1 : i * this.factorial.apply( i - 1 );
    ...
    System.out.println(factorial.apply(3));

在Java中，隨宣告隨呼叫的方式是不行的，比如下面這樣，聲明瞭一個λ表示式(x, y) -> x + y，同時企圖通過傳入實參(2, 3)來呼叫它：

    int five = ( (x, y) -> x + y ) (2, 3); // ERROR! try to call a lambda in-place

這在C++中是可以的，但Java中不行。Java的λ表示式只能用作賦值、傳參、返回值等。

4. 其它相關概念

4.1 捕獲（Capture）

捕獲的概念在於解決在λ表示式中我們可以使用哪些外部變數（即除了它自己的引數和內部定義的本地變數）的問題。

答案是：與內部類非常相似，但有不同點。不同點在於內部類總是持有一個其外部類物件的引用。而λ表示式呢，除非在它內部用到了其外部類（包圍類）物件的方法或者成員，否則它就不持有這個物件的引用。

在Java8以前，如果要在內部類訪問外部物件的一個本地變數，那麼這個變數必須宣告為final才行。在Java8中，這種限制被去掉了，代之以一個新的概念，“effectively final”。它的意思是你可以宣告為final，也可以不宣告final但是按照final來用，也就是一次賦值永不改變。換句話說，保證它加上final字首後不會出編譯錯誤。

在Java8中，內部類和λ表示式都可以訪問effectively final的本地變數。λ表示式的例子如下：

    ...   
    int tmp1 = 1; //包圍類的成員變數
    static int tmp2 = 2; //包圍類的靜態成員變數
    public void testCapture() {
        int tmp3 = 3; //沒有宣告為final，但是effectively final的本地變數
        final int tmp4 = 4; //宣告為final的本地變數
        int tmp5 = 5; //普通本地變數
       
        Function<Integer, Integer> f1 = i -> i + tmp1;
        Function<Integer, Integer> f2 = i -> i + tmp2;
        Function<Integer, Integer> f3 = i -> i + tmp3;
        Function<Integer, Integer> f4 = i -> i + tmp4;
        Function<Integer, Integer> f5 = i -> {
            tmp5  += i; // 編譯錯！對tmp5賦值導致它不是effectively final的
            return tmp5;
        };
        ...
        tmp5 = 9; // 編譯錯！對tmp5賦值導致它不是effectively final的
    }
    ...

Java要求本地變數final或者effectively final的原因是多執行緒併發問題。內部類、λ表示式都有可能在不同的執行緒中執行，允許多個執行緒同時修改一個本地變數不符合Java的設計理念。

4.2 方法引用（Method reference）

任何一個λ表示式都可以代表某個函式介面的唯一方法的匿名描述符。我們也可以使用某個類的某個具體方法來代表這個描述符，叫做方法引用。例如：

    Integer::parseInt //靜態方法引用
    System.out::print //例項方法引用
    Person::new       //構造器引用

下面是一組例子，教你使用方法引用代替λ表示式：

    //c1 與 c2 是一樣的（靜態方法引用）
    Comparator<Integer> c2 = (x, y) -> Integer.compare(x, y);
    Comparator<Integer> c1 = Integer::compare;
   
    //下面兩句是一樣的（例項方法引用1）
    persons.forEach(e -> System.out.println(e));
    persons.forEach(System.out::println);
   
    //下面兩句是一樣的（例項方法引用2）
    persons.forEach(person -> person.eat());
    persons.forEach(Person::eat);
   
    //下面兩句是一樣的（構造器引用）
    strList.stream().map(s -> new Integer(s));
    strList.stream().map(Integer::new);
   
使用方法引用，你的程式會變得更短些。現在distinctPrimarySum方法可以改寫如下：

    public void distinctPrimarySum(String... numbers) {
        List<String> l = Arrays.asList(numbers);
        int sum = l.stream().map(Integer::new).filter(Primes::isPrime).distinct().sum();
        System.out.println("distinctPrimarySum result is: " + sum);
    }
   
還有一些其它的方法引用:

    super::toString //引用某個物件的父類方法
    String[]::new //引用一個數組的構造器

4.3 預設方法（Default method）

Java8中，介面聲明裡可以有方法實現了，叫做預設方法。在此之前，接口裡的方法全部是抽象方法。

    public interface MyInterf {
   
        String m1();
       
        default String m2() {
            return "Hello default method!";
        }
       
    }
   
這實際上混淆了介面和抽象類，但一個類仍然可以實現多個介面，而只能繼承一個抽象類。

這麼做的原因是：由於Collection庫需要為批處理操作新增新的方法，如forEach()，stream()等，但是不能修改現有的Collection介面——如果那樣做的話所有的實現類都要進行修改，包括很多客戶自制的實現類。所以只好使用這種妥協的辦法。

如此一來，我們就面臨一種類似多繼承的問題。如果類Sub繼承了兩個介面，Base1和Base2，而這兩個介面恰好具有完全相同的兩個預設方法，那麼就會產生衝突。這時Sub類就必須通過過載來顯式指明自己要使用哪一個介面的實現（或者提供自己的實現）：
   
    public class Sub implements Base1, Base2 {
   
        public void hello() {
            Base1.super.hello(); //使用Base1的實現
        }
       
    }

除了預設方法，Java8的介面也可以有靜態方法的實現：

    public interface MyInterf {
   
        String m1();
       
        default String m2() {
            return "Hello default method!";
        }
       
        static String m3() {
            return "Hello static method in Interface!";
        }
       
    }
   
4.4 生成器函式（Generator function）

有時候一個流的資料來源不一定是一個已存在的集合物件，也可能是個“生成器函式”。一個生成器函式會產生一系列元素，供給一個流。Stream.generate(Supplier<T> s)就是一個生成器函式。其中引數Supplier是一個函式介面，裡面有唯一的抽象方法 <T> get()。

下面這個例子生成並列印5個隨機數：

    Stream.generate(Math::random).limit(5).forEach(System.out::println);

注意這個limit(5)，如果沒有這個呼叫，那麼這條語句會永遠地執行下去。也就是說這個生成器是無窮的。這種呼叫叫做終結操作，或者短路（short-circuiting）操作。