技術標籤：java併發程式設計

文章目錄

• 1、無型別引數
• • 1.1、多引數
  • 1.2、無引數
  • 1.3、單條執行語句
• 2、有型別引數
• 3、引用外部變數
• 4、雙冒號（::）操作符

1、無型別引數

表示式基本結構：

f -> {}

相當於一個匿名函式，引數變數是形參，語句塊是函式體。

並且可以傳入 多個引數 或 無參：

1.1、多引數

(f1,  f2) -> {}

1.2、無引數

() -> {}

1.3、單條執行語句

f -> System.out.println(f)

只有一條語句時可不加括號（但還是建議都加上括號，這樣程式碼塊邊界明確）

到這裡來個例子：

Student 類：

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return this.name + " " + this.age;
    }

    public
 
 String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

ListSort 類：

import java.util.ArrayList;
import java.util.Collections;
 

import java.util.List;

public class ListSortTest {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("張三", 20));
        students.add(new Student("李四", 18));
        students.add(new Student("王五", 19));

        System.out.println("排序前：");
        students.forEach(student -> {
            System.out.println(student.toString());
        });
		
		//排序
        Collections.sort(students, (student1, student2) -> {
            return student2.getAge() - student1.getAge();
        });	

        System.out.println("排序後：");
        students.forEach(student -> {
            System.out.println(student.toString());
        });

    }
}

forEach()是java集合迴圈遍歷的方法
輸出結果：

排序前：
張三 20
李四 18
王五 19
排序後：
張三 20
王五 19
李四 18

2、有型別引數

大多數情況下使用 Lambda 表示式是為了讓程式碼更加簡潔，所以忽略引數變數型別（無標明型別時系統會根據上下文識別）。
如果程式碼比較複雜，為了易於閱讀和維護，可以為引數變數指定型別：

forEach((Student student) ->{
	System.out.println(student.getName());
});

3、引用外部變數

就是 Lambda 表示式的語句塊 {} 裡可以引用外部的變數。
但有個條件：引用的區域性變數不允許被修改，至少從 Lambda 表示式開始之後不能修改，包括之後的外部區域。
還是用前面的 Student 類，加上個 ExternalTest 類：

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

public class ExternalTest {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("張三", 20));
        students.add(new Student("李四", 18));
        students.add(new Student("王五", 19));

        String testString;
        testString = "測試資訊";
        students.forEach(f -> {
            System.out.println(testString + f.getName());
        });
        testString = "修改一下";		//這行修改了，會報錯
    }
}

執行後發現報錯：

java: 從lambda 表示式引用的本地變數必須是最終變數或實際上的最終變數

意思就是在lambda 表示式引用的外部變數的值必須是最終值。

現在把修改的那一行註釋掉：

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

public class ExternalTest {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("張三", 20));
        students.add(new Student("李四", 18));
        students.add(new Student("王五", 19));

        String testString;
        testString = "測試資訊";
        students.forEach(f -> {
            System.out.println(testString + f.getName());
        });
//        testString = "修改一下";		//這行修改了，會報錯
    }
}

就可以正常運行了：

測試資訊張三
測試資訊李四
測試資訊王五

4、雙冒號（::）操作符

java8 支援了一種新語法"::"，這也是一種 Lambda 寫法，其實也可以理解成 C++ 裡的域解析符。
語法：

個人理解就是取某個域內的某個方法

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

public class lambdaTest {
    public static void main(String[] args) {
        List<String> students = Arrays.asList("張三", "李四", "王五");

        students.forEach(student -> System.out.println(student));

        System.out.println("用\"::\"：");
        students.forEach(System.out::println);
    }

}

輸出結果：

張三
李四
王五
用"::"：
張三
李四
王五