Lambda表示式
Lambda表示式,也可以稱為閉包,是Java 8釋出的最重要新特性
- Lambda允許把函式作為一個方法的引數(函式作為引數傳遞進方法中)
- 使用Lambda表示式可以使程式碼變的更加簡潔緊湊
- 語法:
(parameter) -> expression(parameter) -> { statement; }
- parameter: 引數列表,如果只有一個引數,可以省略括號,如果沒有引數,也需要使用括號;
- expression 或 { statement; } 是Lambda表示式的主體
我們可以舉一個簡單的例子
public class Main {
public static void main(String[] args) {
// Lambda表示式計算兩數之和
MathOperation addition = (a, b) -> a + b;
MathOperation addition2 = (a, b) -> a + b;
MathOperation addition3 = (a, b) -> a*b;
System.out.println(addition.operate(5,3));
System.out.println(addition2.operate(5,3));
System.out.println(addition3.operate(5,3));
}
}
interface MathOperation{
int operate(int a, int b);
}
在上面的例子中，MathOperation 是一個函式式介面，它包含一個抽象方法 operation，Lambda 表示式(a, b) -> a + b 實現了這個抽象方法，表示對兩個引數進行相加操作。
所以,Lambda表示式可以用來實現介面的方法,但是隻可以實現一種方法,一種以上如下圖
MathOperation operation = (a, b) -> {
return a / b;
};
MathOperation operation = (a, b) -> {
return a * b + 10;
};
重要特徵
簡潔性
Lambda 表示式提供了一種更為簡潔的語法，尤其適用於函式式介面。相比於傳統的匿名內部類，Lambda 表示式使得程式碼更為緊湊，減少了樣板程式碼的編寫。
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
public class Main {
public static void main(String[] args) {
//使用匿名內部類
Runnable runnable1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello World!");
}
};
runnable1.run();
// 使用 Lambda 表示式
Runnable runnable2 = () -> System.out.println("Hello World!");
runnable2.run();
}
}
函數語言程式設計支援
Lambda 表示式是函數語言程式設計的一種體現，它允許將函式當作引數傳遞給方法，或者將函式作為返回值，這種支援使得 Java 在函數語言程式設計方面更為靈活，能夠更好地處理集合操作、平行計算等任務
List<String> names = Arrays.asList("Alice","Bob","Cuiweiyang");
names.forEach(name -> System.out.println(name));
實現了一下介面
變數捕獲
Lambda 表示式可以訪問外部作用域的變數，這種特性稱為變數捕獲，Lambda 表示式可以隱式地捕獲 final 或事實上是 final 的區域性變數。
int x = 10;
Function function = a -> System.out.println(a+x);//注意返回值型別
function.oper(5);
interface Function{
void oper(int a);
}
方法引用
Lambda 表示式可以透過方法引用進一步簡化，方法引用允許你直接引用現有類或物件的方法，而不用編寫冗餘的程式碼
// 使用方法引用
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);
可並行性
Lambda 表示式能夠更方便地實現並行操作，透過使用 Stream API 結合 Lambda 表示式，可以更容易地實現平行計算，提高程式效能。
// 使用 Lambda 表示式和 Stream API 進行平行計算
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum =numbers.parallelStream().mapToInt(Integer::intValue).sum();
System.out.println("sum: "+sum);
Lambda 表示式的引入使得 Java 程式設計更加靈活、簡潔，並推動了函數語言程式設計的發展。
Lambda表示式例項
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)
可以分析一下一下程式碼
public class Java8Tester {
public static void main(String []args){
Java8Tester tester = new Java8Tester();
// 型別宣告
MathOperation addition = (int a, int b) -> a + b;
// 不用型別宣告
MathOperation subtraction = (a, b) -> a - b;
// 大括號中的返回語句
MathOperation multiplication = (int a, int b) -> { return a * b; };
// 沒有大括號及返回語句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括號
GreetingService greetService1 = message ->
System.out.println("Hello " + message);
// 用括號
GreetingService greetService2 = (message) ->
System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation){
return mathOperation.operation(a, b);
}
}
使用 Lambda 表示式需要注意以下兩點：
- Lambda 表示式主要用來定義行內執行的方法型別介面（例如，一個簡單方法介面）。在上面例子中，我們使用各種型別的 Lambda 表示式來定義 MathOperation 介面的方法，然後我們定義了 operation 的執行。
- Lambda 表示式免去了使用匿名方法的麻煩，並且給予 Java 簡單但是強大的函式化的程式設計能力。
變數作用域
lambda 表示式只能引用標記了 final 的外層區域性變數，這就是說不能在 lambda 內部修改定義在域外的區域性變數，否則會編譯錯誤。
public class Java8Tester {
final static String salutation = "Hello! ";
public static void main(String args[]){
GreetingService greetService1 = message ->
System.out.println(salutation + message);
greetService1.sayMessage("Runoob");
}
interface GreetingService {
void sayMessage(String message);
}
}
$ javac Java8Tester.java
$ java Java8Tester
Hello! Runoob
我們也可以直接在 lambda 表示式中訪問外層的區域性變數：
public class Java8Tester {
public static void main(String args[]) {
final int num = 1;
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2); // 輸出結果為 3
}
public interface Converter<T1, T2> {
void convert(int i);
}
}
lambda 表示式的區域性變數可以不用宣告為 final，但是必須不可被後面的程式碼修改（即隱性的具有 final 的語義)
int num = 1;
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;
//報錯資訊：Local variable num defined in an enclosing scope must be final or effectively final
在 Lambda 表示式當中不允許宣告一個與區域性變數同名的引數或者區域性變數。
String first = "";
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length()); //編譯會出錯