Java8新特性（拉姆達表達式lambda）

一、函數式接口

　　函數式接口（functional interface 也叫功能性接口，其實是同一個東西）。簡單來說，函數式接口是只包含一個方法的接口。比如Java標准庫中的java.lang.Runnable和 java.util.Comparator都是典型的函數式接口。
　　Java 8提供 @FunctionalInterface作為注解,這個注解是非必須的，只要接口符合函數式接口的標准（即只包含一個方法的接口），虛擬機會自動判斷， 但 最好在接口上使用注解@FunctionalInterface進行聲明，以免團隊的其他人員錯誤地往接口中添加新的方法。

　　Java中的lambda無法單獨出現，它需要一個函數式接口來盛放，lambda表達式方法體其實就是函數接口的實現.

　　下面的接口就是一個函數式接口

 //添加此注解后，接口中只能有一個方法。
@FunctionalInterface
public interface A {
    void call();
}

二、lambda語法

　　包含三部分：
　　1、一個括號內用逗號分隔的形式參數，參數是函數式接口里面方法的參數
　　2、一個箭頭符號：->
　　3、方法體，可以是表達式和代碼塊。

(parameters) -> expression 或者 (parameters) -> { statements; } 

　　通過下面的代碼可以看到lambda表達式設計的代碼更簡潔，而且可讀性更好。

public class Demo1 {
    public static void main(String[] args) {
        runThreadByLambda();
        runThreadByInnerClass();
    }

    public static void runThreadByLambda() {
        /*
         Runnable就是一個函數式接口：他只有一個方法run()方法。
         1、因為run()方法沒有參數，所以   ->前面的()中不需要聲明形參
         2、run返回的是void，所以不需要return。
         3、->后面寫的代碼其實就是定義在run方法內的代碼。因為此處代碼只有一行，所以{}也可以省略。如果此處多與一行，則無法省略。
         */
        Runnable runnable = () -> System.out.println("這個是用拉姆達實現的線程");
        new Thread(runnable).start();
    }

    public static void runThreadByInnerClass() {
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                System.out.println("這個是用內部類實現的線程");

            }
        };
        new Thread(runnable).start();
    }
}

三、方法引用

　　其實是lambda表達式的一種簡化寫法。所引用的方法其實是lambda表達式的方法體實現，語法也很簡單，左邊是容器（可以是類名，實例名），中間是"::"，右邊是相應的方法名。如下所示：

ObjectReference::methodName

　　一般方法的引用格式:

　　如果是靜態方法，則是ClassName::methodName。如 Object ::equals
　　如果是實例方法，則是Instance::methodName。如Object obj=new Object();obj::equals;
　　構造函數.則是ClassName::new

public class Demo2 {

    public static void main(String[] args) {
        /*
         * 方法引用
         */
        Runnable runnable = Demo2::run;
        new Thread(runnable).start();
    }
    
    public static void run(){
        System.out.println("方法引用的代碼...");
    }
}

　　可以看出，doSomething方法就是lambda表達式的實現，這樣的好處就是，如果你覺得lambda的方法體會很長，影響代碼可讀性，方法引用就是個解決辦法

四、默認方法—接口改進

　　簡單說，就是接口可以有實現方法，而且不需要實現類去實現其方法。只需在方法名前面加個default關鍵字即可。

@FunctionalInterface
public interface A {
    void call();

    default void fun() {
        System.out.println("我是接口的默認方法1中的代碼");
    }

    default void fun2() {
        System.out.println("我是接口的默認方法2中的代碼");
    }
}

　　為什么要有這個特性？首先，之前的接口是個雙刃劍，好處是面向抽象而不是面向具體編程，缺陷是，當需要修改接口時候，需要修改全部實現該接口的類，目前的 Java 8之前的集合框架沒有foreach方法，通常能想到的解決辦法是在JDK里給相關的接口添加新的方法及實現。然而，對於已經發布的版本，是沒法在給接口 添加新方法的同時不影響已有的實現。所以引進的默認方法。他們的目的是為了使接口沒有引入與現有的實現不兼容發展。

Java8中接口和抽象類的區別

形同點：
1.都是抽象類型；
2.都可以有實現方法（以前接口不行）；
3.都可以不需要實現類或者繼承者去實現所有方法，（以前不行，現在接口中默認方法不需要實現者實現）
不同點
1.抽象類不可以多重繼承，接口可以（無論是多重類型繼承還是多重行為繼承）；
2.抽象類和接口所反映出的設計理念不同。其實抽象類表示的是"is-a"關系，接口表示的是"like-a"關系；
3.接口中定義的變量默認是public static final 型，且必須給其初值，所以實現類中不能重新定義，也不能改變其值；抽象類中的變量默認是 default 型，其值可以在子類中重新定義，也可以重新賦值。

總結：默認方法給予我們修改接口而不破壞原來的實現類的結構提供了便利，目前Java 8的集合框架已經大量使用了默認方法來改進了，當我們最終開始使用Java 8的lambdas表達式時，提供給我們一個平滑的過渡體驗。也許將來我們會在API設計中看到更多的默認方法的應用。

五、使用lambda改進的集合框架

5.1 集合中內部迭代

import java.util.ArrayList;
import java.util.List;

public class Demo3 {
    public static void main(String[] args) {
        List<User> users = new ArrayList<User>();
        users.add(new User(20, "張三"));
        users.add(new User(22, "李四"));
        users.add(new User(10, "王五"));

        users.forEach((User user) -> System.out.println(user.getAge()));
    }
}

5.2 Stream API

　　流（Stream）僅僅代表着數據流，並沒有數據結構，所以他遍歷完一次之后便再也無法遍歷（這點在編程時候需要注意，不像Collection，遍歷多少次里面都還有數據），它的來源可以是Collection、array、io等等。

　　流作用是提供了一種操作大數據接口，讓數據操作更容易和更快。它具有過濾、映射以及減少遍歷數等方法，這些方法分兩種：中間方法和終端方法，“流”抽象天生就該是持續的，中間方法永遠返回的是Stream，因此如果我們要獲取最終結果的話，必須使用終點操作才能收集流產生的最終結果。區分這兩個方法是看他的返回值，如果是Stream則是中間方法，否則是終點方法。

filter

　　在數據流中實現過濾功能是首先我們可以想到的最自然的操作了。Stream接口暴露了一個filter方法，它可以接受表示操作的Predicate實現來使用定義了過濾條件的lambda表達式。

import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        List<User> users = new ArrayList<User>();
        users.add(new User(20, "張三"));
        users.add(new User(22, "李四"));
        users.add(new User(10, "王五"));
        
        Stream<User> stream = users.stream();
        stream.filter(p -> p.getAge() > 20); //過濾年齡大於20的
    }
}

map

　　假使我們現在過濾了一些數據，比如轉換對象的時候。Map操作允許我們執行一個Function的實現（Function<T,R>的泛型T,R分別表示執行輸入和執行結果），它接受入參並返回。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        List<User> users = new ArrayList<User>();
        users.add(new User(20, "張三"));
        users.add(new User(22, "李四"));
        users.add(new User(10, "王五"));
        
        Stream<User> stream = users.stream();
         //所有的年齡大於20歲的User對象，轉換為字符串50對象。現在流中只有字符串對象了。
        stream.filter((User user) ->  user.getAge() > 20).map((User user) -> {return "50";});
    }
}

count

　　count方法是一個流的終點方法，可使流的結果最終統計，返回long

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        List<User> users = new ArrayList<User>();
        users.add(new User(20, "張三"));
        users.add(new User(22, "李四"));
        users.add(new User(10, "王五"));
        
        Stream<User> stream = users.stream();
        long count = stream.filter((User user) ->  user.getAge() >= 20).map((User user) -> {return "50";})
        .count(); //返回流中元素的個數。
        System.out.println(count);    
    }
}