轉(zhuǎn)載做筆記戳

1.什么是Lambda

λ表達(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ù)類型也可以省略，編譯器會(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(); }//runnbale

public interface Callable<V> { V call() throws Exception; }//回調(diào)

public interface ActionListener { void actionPerformed(ActionEvent e); }//監(jiān)聽

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á)式的使用

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。

Java8有一個(gè)短期目標(biāo)和一個(gè)長(zhǎng)期目標(biāo):

1.配合“集合類批處理操作”的內(nèi)部迭代和并行處理
2.將Java向函數(shù)式編程語言這個(gè)方向引導(dǎo)

2. λ表達(dá)式與Collection類批處理操作（或者叫塊操作）

上文提到了集合類的批處理操作。這是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á)式。

3.流概念

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

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

4.lambda的更多用法：

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

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

// 3.定義一個(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í)企圖通過傳入實(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.Lambda的其他用法

1.Lambda表達(dá)式作用域

總體來說,Lambda表達(dá)式的變量作用域與內(nèi)部類非常相似，只是條件相對(duì)來說，放寬了些以前內(nèi)部類要想引用外部類的變量，必須像下面這樣

 final String[] datas = new String[] { "peng", "Zhao", "li" };
       new Thread(new Runnable() {
        @Override
        public void run() {
          System.out.println(datas);
     }
}).start();

將變量聲明為final類型的，現(xiàn)在在Java 8中可以這樣寫代碼

String []datas = new String[] {"peng","Zhao","li"};
new Thread(new Runnable() {
   @Override
   public void run() {
       System.out.println(datas);
   }
}).start();

也可以這樣寫

new Thread(() -> System.out.println(datas)).start();

總之你愛怎么寫，就怎么寫吧,I don’t Care it!
看了上面的兩段代碼，能夠發(fā)現(xiàn)一個(gè)顯著的不同，就是Java 8中內(nèi)部類或者Lambda表達(dá)式對(duì)外部類變量的引用條件放松了，不要求強(qiáng)制的加上final關(guān)鍵字了，但是Java 8中要求這個(gè)變量是effectively final

What is effectively final?

Effectively final就是有效只讀變量，意思是這個(gè)變量可以不加final關(guān)鍵字，但是這個(gè)變量必須是只讀變量，即一旦定義后，在后面就不能再隨意修改，如下代碼會(huì)編譯出錯(cuò)

String []datas = new String[] {"peng","Zhao","li"};
datas = null;
new Thread(() -> System.out.println(datas)).start();

Java中內(nèi)部類以及Lambda表達(dá)式中也不允許修改外部類中的變量，這是為了避免多線程情況下的race condition
Lambda中變量以及this關(guān)鍵字

2.方法引用（Method reference）

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

1. Integer::parseInt //靜態(tài)方法引用
   2.System.out::print //實(shí)例方法引用
   3.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方法可以改寫如下：

    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)造器

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.生成器函數(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）操作。