Lambda 表達式，也可稱為閉包，它是推動 Java 8 發(fā)布的最重要新特性。

Lambda 允許把函數(shù)作為一個方法的參數(shù)（函數(shù)作為參數(shù)傳遞進方法中）。

使用 Lambda 表達式可以使代碼變的更加簡潔緊湊。

語法

(Type1 param1, Type2 param2, ..., TypeN paramN) -> {
  statement1;
  statement2;
  //.............
  return statementM;
}

lambda表達式的重要特征:

• 可選類型聲明：不需要聲明參數(shù)類型，編譯器可以統(tǒng)一識別參數(shù)值。
• 可選的參數(shù)圓括號：一個參數(shù)無需定義圓括號，但多個參數(shù)或沒有參數(shù)需要定義圓括號。
• 可選的大括號：如果主體包含了一個語句，就不需要使用大括號。
• 可選的返回關(guān)鍵字：如果主體只有一個表達式返回值則編譯器會自動返回值，大括號需要指定明表達式返回了一個數(shù)值。

簡單例子：

// 1. 不需要參數(shù),返回值為 5  
() -> 5  
  
// 2. 接收一個參數(shù)(數(shù)字類型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2個參數(shù)(數(shù)字),并返回他們的差值  
(x, y) -> x – y  
  
// 4. 接收2個int型整數(shù),返回他們的和  
(int x, int y) -> x + y  
  
// 5. 接受一個 string 對象,并在控制臺打印,不返回任何值(看起來像是返回void)  
(String s) -> System.out.print(s)

對于Lambda語法的簡潔緊湊，我們可以和之前的常用語法做個對比：

• 不使用Lambda

public class Test {

    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        List<Integer> arrayList = Arrays.asList(array);
        System.out.println("排序前：");
//        遍歷集合，我們常用的方法有for循環(huán)，增強的for循環(huán)，迭代器遍歷
        for (Integer number : arrayList) {
            System.out.print(number + " ");
        }
//        將集合內(nèi)數(shù)字降序排序
        arrayList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println("\n排序后：");
//        遍歷集合
        for (Integer number : arrayList) {
            System.out.print(number + " ");
        }
    }
}

• 使用Lambda

public class Test {

    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        List<Integer> arrayList = Arrays.asList(array);
        System.out.println("排序前：");
//        遍歷集合
        arrayList.forEach(x -> System.out.print(x + " "));
//        將集合內(nèi)數(shù)字降序排序
        arrayList.sort((o1, o2) -> o2.compareTo(o1));
        System.out.println("\n排序后：");
//        遍歷集合
        arrayList.forEach(x -> System.out.print(x + " "));
    }
}

可以很直觀地看到，Lambda語法更加簡潔緊湊，尤其是對于上例匿名方法Comparator的使用中可以體現(xiàn)這一點。

輸出均為：

排序前：
1 2 3 4 5 6 7 
排序后：
7 6 5 4 3 2 1 

變量作用域

lambda 表達式只能引用標記了 final 的外層局部變量，這就是說不能在 lambda 內(nèi)部修改定義在域外的局部變量，否則會編譯錯誤。

public class Test {

    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        List<Integer> arrayList = Arrays.asList(array);
        final int DOUBLE = 2;
        arrayList.forEach(x -> System.out.println(x * DOUBLE));
    }
}

輸出：

2
4
6
8
10
12
14

lambda 表達式的局部變量可以不用聲明為 final，但是必須不可被后面的代碼修改（即隱性的具有 final 的語義）

• 隱性的具有 final 的語義

    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        List<Integer> arrayList = Arrays.asList(array);
        int DOUBLE = 2;
        arrayList.forEach(x -> System.out.println(x * DOUBLE));
    }
}

輸出：

2
4
6
8
10
12
14

• 非final

public class Test {

    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        List<Integer> arrayList = Arrays.asList(array);
        int DOUBLE = 2;
        arrayList.forEach(x -> System.out.println(x * DOUBLE));
        DOUBLE = 3;
    }
}

編譯時會報錯：從lambda 表達式引用的本地變量必須是最終變量或?qū)嶋H上的最終變量。

另外，在 Lambda 表達式當中不允許聲明一個與局部變量同名的參數(shù)或者局部變量。

public class Test {

    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        List<Integer> arrayList = Arrays.asList(array);
        int first = 1;
        arrayList.sort((first, second) -> first.compareTo(second));
        arrayList.forEach(x -> System.out.println(x));
    }
}

編譯時會報錯：已在方法 main(java.lang.String[])中定義了變量 first

方法引用

靜態(tài)方法或?qū)嵗椒ǖ囊谜Z法：

Class or instance :: method

則上面例子中的遍歷并輸出集合元素的代碼，也可以寫為：

public class Test {

    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        List<Integer> arrayList = Arrays.asList(array);
        arrayList.forEach(System.out::println);
    }
}

構(gòu)造器引用

語法：

ClassName::new

例子

有一個Cat類：

public class Cat {
    private String name;

    public Cat(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

有一個nameList，遍歷nameList，調(diào)用Cat構(gòu)造函數(shù)，生成一個catList：

import java.util.*;
import java.util.function.Function;

public class Test {

    public static void main(String[] args) {
        String[] array = {"tay", "mere", "amy"};
        List<String> nameList = Arrays.asList(array);
        List<Cat> cats = getCatList(nameList, Cat::new);
        cats.forEach(cat -> System.out.println(cat.getName()));
    }

    public static List<Cat> getCatList(List<String> nameList, Function<String, Cat> function) {
        List<Cat> result = new ArrayList<>();
        nameList.forEach(name -> result.add(function.apply(name)));
        return result;
    }
}

輸出：

tay
mere
amy