lambda表達式詳解

（轉自：http://blog.csdn.net/ioriogami/article/details/12782141/）

 

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）操做。