Lambda表示式是Java SE 8中一個重要的新特性。lambda表示式允許你通過表示式來代替功能介面。 lambda表示式就和方法一樣,它提供了一個正常的引數列表和一個使用這些引數的主體(body,可以是一個表示式或一個程式碼塊)。
Lambda表示式還增強了集合庫。 Java SE 8添加了2個對集合資料進行批量操作的包: java.util.function 包以及java.util.stream 包。 流(stream)就如同迭代器(iterator),但附加了許多額外的功能。 總的來說,lambda表示式和 stream 是自Java語言新增泛型(Generics)和註解(annotation)以來最大的變化。 在本文中,我們將從簡單到複雜的示例中見認識lambda表示式和stream的強悍。

Lambda 表示式是 JDK8 的一個新特性，可以取代大部分的匿名內部類，寫出更優雅的 Java 程式碼，尤其在集合的遍歷和其他集合操作中，可以極大地優化程式碼結構。

JDK 也提供了大量的內建函式式介面供我們使用，使得 Lambda 表示式的運用更加方便、高效

2 Lambda表示式的組成
java 8 中Lambda 表示式由三個部分組成：第一部分為一個括號內用逗號分隔的形式引數，引數是函式式接口裡面方法的引數；第二部分為一個箭頭符號：->；第三部分為方法體，可以是表示式和程式碼塊。語法如下

1、方法體為表示式，該表示式的值作為返回值返回

// 求和
(parameters)  -> expression
(
 
int a, int b) -> return a+b;

2、方法體為程式碼塊，必須用 {} 來包裹起來，且需要一個 return 返回值，但若函式式接口裡面方法返回值是 void，則無需返回值。

(parameters) -> { statements; }
(int a) -> {System.out.println("a = " + a);} //列印，無返回值
(int a) -> {return a * a;} //求平方

2.1 Lambda表示式的函式式介面 

上面提到了函式式介面，那這是一個什麼樣的概念呢？

函式式介面(Functional Interface)是Java 8對一類特殊型別的介面的稱呼。這類介面只定義了唯一的抽象方法的介面（除了隱含的Object物件的公共方法，因此最開始也就做SAM型別的介面（Single Abstract Method）。定義函式式介面的原因是在Java Lambda的實現中,開發組不想再為Lambda表示式單獨定義一種特殊的Structural函式型別,稱之為箭頭型別（arrow type,依然想採用Java既有的型別(class, interface, method等).原因是增加一個結構化的函式型別會增加函式型別的複雜性，破壞既有的Java型別，並對成千上萬的Java類庫造成嚴重的影響。權衡利弊,因此最終還是利用SAM 介面作為 Lambda表示式的目標型別.另外對於函式式介面來說@FunctionalInterface並不是必須的,只要介面中只定義了唯一的抽象方法的介面那它就是一個實質上的函式式介面,就可以用來實現Lambda表示式。

在java 8中已經為我們定義了很多常用的函式式介面它們都放在java.util.function包下面,一般有以下常用的四大核心介面：

函式式介面                               引數型別    返回型別         用途
Consumer<T>(消費型介面)         T                void         對型別為T的物件應用操作。void accept(T t)
Supplier<T>(供給型介面)            無                 T           返回型別為T的物件。 T get();
Function<T, R>(函式型介面)        T                 R            對型別為T的物件應用操作並返回R型別的物件。R apply(T t);
Predicate<T>(斷言型介面)           T             boolean     確定型別為T的物件是否滿足約束。boolean test(T t);
函式式介面

Java 把 Lambda表示式當作是一個介面型別的例項。它把這種形式被稱之為函式式介面。一個函式式介面就是一個只有單一方法的介面，Java把這種方法稱之為“函式式方法”，但更常用的名字為單一抽象方法（single abstract method" 或 SAM）。例如JDK中存在的介面例如Runnable和Callable。

@FunctionalInterface

Oracle 引入了一個新的註解為@FunctionalInterface， 用來標識一個介面為函式式介面。它基本上是用來傳達這一用途，除此而外，編輯器還會做一些額外的檢查。
比如，下面的介面：

public interface FunctionalInterfaceExample {
// compiles ok
}

如果加上@FunctionalInterface註解，則會編譯錯誤：

@FunctionalInterface // <- error here
public interface FunctionalInterfaceExample {
// doesn't compile
}

編譯器就會報錯，錯誤的詳細資訊為“Invalid '@FunctionalInterface' annotation; FunctionalInterfaceExample is not a functional interface”。意思是沒有定義一個單一的抽象方法。

而如果我們定義了兩個抽象方法會如何？

@FunctionalInterface
public interface FunctionalInterfaceExample {
void apply();
void illegal(); // <- error here
}

編譯器再次報錯，提示為"multiple, non-overriding abstract methods were found"。所以，一旦使用了此註解，則在接口裡只能定義一個抽象方法。

而現在有這樣一種情況，如歌一個介面繼承了另一個介面，會怎麼辦？我們建立一個新的函式式介面為A，定義了另一個介面B，B繼承A，則B仍然是一個函式式介面，它繼承了A的apply方法。

@FunctionalInterface
interface A {
abstract void apply();
}

interface B extends A {

如果你想看起來更加清晰，可以複寫父類的方法：

@FunctionalInterface
interface A {
abstract void apply();
}

interface B extends A {
@Override
abstract void apply();
}

我們可以用下面的程式碼來測試一下上面的兩個介面是否為函式式介面：

@FunctionalInterface
public interface A {
void apply();
}

public interface B extends A {
@Override
void apply();
}

public static void main(String... args) {
A a = () -> System.out.println("A");
B b = () -> System.out.println("B");
a.apply(); // 列印：A
b.apply(); // 列印：B
}

如果B介面繼承了A介面，那麼在B介面中就不能定義新的方法了，否則編譯器會報錯。

除了這些，在Java 8 中介面有了一些新的改進：

可以新增預設方法；
可以包含靜態介面方法；
在java.util.function包中增加了一些新的介面，例如，Function 和 Predicate。
2.2 對介面的要求
雖然使用 Lambda 表示式可以對某些介面進行簡單的實現，但並不是所有的介面都可以使用 Lambda 表示式來實現。Lambda 規定介面中只能有一個需要被實現的方法，不是規定介面中只能有一個方法

jdk 8 中有另一個新特性：default， 被 default 修飾的方法會有預設實現，不是必須被實現的方法，所以不影響 Lambda 表示式的使用。

@FunctionalInterface#
修飾函式式介面的，要求介面中的抽象方法只有一個。 這個註解往往會和 lambda 表示式一起出現

3 Lambda使用
3.1 基本使用
基本語法:
(parameters) -> expression
或
(parameters) ->{ statements; }

下面是Java lambda表示式的簡單例子:

// 1. 不需要引數,返回值為 5 
() -> 5 

// 2. 接收一個引數(數字型別),返回其2倍的值 
x -> 2 * x 

// 3. 接受2個引數(數字),並返回他們的差值 
(x, y) -> x – y 

// 4. 接收2個int型整數,返回他們的和 
(int x, int y) -> x + y 

// 5. 接受一個 string 物件,並在控制檯列印,不返回任何值(看起來像是返回void) 
(String s) -> System.out.print(s)

基本的Lambda例子

現在,我們已經知道什麼是lambda表示式,讓我們先從一些基本的例子開始。 在本節中,我們將看到lambda表示式如何影響我們編碼的方式。 假設有一個玩家List ,程式設計師可以使用 for 語句 ("for 迴圈")來遍歷,在Java SE 8中可以轉換為另一種形式:

String[] atp = {"Rafael Nadal", "Novak Djokovic", 
"Stanislas Wawrinka", 
"David Ferrer","Roger Federer", 
"Andy Murray","Tomas Berdych", 
"Juan Martin Del Potro"}; 
List<String> players = Arrays.asList(atp); 

// 以前的迴圈方式 
for (String player : players) { 
System.out.print(player + "; "); 
} 

// 使用 lambda 表示式以及函式操作(functional operation) 
players.forEach((player) -> System.out.print(player + "; ")); 

// 在 Java 8 中使用雙冒號操作符(double colon operator) 
players.forEach(System.out::println);

正如您看到的,lambda表示式可以將我們的程式碼縮減到一行。 另一個例子是在圖形使用者介面程式中,匿名類可以使用lambda表示式來代替。 同樣,在實現Runnable介面時也可以這樣使用:

// 使用匿名內部類 
btn.setOnAction(new EventHandler<ActionEvent>() { 
@Override 
public void handle(ActionEvent event) { 
System.out.println("Hello World!"); 
} 
}); 

// 或者使用 lambda expression 
btn.setOnAction(event -> System.out.println("Hello World!"));

下面是使用lambdas 來實現 Runnable介面 的示例:

// 1.1使用匿名內部類 
new Thread(new Runnable() { 
@Override 
public void run() { 
System.out.println("Hello world !"); 
} 
}).start(); 

// 1.2使用 lambda expression 
new Thread(() -> System.out.println("Hello world !")).start(); 

// 2.1使用匿名內部類 
Runnable race1 = new Runnable() { 
@Override 
public void run() { 
System.out.println("Hello world !"); 
} 
}; 

// 2.2使用 lambda expression 
Runnable race2 = () -> System.out.println("Hello world !"); 

// 直接呼叫 run 方法(沒開新執行緒哦!) 
race1.run(); 
race2.run();

Runnable 的 lambda表示式,使用塊格式,將五行程式碼轉換成單行語句。 接下來,在下一節中我們將使用lambdas對集合進行排序。

使用Lambdas排序集合
在Java中,Comparator 類被用來排序集合。 在下面的例子中,我們將根據球員的 name, surname, name 長度 以及最後一個字母。 和前面的示例一樣,先使用匿名內部類來排序,然後再使用lambda表示式精簡我們的程式碼。
在第一個例子中,我們將根據name來排序list。 使用舊的方式,程式碼如下所示:

String[] players = {"Rafael Nadal", "Novak Djokovic", 
"Stanislas Wawrinka", "David Ferrer", 
"Roger Federer", "Andy Murray", 
"Tomas Berdych", "Juan Martin Del Potro", 
"Richard Gasquet", "John Isner"}; 

// 1.1 使用匿名內部類根據 name 排序 players 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.compareTo(s2)); 
} 
});
使用lambdas,可以通過下面的程式碼實現同樣的功能:

// 1.2 使用 lambda expression 排序 players 
Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2)); 
Arrays.sort(players, sortByName); 

// 1.3 也可以採用如下形式: 
Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2))); 
其他的排序如下所示。 和上面的示例一樣,程式碼分別通過匿名內部類和一些lambda表示式來實現Comparator :

// 1.1 使用匿名內部類根據 surname 排序 players 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" ")))); 
} 
}); 

// 1.2 使用 lambda expression 排序,根據 surname 
Comparator<String> sortBySurname = (String s1, String s2) -> 
( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) ); 
Arrays.sort(players, sortBySurname); 

// 1.3 或者這樣,懷疑原作者是不是想錯了,括號好多... 
Arrays.sort(players, (String s1, String s2) -> 
( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) ) 
); 

// 2.1 使用匿名內部類根據 name lenght 排序 players 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.length() - s2.length()); 
} 
}); 

// 2.2 使用 lambda expression 排序,根據 name lenght 
Comparator<String> sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length()); 
Arrays.sort(players, sortByNameLenght); 

// 2.3 or this 
Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length())); 

// 3.1 使用匿名內部類排序 players, 根據最後一個字母 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); 
} 
}); 

// 3.2 使用 lambda expression 排序,根據最後一個字母 
Comparator<String> sortByLastLetter = 
(String s1, String s2) -> 
(s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); 
Arrays.sort(players, sortByLastLetter); 

// 3.3 or this 
Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));

就是這樣,簡潔又直觀。 在下一節中我們將探索更多lambdas的能力,並將其與 stream 結合起來使用。

3.2 使用Lambdas和Streams
Stream是對集合的包裝,通常和lambda一起使用。 使用lambdas可以支援許多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。 同樣,Stream使用懶運算,他們並不會真正地讀取所有資料,遇到像getFirst() 這樣的方法就會結束鏈式語法。 在接下來的例子中,我們將探索lambdas和streams 能做什麼。 我們建立了一個Person類並使用這個類來新增一些資料到list中,將用於進一步流操作。 Person 只是一個簡單的POJO類:

public class Person { 

private String firstName, lastName, job, gender; 
private int salary, age; 

public Person(String firstName, String lastName, String job, 
String gender, int age, int salary) { 
this.firstName = firstName; 
this.lastName = lastName; 
this.gender = gender; 
this.age = age; 
this.job = job; 
this.salary = salary; 
} 
// Getter and Setter 
// . . . . . 
}

接下來,我們將建立兩個list,都用來存放Person物件:

List<Person> javaProgrammers = new ArrayList<Person>() { 
{ 
add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000)); 
add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500)); 
add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800)); 
add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600)); 
add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200)); 
add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900)); 
add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300)); 
add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700)); 
add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000)); 
add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300)); 
} 
}; 

List<Person> phpProgrammers = new ArrayList<Person>() { 
{ 
add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550)); 
add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200)); 
add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600)); 
add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000)); 
add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100)); 
add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300)); 
add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100)); 
add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000)); 
add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600)); 
add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800)); 
} 
};

現在我們使用forEach方法來迭代輸出上述列表:

System.out.println("所有程式設計師的姓名:"); 
javaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 
phpProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

我們同樣使用forEach方法,增加程式設計師的工資5%:

System.out.println("給程式設計師加薪 5% :"); 
Consumer<Person> giveRaise = e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary()); 

javaProgrammers.forEach(giveRaise); 
phpProgrammers.forEach(giveRaise); 

另一個有用的方法是過濾器filter() ,讓我們顯示月薪超過1400美元的PHP程式設計師:

System.out.println("下面是月薪超過 $1,400 的PHP程式設計師:") 
phpProgrammers.stream() 
.filter((p) -> (p.getSalary() > 1400)) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 
我們也可以定義過濾器,然後重用它們來執行其他操作:

// 定義 filters 
Predicate<Person> ageFilter = (p) -> (p.getAge() > 25); 
Predicate<Person> salaryFilter = (p) -> (p.getSalary() > 1400); 
Predicate<Person> genderFilter = (p) -> ("female".equals(p.getGender())); 

System.out.println("下面是年齡大於 24歲且月薪在$1,400以上的女PHP程式設計師:"); 
phpProgrammers.stream() 
.filter(ageFilter) 
.filter(salaryFilter) 
.filter(genderFilter) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

// 重用filters 
System.out.println("年齡大於 24歲的女性 Java programmers:"); 
javaProgrammers.stream() 
.filter(ageFilter) 
.filter(genderFilter) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
System.out.println("最前面的3個 Java programmers:"); 
javaProgrammers.stream() 
.limit(3) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 


System.out.println("最前面的3個女性 Java programmers:"); 
javaProgrammers.stream() 
.filter(genderFilter) 
.limit(3) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

排序呢? 我們在stream中能處理嗎? 答案是肯定的。 在下面的例子中,我們將根據名字和薪水排序Java程式設計師,放到一個list中,然後顯示列表:

System.out.println("根據 name 排序,並顯示前5個 Java programmers:"); 
List<Person> sortedJavaProgrammers = javaProgrammers 
.stream() 
.sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName()))) 
.limit(5) 
.collect(toList()); 

sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName())); 

System.out.println("根據 salary 排序 Java programmers:"); 
sortedJavaProgrammers = javaProgrammers 
.stream() 
.sorted( (p, p2) -> (p.getSalary() - p2.getSalary()) ) 
.collect( toList() ); 

sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));

如果我們只對最低和最高的薪水感興趣,比排序後選擇第一個/最後一個 更快的是min和max方法:

System.out.println("工資最低的 Java programmer:"); 
Person pers = javaProgrammers 
.stream() 
.min((p1, p2) -> (p1.getSalary() - p2.getSalary())) 
.get() 

System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary()) 

System.out.println("工資最高的 Java programmer:"); 
Person person = javaProgrammers 
.stream() 
.max((p, p2) -> (p.getSalary() - p2.getSalary())) 
.get() 

System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary())

上面的例子中我們已經看到 collect 方法是如何工作的。 結合 map 方法,我們可以使用 collect 方法來將我們的結果集放到一個字串,一個 Set 或一個TreeSet中:

System.out.println("將 PHP programmers 的 first name 拼接成字串:"); 
String phpDevelopers = phpProgrammers 
.stream() 
.map(Person::getFirstName) 
.collect(joining(" ; ")); // 在進一步的操作中可以作為標記(token) 

System.out.println("將 Java programmers 的 first name 存放到 Set:"); 
Set<String> javaDevFirstName = javaProgrammers 
.stream() 
.map(Person::getFirstName) 
.collect(toSet()); 

System.out.println("將 Java programmers 的 first name 存放到 TreeSet:"); 
TreeSet<String> javaDevLastName = javaProgrammers 
.stream() 
.map(Person::getLastName) 
.collect(toCollection(TreeSet::new));
Streams 還可以是並行的(parallel)。 示例如下:

System.out.println("計算付給 Java programmers 的所有money:"); 
int totalSalary = javaProgrammers 
.parallelStream() 
.mapToInt(p -> p.getSalary()) 
.sum(); 

我們可以使用summaryStatistics方法獲得stream 中元素的各種彙總資料。 接下來,我們可以訪問這些方法,比如getMax, getMin, getSum或getAverage:

//計算 count, min, max, sum, and average for numbers 
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 
IntSummaryStatistics stats = numbers 
.stream() 
.mapToInt((x) -> x) 
.summaryStatistics(); 

System.out.println("List中最大的數字 : " + stats.getMax()); 
System.out.println("List中最小的數字 : " + stats.getMin()); 
System.out.println("所有數字的總和 : " + stats.getSum()); 
System.out.println("所有數字的平均值 : " + stats.getAverage());

4 Lambda 表示式好處

1.替代匿名內部類

毫無疑問，lambda表示式用得最多的場合就是替代匿名內部類，而實現Runnable介面是匿名內部類的經典例子。lambda表示式的功能相當強大，用()->就可以代替整個匿名內部類！請看程式碼：

這就是lambda表示式的好處之一，用極少的程式碼完成了之前一個類做的事情！

lambda表示式的最大好處之一就是減少了程式碼量。我們知道，lambda表示式只能與功能介面一起使用。例如，Runnable 是一個介面，因此我們可以輕鬆地應用lambda表示式。

2.使用lambda表示式對集合進行迭代

通過將行為作為方法中的引數傳遞來支援順序和並行執行-通過在Java 8中使用Stream API，將函式傳遞給collection方法。現在，集合的職責是以順序或並行的方式處理元素。

3.Stream操作

我們來認識一下Lambda的好兄弟Stream，這裡的Stream並不是輸入流和輸出流（IO），而它也是jdk8後的新特性，是有關演算法和計算的，它更像一個高階版本的 Iterator。原始版本的 Iterator，使用者只能顯式地一個一個遍歷元素並對其執行某些操作；高階版本的 Stream，使用者只要給出需要對其包含的元素執行什麼操作，比如 “過濾掉長度大於 10 的字串”、“獲取每個字串的首字母”等，Stream 會隱式地在內部進行遍歷，做出相應的資料轉換。
Stream就如同一個迭代器（Iterator），單向，不可往復，資料只能遍歷一次，遍歷過一次後即用盡了，就好比流水從面前流過，一去不復返。
簡單來講，Stream就是JAVA8提供給我們的對於元素集合統一、快速、並行操作的一種方式。它能充分運用多核的優勢，以及配合lambda表示式、鏈式結構對集合等進行許多有用的操作。
1）filter（過濾）

2）Map（對映）

3）limit(截斷)

對一個Stream進行截斷操作，獲取其前N個元素，如果原Stream中包含的元素個數小於N，那就獲取其所有的元素
4）distinct(去重)

對於Stream中包含的元素進行去重操作（去重邏輯依賴元素的equals方法），新生成的Stream中沒有重複的元素
5）count（統計）

count方法是一個流的終點方法，可使流的結果最終統計，返回int，比如我們計算一下滿足18歲的總人數

6）Collect（收集流的結果）

collect方法也是一個流的終點方法，可收集最終的結果

4.與函式式介面Predicate配合

除了在語言層面支援函數語言程式設計風格，Java 8也添加了一個包，叫做 java.util.function。它包含了很多類，用來支援Java的函數語言程式設計。其中一個便是Predicate，使用 java.util.function.Predicate 函式式介面以及lambda表示式，可以向API方法新增邏輯，用更少的程式碼支援更多的動態行為。Predicate介面非常適用於做過濾。

————————————————
版權宣告：本文為CSDN博主「mocas_wang」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處連結及本宣告。
原文連結：https://blog.csdn.net/mocas_wang/article/details/118802896