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ù)類型也可以省略，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推斷出類型，那么參數(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)注出來(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)類型不明 

必須先轉(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!");};

都是正確的寫法。這說(shuō)明一個(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的唯一不同是它沒(méi)有返回值。

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

還有一個(gè)Predicate，用來(lái)判斷某項(xiàng)條件是否滿足。經(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)部匿名類，各種回調(diào)，比如事件響應(yīng)器、傳入Thread類的Runnable等?？聪旅娴睦樱?/p>

 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)推斷出來(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)是：配合“集合類批處理操作”的內(nèi)部迭代和并行處理（下面將要講到）；長(zhǎng)期目標(biāo)是將Java向函數(shù)式編程語(yǔ)言這個(gè)方向引導(dǎo)（并不是要完全變成一門函數(shù)式編程語(yǔ)言，只是讓它有更多的函數(shù)式編程語(yǔ)言的特性），也正是由于這個(gè)原因，Oracle并沒(méi)有簡(jiǎn)單地使用內(nèi)部類去實(shí)現(xiàn)λ表達(dá)式，而是使用了一種更動(dòng)態(tài)、更靈活、易于將來(lá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ù)來(lái)進(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)部迭代方法廣泛存在于各種語(yǔ)言，如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è)語(yǔ)句里串起來(lái)?？聪旅娴睦樱?/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()一樣，只不過(guò)指明要并行處理，以期充分利用現(xiàn)代CPU的多核特性。  

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

來(lái)看更多的例子。下面是典型的大數(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方法，過(guò)濾那些不是素?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ì)覺(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類型的數(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方法用來(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)部類非常相似，但有不同點(diǎn)。不同點(diǎn)在于內(nèi)部類總是持有一個(gè)其外部類對(duì)象的引用。而λ表達(dá)式呢，除非在它內(nèi)部用到了其外部類（包圍類）對(duì)象的方法或者成員，否則它就不持有這個(gè)對(duì)象的引用。

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

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

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

4.2 方法引用（Method reference）

任何一個(gè)λ表達(dá)式都可以代表某個(gè)函數(shù)接口的唯一方法的匿名描述符。我們也可以使用某個(gè)類的某個(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ì)變得更短些?，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é)的辦法。

如此一來(lái)，我們就面臨一種類似多繼承的問(wèn)題。如果類Sub繼承了兩個(gè)接口，Base1和Base2，而這兩個(gè)接口恰好具有完全相同的兩個(gè)默認(rèn)方法，那么就會(huì)產(chǎn)生沖突。這時(shí)Sub類就必須通過(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）操作。

參考資料：

http://openjdk.java.net/projects/lambda/

http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

以上所述是小編給大家介紹的Java8中的 Lambda表達(dá)式教程，希望對(duì)大家有所幫助，如果大家有任何疑問(wèn)請(qǐng)給我留言，小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對(duì)腳本之家網(wǎng)站的支持！

最新評(píng)論