1. 什么是λ表達(dá)式

λ表達(dá)式本質(zhì)上是一個(gè)匿名方法。讓我們來看下面這個(gè)例子：

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

轉(zhuǎn)成λ表達(dá)式后是這個(gè)樣子：
   
    (int x, int y) -> x + y;

參數(shù)類型也可以省略,，Java編譯器會(huì)根據(jù)上下文推斷出來：

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

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

可見λ表達(dá)式有三部分組成：參數(shù)列表,，箭頭（->），以及一個(gè)表達(dá)式或語句塊,。

下面這個(gè)例子里的λ表達(dá)式?jīng)]有參數(shù),，也沒有返回值（相當(dāng)于一個(gè)方法接受0個(gè)參數(shù)，返回void,，其實(shí)就是Runnable里run方法的一個(gè)實(shí)現(xiàn)）：

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

如果只有一個(gè)參數(shù)且可以被Java推斷出類型，那么參數(shù)列表的括號(hào)也可以省略：

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

2. λ表達(dá)式的類型（它是Object嗎,？）

λ表達(dá)式可以被當(dāng)做是一個(gè)Object（注意措辭）,。λ表達(dá)式的類型，叫做“目標(biāo)類型（target type）”,。λ表達(dá)式的目標(biāo)類型是“函數(shù)接口（functional interface）”,，這是Java8新引入的概念。它的定義是：一個(gè)接口,，如果只有一個(gè)顯式聲明的抽象方法,，那么它就是一個(gè)函數(shù)接口。一般用@FunctionalInterface標(biāo)注出來（也可以不標(biāo)）,。舉例如下：

    @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); }

注意最后這個(gè)Comparator接口,。它里面聲明了兩個(gè)方法，貌似不符合函數(shù)接口的定義,，但它的確是函數(shù)接口,。這是因?yàn)閑quals方法是Object的，所有的接口都會(huì)聲明Object的public方法——雖然大多是隱式的,。所以,，Comparator顯式的聲明了equals不影響它依然是個(gè)函數(shù)接口。

你可以用一個(gè)λ表達(dá)式為一個(gè)函數(shù)接口賦值：
 
    Runnable r1 = () -> {System.out.println("Hello Lambda!");};
   
然后再賦值給一個(gè)Object：

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

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

必須顯式的轉(zhuǎn)型成一個(gè)函數(shù)接口才可以：

    Object o = (Runnable) () -> { System.out.println("hi"); }; // correct
   
一個(gè)λ表達(dá)式只有在轉(zhuǎn)型成一個(gè)函數(shù)接口后才能被當(dāng)做Object使用,。所以下面這句也不能編譯：

    System.out.println( () -> {} ); //錯(cuò)誤! 目標(biāo)類型不明
   
必須先轉(zhuǎn)型:

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

假設(shè)你自己寫了一個(gè)函數(shù)接口,，長(zhǎng)的跟Runnable一模一樣：

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

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

都是正確的寫法。這說明一個(gè)λ表達(dá)式可以有多個(gè)目標(biāo)類型（函數(shù)接口）,，只要函數(shù)匹配成功即可,。
但需注意一個(gè)λ表達(dá)式必須至少有一個(gè)目標(biāo)類型。

JDK預(yù)定義了很多函數(shù)接口以避免用戶重復(fù)定義,。最典型的是Function：

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

這個(gè)接口代表一個(gè)函數(shù),，接受一個(gè)T類型的參數(shù)，并返回一個(gè)R類型的返回值。   

另一個(gè)預(yù)定義函數(shù)接口叫做Consumer,，跟Function的唯一不同是它沒有返回值,。

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

還有一個(gè)Predicate，用來判斷某項(xiàng)條件是否滿足,。經(jīng)常用來進(jìn)行篩濾操作：
   
    @FunctionalInterface
    public interface Predicate<T> {
        boolean test(T t);
    }
   
綜上所述,，一個(gè)λ表達(dá)式其實(shí)就是定義了一個(gè)匿名方法，只不過這個(gè)方法必須符合至少一個(gè)函數(shù)接口,。
       
3. λ表達(dá)式的使用

3.1 λ表達(dá)式用在何處

λ表達(dá)式主要用于替換以前廣泛使用的內(nèi)部匿名類,，各種回調(diào)，比如事件響應(yīng)器,、傳入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).");
    } );

注意第二個(gè)線程里的λ表達(dá)式,，你并不需要顯式地把它轉(zhuǎn)成一個(gè)Runnable,，因?yàn)镴ava能根據(jù)上下文自動(dòng)推斷出來：一個(gè)Thread的構(gòu)造函數(shù)接受一個(gè)Runnable參數(shù)，而傳入的λ表達(dá)式正好符合其run()函數(shù),，所以Java編譯器推斷它為Runnable,。

從形式上看，λ表達(dá)式只是為你節(jié)省了幾行代碼,。但將λ表達(dá)式引入Java的動(dòng)機(jī)并不僅僅為此,。Java8有一個(gè)短期目標(biāo)和一個(gè)長(zhǎng)期目標(biāo)。短期目標(biāo)是：配合“集合類批處理操作”的內(nèi)部迭代和并行處理（下面將要講到）,；長(zhǎng)期目標(biāo)是將Java向函數(shù)式編程語言這個(gè)方向引導(dǎo)（并不是要完全變成一門函數(shù)式編程語言,，只是讓它有更多的函數(shù)式編程語言的特性），也正是由于這個(gè)原因,，Oracle并沒有簡(jiǎn)單地使用內(nèi)部類去實(shí)現(xiàn)λ表達(dá)式,，而是使用了一種更動(dòng)態(tài)、更靈活,、易于將來擴(kuò)展和改變的策略（invokedynamic）,。

3.2 λ表達(dá)式與集合類批處理操作（或者叫塊操作）

上文提到了集合類的批處理操作。這是Java8的另一個(gè)重要特性,，它與λ表達(dá)式的配合使用乃是Java8的最主要特性,。集合類的批處理操作API的目的是實(shí)現(xiàn)集合類的“內(nèi)部迭代”，并期望充分利用現(xiàn)代多核CPU進(jìn)行并行計(jì)算,。
Java8之前集合類的迭代（Iteration）都是外部的,，即客戶代碼。而內(nèi)部迭代意味著改由Java類庫(kù)來進(jìn)行迭代,，而不是客戶代碼,。例如：

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

可以寫成：

    list.forEach(o -> {System.out.println(o);}); //forEach函數(shù)實(shí)現(xiàn)內(nèi)部迭代

集合類（包括List）現(xiàn)在都有一個(gè)forEach方法,，對(duì)元素進(jìn)行迭代（遍歷），所以我們不需要再寫for循環(huán)了,。forEach方法接受一個(gè)函數(shù)接口Consumer做參數(shù),，所以可以使用λ表達(dá)式。

這種內(nèi)部迭代方法廣泛存在于各種語言,，如C++的STL算法庫(kù),、python、ruby,、scala等,。

Java8為集合類引入了另一個(gè)重要概念：流（stream）。一個(gè)流通常以一個(gè)集合類實(shí)例為其數(shù)據(jù)源,，然后在其上定義各種操作,。流的API設(shè)計(jì)使用了管道（pipelines）模式。對(duì)流的一次操作會(huì)返回另一個(gè)流,。如同IO的API或者StringBuffer的append方法那樣,，從而多個(gè)不同的操作可以在一個(gè)語句里串起來?？聪旅娴睦樱?/p>

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

首先調(diào)用stream方法，以集合類對(duì)象shapes里面的元素為數(shù)據(jù)源,，生成一個(gè)流,。然后在這個(gè)流上調(diào)用filter方法，挑出藍(lán)色的,，返回另一個(gè)流,。最后調(diào)用forEach方法將這些藍(lán)色的物體噴成紅色。（forEach方法不再返回流,，而是一個(gè)終端方法,，類似于StringBuffer在調(diào)用若干append之后的那個(gè)toString）

filter方法的參數(shù)是Predicate類型，forEach方法的參數(shù)是Consumer類型,，它們都是函數(shù)接口,，所以可以使用λ表達(dá)式。

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

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

來看更多的例子,。下面是典型的大數(shù)據(jù)處理方法，F(xiàn)ilter-Map-Reduce：

    //給出一個(gè)String類型的數(shù)組,，找出其中所有不重復(fù)的素?cái)?shù)
    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（假設(shè)都是合法的數(shù)字）,，轉(zhuǎn)成一個(gè)List,，然后調(diào)用stream()方法生成流。

第二步：調(diào)用流的map方法把每個(gè)元素由String轉(zhuǎn)成Integer,，得到一個(gè)新的流,。map方法接受一個(gè)Function類型的參數(shù)，上面介紹了,，F(xiàn)unction是個(gè)函數(shù)接口,，所以這里用λ表達(dá)式。

第三步：調(diào)用流的filter方法,，過濾那些不是素?cái)?shù)的數(shù)字,，并得到一個(gè)新流。filter方法接受一個(gè)Predicate類型的參數(shù),，上面介紹了,，Predicate是個(gè)函數(shù)接口，所以這里用λ表達(dá)式,。

第四步：調(diào)用流的distinct方法,，去掉重復(fù)，并得到一個(gè)新流,。這本質(zhì)上是另一個(gè)filter操作,。

第五步：用collect方法將最終結(jié)果收集到一個(gè)List里面去。collect方法接受一個(gè)Collector類型的參數(shù),，這個(gè)參數(shù)指明如何收集最終結(jié)果,。在這個(gè)例子中，結(jié)果簡(jiǎn)單地收集到一個(gè)List中,。我們也可以用Collectors.toMap(e->e, e->e)把結(jié)果收集到一個(gè)Map中,，它的意思是：把結(jié)果收到一個(gè)Map，用這些素?cái)?shù)自身既作為鍵又作為值,。toMap方法接受兩個(gè)Function類型的參數(shù),，分別用以生成鍵和值，F(xiàn)unction是個(gè)函數(shù)接口,，所以這里都用λ表達(dá)式,。

你可能會(huì)覺得在這個(gè)例子里，List l被迭代了好多次,，map,，filter，distinct都分別是一次循環(huán),，效率會(huì)不好,。實(shí)際并非如此。這些返回另一個(gè)Stream的方法都是“懶（lazy）”的,，而最后返回最終結(jié)果的collect方法則是“急（eager）”的,。在遇到eager方法之前,，lazy的方法不會(huì)執(zhí)行。

當(dāng)遇到eager方法時(shí),，前面的lazy方法才會(huì)被依次執(zhí)行,。而且是管道貫通式執(zhí)行。這意味著每一個(gè)元素依次通過這些管道,。例如有個(gè)元素“3”,，首先它被map成整數(shù)型3；然后通過filter,，發(fā)現(xiàn)是素?cái)?shù),，被保留下來；又通過distinct,，如果已經(jīng)有一個(gè)3了,，那么就直接丟棄，如果還沒有則保留,。這樣,，3個(gè)操作其實(shí)只經(jīng)過了一次循環(huán)。

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

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

    //給出一個(gè)String類型的數(shù)組,，找出其中各個(gè)素?cái)?shù)，并統(tǒng)計(jì)其出現(xiàn)次數(shù)
    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))

它的意思是：把結(jié)果收集到一個(gè)Map中,，用統(tǒng)計(jì)到的各個(gè)素?cái)?shù)自身作為鍵,，其出現(xiàn)次數(shù)作為值,。

下面是一個(gè)reduce的例子：

    //給出一個(gè)String類型的數(shù)組,，求其中所有不重復(fù)素?cái)?shù)的和
    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方法用來產(chǎn)生單一的一個(gè)最終結(jié)果。
流有很多預(yù)定義的reduce操作,，如sum(),，max()，min()等,。

再舉個(gè)現(xiàn)實(shí)世界里的栗子比如：

    // 統(tǒng)計(jì)年齡在25-35歲的男女人數(shù),、比例
    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 λ表達(dá)式的更多用法

    // 嵌套的λ表達(dá)式
    Callable<Runnable> c1 = () -> () -> { System.out.println("Nested lambda"); };
    c1.call().run();

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

    // 定義一個(gè)遞歸函數(shù)
    private UnaryOperator<Integer> factorial = i -> { return i == 0 ? 1 : i * factorial.apply( i - 1 ); };
    ...
    System.out.println(factorial.apply(3));

在Java中，隨聲明隨調(diào)用的方式是不行的,，比如下面這樣,，聲明了一個(gè)λ表達(dá)式(x, y) -> x + y，同時(shí)企圖通過傳入實(shí)參(2, 3)來調(diào)用它：

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

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

4. 其它相關(guān)概念

4.1 捕獲（Capture）

捕獲的概念在于解決在λ表達(dá)式中我們可以使用哪些外部變量（即除了它自己的參數(shù)和內(nèi)部定義的本地變量）的問題,。

答案是：與內(nèi)部類非常相似，但有不同點(diǎn),。不同點(diǎn)在于內(nèi)部類總是持有一個(gè)其外部類對(duì)象的引用,。而λ表達(dá)式呢，除非在它內(nèi)部用到了其外部類（包圍類）對(duì)象的方法或者成員,，否則它就不持有這個(gè)對(duì)象的引用,。

在Java8以前，如果要在內(nèi)部類訪問外部對(duì)象的一個(gè)本地變量,，那么這個(gè)變量必須聲明為final才行,。在Java8中，這種限制被去掉了,，代之以一個(gè)新的概念,，“effectively final”。它的意思是你可以聲明為final,，也可以不聲明final但是按照final來用,，也就是一次賦值永不改變。換句話說,，保證它加上final前綴后不會(huì)出編譯錯(cuò)誤,。

在Java8中，內(nèi)部類和λ表達(dá)式都可以訪問effectively final的本地變量,。λ表達(dá)式的例子如下：

    ...   
    int tmp1 = 1; //包圍類的成員變量
    static int tmp2 = 2; //包圍類的靜態(tài)成員變量
    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; // 編譯錯(cuò)！對(duì)tmp5賦值導(dǎo)致它不是effectively final的
            return tmp5;
        };
        ...
        tmp5 = 9; // 編譯錯(cuò),！對(duì)tmp5賦值導(dǎo)致它不是effectively final的
    }
    ...

Java要求本地變量final或者effectively final的原因是多線程并發(fā)問題,。內(nèi)部類、λ表達(dá)式都有可能在不同的線程中執(zhí)行,，允許多個(gè)線程同時(shí)修改一個(gè)本地變量不符合Java的設(shè)計(jì)理念,。

4.2 方法引用（Method reference）

任何一個(gè)λ表達(dá)式都可以代表某個(gè)函數(shù)接口的唯一方法的匿名描述符。我們也可以使用某個(gè)類的某個(gè)具體方法來代表這個(gè)描述符,，叫做方法引用,。例如：

    Integer::parseInt //靜態(tài)方法引用
    System.out::print //實(shí)例方法引用
    Person::new       //構(gòu)造器引用

下面是一組例子，教你使用方法引用代替λ表達(dá)式：

    //c1 與 c2 是一樣的（靜態(tài)方法引用）
    Comparator<Integer> c2 = (x, y) -> Integer.compare(x, y);
    Comparator<Integer> c1 = Integer::compare;
   
    //下面兩句是一樣的（實(shí)例方法引用1）
    persons.forEach(e -> System.out.println(e));
    persons.forEach(System.out::println);
   
    //下面兩句是一樣的（實(shí)例方法引用2）
    persons.forEach(person -> person.eat());
    persons.forEach(Person::eat);
   
    //下面兩句是一樣的（構(gòu)造器引用）
    strList.stream().map(s -> new Integer(s));
    strList.stream().map(Integer::new);
   
使用方法引用,，你的程序會(huì)變得更短些?，F(xiàn)在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 //引用某個(gè)對(duì)象的父類方法
    String[]::new //引用一個(gè)數(shù)組的構(gòu)造器

4.3 默認(rèn)方法（Default method）

Java8中，接口聲明里可以有方法實(shí)現(xiàn)了,，叫做默認(rèn)方法,。在此之前,，接口里的方法全部是抽象方法。

    public interface MyInterf {
   
        String m1();
       
        default String m2() {
            return "Hello default method!";
        }
       
    }
   
這實(shí)際上混淆了接口和抽象類,，但一個(gè)類仍然可以實(shí)現(xiàn)多個(gè)接口,，而只能繼承一個(gè)抽象類。

這么做的原因是：由于Collection庫(kù)需要為批處理操作添加新的方法,，如forEach(),，stream()等，但是不能修改現(xiàn)有的Collection接口——如果那樣做的話所有的實(shí)現(xiàn)類都要進(jìn)行修改,，包括很多客戶自制的實(shí)現(xiàn)類,。所以只好使用這種妥協(xié)的辦法。

如此一來,，我們就面臨一種類似多繼承的問題,。如果類Sub繼承了兩個(gè)接口，Base1和Base2,，而這兩個(gè)接口恰好具有完全相同的兩個(gè)默認(rèn)方法,，那么就會(huì)產(chǎn)生沖突。這時(shí)Sub類就必須通過重載來顯式指明自己要使用哪一個(gè)接口的實(shí)現(xiàn)（或者提供自己的實(shí)現(xiàn)）：
   
    public class Sub implements Base1, Base2 {
   
        public void hello() {
            Base1.super.hello(); //使用Base1的實(shí)現(xiàn)
        }
       
    }

除了默認(rèn)方法,，Java8的接口也可以有靜態(tài)方法的實(shí)現(xiàn)：

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

有時(shí)候一個(gè)流的數(shù)據(jù)源不一定是一個(gè)已存在的集合對(duì)象,，也可能是個(gè)“生成器函數(shù)”。一個(gè)生成器函數(shù)會(huì)產(chǎn)生一系列元素,，供給一個(gè)流,。Stream.generate(Supplier<T> s)就是一個(gè)生成器函數(shù)。其中參數(shù)Supplier是一個(gè)函數(shù)接口,，里面有唯一的抽象方法 <T> get(),。

下面這個(gè)例子生成并打印5個(gè)隨機(jī)數(shù)：

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

注意這個(gè)limit(5)，如果沒有這個(gè)調(diào)用,，那么這條語句會(huì)永遠(yuǎn)地執(zhí)行下去,。也就是說這個(gè)生成器是無窮的。這種調(diào)用叫做終結(jié)操作,，或者短路（short-circuiting）操作,。

參考資料：
http://openjdk./projects/lambda/
http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html