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

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

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

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

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

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

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

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

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

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

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

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

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

λ表達(dá)式可以被當(dāng)做是一個(gè)Object（注意措辭）。λ表達(dá)式的類(lèi)型，叫做“目標(biāo)類(lèi)型（target type）”。λ表達(dá)式的目標(biāo)類(lèi)型是“函數(shù)接口（functional interface）”，這是Java8新引入的概念。它的定義是：一個(gè)接口，如果只有一個(gè)顯式聲明的抽象方法，那么它就是一個(gè)函數(shù)接口。一般用@FunctionalInterface標(biāo)注出來(lái)（也可以不標(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)類(lèi)型不明    必須先轉(zhuǎn)型:

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

假設(shè)你自己寫(xiě)了一個(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!");};

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

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

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

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

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

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

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

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

λ表達(dá)式主要用于替換以前廣泛使用的內(nèi)部匿名類(lèi)，各種回調(diào)，比如事件響應(yīng)器、傳入Thread類(lèi)的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è)線(xiàn)程里的λ表達(dá)式，你并不需要顯式地把它轉(zhuǎn)成一個(gè)Runnable，因?yàn)镴ava能根據(jù)上下文自動(dòng)推斷出來(lái)：一個(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)是：配合“集合類(lèi)批處理操作”的內(nèi)部迭代和并行處理（下面將要講到）；長(zhǎng)期目標(biāo)是將Java向函數(shù)式編程語(yǔ)言這個(gè)方向引導(dǎo)（并不是要完全變成一門(mén)函數(shù)式編程語(yǔ)言，只是讓它有更多的函數(shù)式編程語(yǔ)言的特性），也正是由于這個(gè)原因，Oracle并沒(méi)有簡(jiǎn)單地使用內(nèi)部類(lèi)去實(shí)現(xiàn)λ表達(dá)式，而是使用了一種更動(dòng)態(tài)、更靈活、易于將來(lái)擴(kuò)展和改變的策略（invokedynamic）。

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

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

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

可以寫(xiě)成：

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

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

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

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

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

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

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

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

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

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

    //給出一個(gè)String類(lèi)型的數(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類(lèi)型的參數(shù)，上面介紹了，F(xiàn)unction是個(gè)函數(shù)接口，所以這里用λ表達(dá)式。

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

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

第五步：用collect方法將最終結(jié)果收集到一個(gè)List里面去。collect方法接受一個(gè)Collector類(lèi)型的參數(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類(lèi)型的參數(shù)，分別用以生成鍵和值，F(xiàn)unction是個(gè)函數(shù)接口，所以這里都用λ表達(dá)式。

你可能會(huì)覺(jué)得在這個(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è)元素依次通過(guò)這些管道。例如有個(gè)元素“3”，首先它被map成整數(shù)型3；然后通過(guò)filter，發(fā)現(xiàn)是素?cái)?shù)，被保留下來(lái)；又通過(guò)distinct，如果已經(jīng)有一個(gè)3了，那么就直接丟棄，如果還沒(méi)有則保留。這樣，3個(gè)操作其實(shí)只經(jīng)過(guò)了一次循環(huán)。

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

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

    //給出一個(gè)String類(lèi)型的數(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類(lèi)型的數(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方法用來(lái)產(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ù)，注意須用this限定    protected UnaryOperator<Integer> factorial = i -> i == 0 ? 1 : i * this.factorial.apply( i - 1 );    ...    System.out.println(factorial.apply(3));

在Java中，隨聲明隨調(diào)用的方式是不行的，比如下面這樣，聲明了一個(gè)λ表達(dá)式(x, y) -> x + y，同時(shí)企圖通過(guò)傳入實(shí)參(2, 3)來(lái)調(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)部定義的本地變量）的問(wèn)題。

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

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

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

    ...        int tmp1 = 1; //包圍類(lèi)的成員變量    static int tmp2 = 2; //包圍類(lèi)的靜態(tài)成員變量    public void testCapture() {        int tmp3 = 3; //沒(méi)有聲明為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的原因是多線(xiàn)程并發(fā)問(wèn)題。內(nèi)部類(lèi)、λ表達(dá)式都有可能在不同的線(xiàn)程中執(zhí)行，允許多個(gè)線(xiàn)程同時(shí)修改一個(gè)本地變量不符合Java的設(shè)計(jì)理念。

4.2 方法引用（Method reference）

任何一個(gè)λ表達(dá)式都可以代表某個(gè)函數(shù)接口的唯一方法的匿名描述符。我們也可以使用某個(gè)類(lèi)的某個(gè)具體方法來(lái)代表這個(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ì)變得更短些。現(xiàn)在distinctPrimarySum方法可以改寫(xiě)如下：

    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ì)象的父類(lèi)方法    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í)際上混淆了接口和抽象類(lèi)，但一個(gè)類(lèi)仍然可以實(shí)現(xiàn)多個(gè)接口，而只能繼承一個(gè)抽象類(lèi)。

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

如此一來(lái)，我們就面臨一種類(lèi)似多繼承的問(wèn)題。如果類(lèi)Sub繼承了兩個(gè)接口，Base1和Base2，而這兩個(gè)接口恰好具有完全相同的兩個(gè)默認(rèn)方法，那么就會(huì)產(chǎn)生沖突。這時(shí)Sub類(lèi)就必須通過(guò)重載來(lái)顯式指明自己要使用哪一個(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)，如果沒(méi)有這個(gè)調(diào)用，那么這條語(yǔ)句會(huì)永遠(yuǎn)地執(zhí)行下去。也就是說(shuō)這個(gè)生成器是無(wú)窮的。這種調(diào)用叫做終結(jié)操作，或者短路（short-circuiting）操作。