Java8中的 Lambda表達式教程

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

參考材料：

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

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

以上所述是給大家引見的Java8中的 Lambda表達式教程，希望對大家有所協助，假如大家有任何疑問請給我留言，會及時回復大家的。在此也十分感激大家對網站的支持！