Lambda 表達(dá)式詳解

函數(shù)式編程

函數(shù)式接口（functional interface 也叫功能性接口馁启，其實是同一個東西）。簡單來說芍秆，函數(shù)式接口是只包含一個方法的接口惯疙。比如Java標(biāo)準(zhǔn)庫中的java.lang.Runnable和 java.util.Comparator都是典型的函數(shù)式接口。java 8提供 @FunctionalInterface作為注解,這個注解是非必須的妖啥，只要接口符合函數(shù)式接口的標(biāo)準(zhǔn)（即只包含一個方法的接口）霉颠，虛擬機(jī)會自動判斷，但最好在接口上使用注解@FunctionalInterface進(jìn)行聲明荆虱，以免團(tuán)隊的其他人員錯誤地往接口中添加新的方法蒿偎。
Java中的lambda無法單獨出現(xiàn)，它需要一個函數(shù)式接口來盛放怀读，lambda表達(dá)式方法體其實就是函數(shù)接口的實現(xiàn)诉位。

Lambda語法

包含三個部分

• 一個括號內(nèi)用逗號分隔的形式參數(shù)，參數(shù)是函數(shù)式接口里面方法的參數(shù)
• 一個箭頭符號：->
• 方法體菜枷，可以是表達(dá)式和代碼塊苍糠，方法體函數(shù)式接口里面方法的實現(xiàn)，如果是代碼塊啤誊，則必須用{}來包裹起來岳瞭，且需要一個return 返回值，但有個例外蚊锹，若函數(shù)式接口里面方法返回值是void寝优，則無需{}

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

例子如下：

public class TestLambda {

    public static void runThreadUseLambda() {
        //Runnable是一個函數(shù)接口，只包含了有個無參數(shù)的枫耳，返回void的run方法乏矾；
        //所以lambda表達(dá)式左邊沒有參數(shù)，右邊也沒有return迁杨，只是單純的打印一句話
        new Thread(() ->System.out.println("lambda實現(xiàn)的線程")).start();
    }

    public static void runThreadUseInnerClass() {
        //這種方式就不多講了钻心，以前舊版本比較常見的做法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("內(nèi)部類實現(xiàn)的線程");
            }
        }).start();
    }

    public static void main(String[] args) {
        TestLambda.runThreadUseLambda();
        TestLambda.runThreadUseInnerClass();
    }
}

可以看出，使用lambda表達(dá)式設(shè)計的代碼會更加簡潔铅协，而且還可讀.

方法引用

其實是lambda表達(dá)式的一個簡化寫法捷沸，所引用的方法其實是lambda表達(dá)式的方法體實現(xiàn)，語法也很簡單狐史，左邊是容器（可以是類名痒给，實例名）说墨，中間是"::"，右邊是相應(yīng)的方法名苍柏。如下所示：

bjectReference::methodName

一般方法的引用格式是

• 如果是靜態(tài)方法尼斧，則是ClassName::methodName。如 Object ::equals
• 如果是實例方法试吁，則是Instance::methodName棺棵。如Object obj=new Object();obj::equals;
• 構(gòu)造函數(shù).則是ClassName::new

例子如下：

public class TestMethodReference {

    public static void main(String[] args) {

        JFrame frame = new JFrame();
        frame.setLayout(new FlowLayout());
        frame.setVisible(true);

        JButton button1 = new JButton("點我!");
        JButton button2 = new JButton("也點我!");

        frame.getContentPane().add(button1);
        frame.getContentPane().add(button2);
        //這里addActionListener方法的參數(shù)是ActionListener，是一個函數(shù)式接口
        //使用lambda表達(dá)式方式
        button1.addActionListener(e -> { System.out.println("這里是Lambda實現(xiàn)方式"); });
        //使用方法引用方式
        button2.addActionListener(TestMethodReference::doSomething);

    }
    /**
     * 這里是函數(shù)式接口ActionListener的實現(xiàn)方法
     * @param e
     */
    public static void doSomething(ActionEvent e) {

        System.out.println("這里是方法引用實現(xiàn)方式");

    }
}

可以看出熄捍，doSomething方法就是lambda表達(dá)式的實現(xiàn)烛恤，這樣的好處就是，如果你覺得lambda的方法體會很長余耽，影響代碼可讀性缚柏，方法引用就是個解決辦法。

lambda表達(dá)式使用實例

1. lambda表達(dá)式實現(xiàn)Runnable

// Java 8之前：
new Thread(new Runnable() {
  @Override
  public void run() {
    System.out.println("Before Java8, too much code for too little to do");
  }
}).start();
//Java 8方式：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

使用lambda表達(dá)式代替匿名類碟贾，可以使代碼更簡短船惨、清晰易于閱讀。

2. lambda表達(dá)式進(jìn)行事件處理

// Java 8之前：
JButton show =  new JButton("Show");
show.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
    System.out.println("Event handling without lambda expression is boring");
    }
});

// Java 8方式：
show.addActionListener((e) -> {
    System.out.println("Light, Camera, Action !! Lambda expressions Rocks");
});

3. lambda表達(dá)式對列表進(jìn)行迭代

// Java 8之前：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
for (String feature : features) {
    System.out.println(feature);
}
// Java 8之后：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
features.forEach(n -> System.out.println(n));

// 使用Java 8的方法引用更方便缕陕，方法引用由::雙冒號操作符標(biāo)示粱锐，
// 看起來像C++的作用域解析運算符
features.forEach(System.out::println);

由于 Java是命令式語言，Java 8之前的所有循環(huán)代碼都是順序的扛邑，即可以對其元素進(jìn)行并行化處理怜浅。如果你想做并行過濾，就需要自己寫代碼蔬崩，這并不是那么容易恶座。通過引入lambda表達(dá)式 和默認(rèn)方法，將做什么和怎么做的問題分開了沥阳，這意味著Java集合現(xiàn)在知道怎樣做迭代跨琳，并可以在API層面對集合元素進(jìn)行并行處理。

4. lambda表達(dá)式和函數(shù)式接口Predicate

public static void main(String [] args){
    List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");

    System.out.println("Languages which starts with J :");
    filter(languages, (str)-> str.startsWith("J"));

    System.out.println("Languages which ends with a ");
    filter(languages, (str)->str.endsWith("a"));

    System.out.println("Print all languages :");
    filter(languages, (str)->true);

    System.out.println("Print no language : ");
    filter(languages, (str)->false);

    System.out.println("Print language whose length greater than 4:");
    filter(languages, (str)->str.length() > 4);
}

public static void filter(List<String> names, Predicate<String> condition) {
    for(String name: names)  {
        if(condition.test(name)) {
            System.out.println(name + " ");
        }
    }
}
// 更好的辦法
public static void batterFilter(List names, Predicate condition) {
    names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {
        System.out.println(name + " ");
    });
}

除了在語言層面支持函數(shù)式編程風(fēng)格桐罕，Java 8也添加了一個包脉让，叫做 java.util.function。它包含了很多類功炮，用來支持Java的函數(shù)式編程溅潜。其中一個便是Predicate，使用 java.util.function.Predicate 函數(shù)式接口以及l(fā)ambda表達(dá)式薪伏，可以向API方法添加邏輯滚澜，用更少的代碼支持更多的動態(tài)行為

5. 在lambda表達(dá)式中加入Predicate

java.util.function.Predicate 允許將兩個或更多的 Predicate 合成一個。它提供類似于邏輯操作符AND和OR的方法嫁怀，名字叫做and()设捐、or()和xor()借浊，用于將傳入 filter() 方法的條件合并起來。例如萝招，要得到所有以J開始蚂斤，長度為四個字母的語言，可以定義兩個獨立的 Predicate 示例分別表示每一個條件即寒，然后用 Predicate.and() 方法將它們合并起來橡淆，如下所示：

/ 甚至可以用and()召噩、or()和xor()邏輯函數(shù)來合并Predicate母赵，
// 例如要找到所有以J開始，長度為四個字母的名字具滴，你可以合并兩個Predicate并傳入
Predicate<String> startsWithJ = (n) -> n.startsWith("J");
Predicate<String> fourLetterLong = (n) -> n.length() == 4;
names.stream()
    .filter(startsWithJ.and(fourLetterLong))
    .forEach((n) ->
    System.out.print("nName, which starts with 'J' and four letter long is : " + n));

6. lambda表達(dá)式的Map和Reduce示例

// 不使用lambda表達(dá)式為每個訂單加上12%的稅
List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
for (Integer cost : costBeforeTax) {
    double price = cost + .12*cost;
    System.out.println(price);
}
// 使用lambda表達(dá)式
costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);

在上個例子中凹嘲，可以看到map將集合類（例如列表）元素進(jìn)行轉(zhuǎn)換的。還有一個 reduce() 函數(shù)可以將所有值合并成一個构韵。Map和Reduce操作是函數(shù)式編程的核心操作周蹭，因為其功能，reduce 又被稱為折疊操作疲恢。另外凶朗，reduce 并不是一個新的操作，你有可能已經(jīng)在使用它显拳。SQL中類似 sum()棚愤、avg() 或者 count() 的聚集函數(shù)，實際上就是 reduce 操作杂数，因為它們接收多個值并返回一個值宛畦。流API定義的 reduceh() 函數(shù)可以接受lambda表達(dá)式，并對所有值進(jìn)行合并揍移。IntStream這樣的類有類似 average()次和、count()、sum() 的內(nèi)建方法來做 reduce 操作那伐，也有mapToLong()踏施、mapToDouble() 方法來做轉(zhuǎn)換。這并不會限制你罕邀，你可以用內(nèi)建方法读规，也可以自己定義。在這個Java 8的Map Reduce示例里燃少，我們首先對所有價格應(yīng)用 12% 的VAT束亏，然后用 reduce() 方法計算總和。

// 為每個訂單加上12%的稅
// 老方法：
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double total = 0;
for (Integer cost : costBeforeTax) {
    double price = cost + .12*cost;
    total = total + price;
}
System.out.println("Total : " + total);

// 新方法：
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();
System.out.println("Total : " + bill);

7. 通過過濾創(chuàng)建一個String列表

// 創(chuàng)建一個字符串列表阵具，每個字符串長度大于2
List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);

過濾是Java開發(fā)者在大規(guī)模集合上的一個常用操作碍遍，而現(xiàn)在使用lambda表達(dá)式和流API過濾大規(guī)模數(shù)據(jù)集合是驚人的簡單定铜。流提供了一個 filter() 方法，接受一個 Predicate 對象怕敬，即可以傳入一個lambda表達(dá)式作為過濾邏輯

8. 對列表的每個元素應(yīng)用函數(shù)

// 將字符串換成大寫并用逗號鏈接起來
List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
System.out.println(G7Countries);

我們通常需要對列表的每個元素使用某個函數(shù)揣炕，例如逐一乘以某個數(shù)、除以某個數(shù)或者做其它操作东跪。這些操作都很適合用 map() 方法畸陡，可以將轉(zhuǎn)換邏輯以lambda表達(dá)式的形式放在 map() 方法里，就可以對集合的各個元素進(jìn)行轉(zhuǎn)換了

9. 復(fù)制不同的值虽填，創(chuàng)建一個子列表

// 用所有不同的數(shù)字創(chuàng)建一個正方形列表
List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
System.out.printf("Original List : %s,  Square Without duplicates : %s %n", numbers, distinct);

利用流的 distinct() 方法來對集合進(jìn)行去重

10. 計算集合元素的最大值丁恭、最小值、總和以及平均值

//獲取數(shù)字的個數(shù)斋日、最小值牲览、最大值、總和以及平均值
List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Highest prime number in List : " + stats.getMax());
System.out.println("Lowest prime number in List : " + stats.getMin());
System.out.println("Sum of all prime numbers : " + stats.getSum());
System.out.println("Average of all prime numbers : " + stats.getAverage());

IntStream恶守、LongStream 和 DoubleStream 等流的類中第献，有個非常有用的方法叫做 summaryStatistics() ⊥酶郏可以返回 IntSummaryStatistics庸毫、LongSummaryStatistics 或者 DoubleSummaryStatistic s，描述流中元素的各種摘要數(shù)據(jù)衫樊。在本例中飒赃，我們用這個方法來計算列表的最大值和最小值。它也有 getSum() 和 getAverage() 方法來獲得列表的所有元素的總和及平均值