Java編程中使用lambda表達式的奇技淫巧
為什么使用Lambda表達式
先看幾個例子：
第一個例子，在一個獨立的線程中執(zhí)行某項任務，我們通常這么實現(xiàn)：
class Worker implements Runnable {
public void run() {
for (int i = 0; i < 100; i++)
doWork();
}
...
}
Worker w = new Worker();
new Thread(w).start();
第二個例子，自定義字符串比較的方法（通過字符串長度），一般這么做：
class LengthComparator implements Comparator<String> {
public int compare(String first, String second) {
return Integer.compare(first.length(), second.length());
}
}
Arrays.sort(strings, new LengthComparator());
第三個例子，在JavaFX中，給一個button添加一個callback：
button.setOnAction(new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
System.out.println("Thanks for clicking!");
}
});
這些例子有一個共同點，就是：先定義一段代碼塊，傳給某個對象或方法，然后被執(zhí)行。在Lambda表
達式之前，Java是不允許直接傳遞代碼塊的，因為Java是面向?qū)ο蟮?，因此必須傳遞一個對象，將要
執(zhí)行的代碼塊封裝到對象里。
Lambda表達式的語法
將上面第二個例子中的LengthComparator，用Lambda表達式表示為：
(String first, String second) -> Integer.compare(first.length(), second.length());
->前為參數(shù)列表，其后為表達式語句體；
如果表達式語句體不止一行，則將語句體寫在{}中，與普通的函數(shù)一樣：
(String first, String second) -> {
if (first.length() > second.length()) {
return 1;
} else if (first.length() == second.length()) {
return 0;
} else {
return -1;
}
};
如果沒有參數(shù)，()還是需要帶上，比如上面的第一個例子，可以表示為：
() -> {
for (int i = 0; i < 1000; i ++) {
doWork();
}
}
如果參數(shù)的類型可以從上下文自動推斷，則可以省略：
Comparator<String> comp = (first, second) // Same as (String first, String second) -> Integer.compare(first.length(), second.length());
如果參數(shù)只有一個，且類型可以自動推斷，則小括號()也可以省略：
// Instead of (event) -> or (ActionEvent event) ->
eventHandler<ActionEvent> listener =
event -> System.out.println("Thanks for clicking!");
lambda表達式的返回值的類型是自動推斷的，因此不需要指明；在lambda表達式，某些條件分支中有
返回值，而其它分支沒有返回值，是不允許的，如：
(x) -> {
if (x >= 0) {
return 1;
}
}
另外，expression lambda和statement lambda的區(qū)別是，expression lambda不需要
寫return關鍵字，Java runtime會將表達式的結(jié)果作為返回值返回，而statement lambda是
寫在{}中的表達式，需要使用return關鍵字，比如：
// expression lambda
Comparator<String> comp1 =
(first, second) -> Integer.compare(first.length(), second.length());
// statement lambda
Comparator<String> comp2 = (first, second) ->
{ return Integer.compare(first.length(), second.length());};
Functional Interface
如果一個接口（interface）僅有一個抽象方法（abstract method），就稱為
Functional Interface，比如Runnable、Comparator等。
在任何一個需要Functional Interface對象的地方，都可以使用lambda表達式：
Arrays.sort(words, (first, second) -> Integer.compare(first.length(), second.length()));
這里，sort()的第二個參數(shù)需要的是一個Comparator對象，而Comparator是
Functional Interface，因此可以直接傳入lambda表達式，在調(diào)用該對象的compare()方法
時，就是執(zhí)行該lambda表達式中的語句體；
如果lambda表達式的語句體會拋出異常，則對應的Functional Interface中的抽象方法必須拋
出了該異常，否則就需要在lambda表達式中顯式捕獲異常：
Runnable r = () -> {
System.out.println("------");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// catch exception
}
};
Callable<String> c = () -> {
System.out.println("--------");
Thread.sleep(10);
return "";
};
Method Reference
如果將lambda表達式的參數(shù)作為參數(shù)傳遞給一個方法，他們的執(zhí)行效果是相同的，則該lambda表達式
可以使用Method Reference表達，以下兩種方式是等價的：
(x) -> System.out.println(x) System.out::println
其中System.out::println被稱為Method Reference。
Method Reference主要有三種形式：
- object::instanceMethod
- Class::staticMethod
- Class::instanceMethod
對于前兩種方式，對應的lambda表達式的參數(shù)和method的參數(shù)是一致的，比如：
System.out::println (x) -> System.out.println(x) Math::pow (x, y) -> Math.pow(x, y)
對于第三種方式，對應的lambda表達式的語句體中，第一個參數(shù)作為對象，調(diào)用method，將其它參數(shù)
作為method的參數(shù)，比如：
String::compareToIgnoreCase (s1, s2) -> s1.compareToIgnoreCase(s2) 1.5 Constructor Reference
Constructor Reference與Method Reference類似，只不過是特殊的method：new，具體調(diào)用的是哪個構造函數(shù)，由上下文環(huán)境決定，比如：
List<String> labels = ...; Stream<Button> stream = labels.stream().map(Button::new);
Button::new等價于(x) -> Button(x)，所以調(diào)用的構造函數(shù)是：Button(x);
除了創(chuàng)建單個對象，也可以創(chuàng)建對象數(shù)組，如下面兩種方式等價：
int[]::new (x) -> new int[x]
變量作用域
lambd表達式會捕獲當前作用域下可用的變量，比如：
public void repeatMessage(String text, int count) {
Runnable r = () -> {
for (int i = 0; i < count; i ++) {
System.out.println(text);
Thread.yield();
}
};
new Thread(r).start();
}
但是這些變量必須是不可變的，為什么呢？看下面這個例子：
int matches = 0;
for (Path p : files)
new Thread(() -> { if (p has some property) matches++; }).start();
// Illegal to mutate matches
因為可變的變量在lambda表達式中不是線程安全的，這和內(nèi)部類的要求是一致的，內(nèi)部類中只能引用
外部定義的final變量；
lambda表達式的作用域與嵌套代碼塊的作用域是一樣的，所以在lambd表達式中的參數(shù)名或變量名不
能與局部變量沖突，如：
Path first = Paths.get("/usr/bin");
Comparator<String> comp = (first, second) -> Integer.compare(first.length(),
second.length()); // Error: Variable first already defined
如果在lambda表達式中引用this變量，則引用的是創(chuàng)建該lambda表達式的方法的this變量，如：
public class Application() {
public void doWork() {
Runnable runner = () -> {
...;
System.out.println(this.toString());
...
};
}
}
所以這里的this.toString()調(diào)用的是Application對象的toString()，而不是Runnable
對象的。
Default Method
接口中只能有抽象方法，如果在已有的接口中新增一個方法，則該接口所有的實現(xiàn)類都需要實現(xiàn)該方法。
Java 8中引入了Default Method的概念，在接口中新增一個default方法，不會破壞已有的接
口規(guī)則，接口的實現(xiàn)類可以選擇重寫或直接繼承該default方法，比如：
interface Person {
long getId();
default String getName() { return "John Q. Public"; }
}
Java是允許多繼承的，如果一個類的父類中定義的方法和接口中定義的default方法完全相同，或者
一個類的兩個接口中定義了完全相同的方法， 則如何處理這種沖突呢？處理規(guī)則如下：
如果是父類和接口的方法沖突：以父類中的方法為準，接口中的方法被忽略；
如果兩個接口中的default方法沖突，則需要重寫該方法解決沖突；
Static Method
Java 8之前，接口中只能定義static變量，Java 8開始，接口中可以添加static方法，比如
Comparator接口新增了一系列comparingXXX的static方法，比如：
public static <T> Comparator<T> comparingInt(ToIntFunction<? super T>
keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1),
keyExtractor.applyAsInt(c2));
}
使用這個static方法，以下兩種方式也是等價的：
1、
Arrays.sort(cities, (first, second) -> Integer.compare(first.length(), second.length()));
2、
Arrays.sort(cities, Comparator.comparingInt(String::length));
所以，以后我們在設計自己的接口時，不需要再定義單獨的工具類（如Collections/Collection)，
在接口中使用static方法就行了。
匿名內(nèi)部類
在 Java 世界中，匿名內(nèi)部類 可以實現(xiàn)在應用程序中可能只執(zhí)行一次的操作。例如，在 Android 應用程序中，一個按鈕的點擊事件處理。你不需要為了處理一個點擊事件單獨編寫一個獨立的類，可以用匿名內(nèi)部類完成該操作：
Button button = (Button) findViewById(R.id.button1);
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(MainActivity.this, "Button Clicked", Toast.LENGTH_SHORT).show();
}
});
Lambda 示例
public void runnableTest() {
System.out.println("=== RunnableTest ===");
// 一個匿名的 Runnable
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world one!");
}
};
// Lambda Runnable
Runnable r2 = () -> System.out.println("Hello world two!");
// 執(zhí)行兩個 run 函數(shù)
r1.run();
r2.run();
}
public void runnableTest() {
System.out.println("=== RunnableTest ===");
// 一個匿名的 Runnable
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world one!");
}
};
// Lambda Runnable
Runnable r2 = () -> System.out.println("Hello world two!");
// 執(zhí)行兩個 run 函數(shù)
r1.run();
r2.run();
}
2.Comparator Lambda
public class Person {
private String givenName;
private String surName;
private int age;
private Gender gender;
private String eMail;
private String phone;
private String address;
}
public class Person {
private String givenName;
private String surName;
private int age;
private Gender gender;
private String eMail;
private String phone;
private String address;
}
public class ComparatorTest {
public static void main(String[] args) {
List<Person> personList = Person.createShortList();
// 使用內(nèi)部類實現(xiàn)排序
Collections.sort(personList, new Comparator<Person>() {
public int compare(Person p1, Person p2) {
return p1.getSurName().compareTo(p2.getSurName());
}
});
System.out.println("=== Sorted Asc SurName ===");
for (Person p : personList) {
p.printName();
}
// 使用 Lambda 表達式實現(xiàn)
// 升序排列
System.out.println("=== Sorted Asc SurName ===");
Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));
for (Person p : personList) {
p.printName();
}
// 降序排列
System.out.println("=== Sorted Desc SurName ===");
Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));
for (Person p : personList) {
p.printName();
}
}
}
public class ComparatorTest {
public static void main(String[] args) {
List<Person> personList = Person.createShortList();
// 使用內(nèi)部類實現(xiàn)排序
Collections.sort(personList, new Comparator<Person>() {
public int compare(Person p1, Person p2) {
return p1.getSurName().compareTo(p2.getSurName());
}
});
System.out.println("=== Sorted Asc SurName ===");
for (Person p : personList) {
p.printName();
}
// 使用 Lambda 表達式實現(xiàn)
// 升序排列
System.out.println("=== Sorted Asc SurName ===");
Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));
for (Person p : personList) {
p.printName();
}
// 降序排列
System.out.println("=== Sorted Desc SurName ===");
Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));
for (Person p : personList) {
p.printName();
}
}
}
相關文章
大家好，本篇文章主要講的是JDBC獲取數(shù)據(jù)庫連接由淺入深，感興趣的同學趕快來看一看吧，對你有幫助的話記得收藏一下2022-02-02
這篇文章主要為大家詳細介紹了Servlet簡單實現(xiàn)登錄功能，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-03-03
spring mvc+localResizeIMG實現(xiàn)HTML5端圖片壓縮上傳
這篇文章主要為大家詳細介紹了使用spring mvc+localResizeIMG實現(xiàn)HTML5端圖片壓縮上傳，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-04-04
我們給大家?guī)硪黄P于java初學者如何讓編程學習起來更簡單的基礎性文章，有需要的朋友們可以學習下。2020-11-11
這篇文章主要為大家介紹了Netty開發(fā)及粘包實戰(zhàn)解決分析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2024-02-02
官方詳解HDFS?Balancer工具主要調(diào)優(yōu)參數(shù)
這篇文章主要為大家介紹了HDFS?Balancer工具主要調(diào)優(yōu)參數(shù)的?官方詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-03-03
這篇文章主要介紹了IntelliJ IDEA 2020安裝使用教程,本文通過圖文實例相結(jié)合給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-07-07
SpringMVC 數(shù)據(jù)校驗方法(必看篇)
下面小編就為大家?guī)硪黄猄pringMVC 數(shù)據(jù)校驗方法(必看篇)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-06-06
這篇文章主要介紹了 java 解壓與壓縮文件夾的實例詳解的相關資料,希望通過本文能幫助到大家，讓大家實現(xiàn)這樣的功能，掌握這樣的方法，需要的朋友可以參考下2017-10-10
在本篇文章里小編給大家整理的是一篇關于java jvm兩種存儲區(qū)的類型知識點講解內(nèi)容，有興趣的朋友們可以學習下。2021-03-03