Java Lambda-Ausdrücke

Java 8 Neue Funktionen

Lambda-Ausdrücke, auch bekannt als Closures, treiben Java 8 Die wichtigste neue Funktion der Veröffentlichung.

Lambda ermöglicht es, Funktionen als Parameter einer Methode zu übergeben (Funktionen werden in Methoden übergeben).

Mit Lambda-Ausdrücken kann der Code einfacher und komprimierter werden.

Syntax

Die Syntax der Lambda-Ausdrücke ist wie folgt:

(Parameter)　->　Ausdruck
oder
(Parameter)　-{　statements;　}

Hier sind die wichtigen Merkmale der Lambda-Ausdrücke:

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

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)

In Java8Geben Sie den folgenden Code in die Datei Tester.java ein:

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("w3codebox");
　　　　　　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);
　　　}
}

Führen Sie den obigen Skript aus, die Ausgabeergebnisse sind:

$　javac　Java8Tester.java　
$　java　Java8Tester
10　+　5　=　15
10　-　5　=　5
10　x　5　=　50
10　/　5　=　2
Hello　w3codebox
Hello　Google

Bei der Verwendung von Lambda-Ausdrücken sollten folgende Punkte beachtet werden:

• Lambda-Ausdrücke werden hauptsächlich verwendet, um inline Methodentypen-Interfaces zu definieren, z.B. ein einfaches Methoden-Interface. In diesem Beispiel verwenden wir verschiedene Arten von Lambda-Ausdrücken, um die Methoden des Interfaces MathOperation zu definieren. Dann definieren wir die Ausführung von sayMessage.

• Lambda-Ausdrücke vermeiden die Mühe, anonyme Methoden zu verwenden, und verleihen Java eine einfache aber mächtige funktionalen Programmierfähigkeit.

Bereich der Variablen

Lambda-Ausdrücke können nur auf lokale Variablen zugreifen, die als final markiert sind, das bedeutet, dass lokale Variablen, die in einem anderen Bereich definiert sind, nicht im Lambda geändert werden dürfen, sonst wird ein Kompilationsfehler aufgetreten.

In Java8Geben Sie den folgenden Code in die Datei Tester.java ein:

public class Java8Tester {
　
　　　final static String salutation = "Hello!　";
　　　
　　　public static void main(String args[]){
　　　　　　GreetingService　greetService1　=　message　->　
　　　　　　System.out.println(salutation　+　message);
　　　　　　greetService1.sayMessage("w3codebox");
　　　}
　　　　
　　　interface GreetingService　{
　　　　　　void sayMessage(String message);
　　　}
}

Führen Sie den obigen Skript aus, die Ausgabeergebnisse sind:

$　javac　Java8Tester.java　
$　java　Java8Tester
Hello!　w3codebox

Wir können auch direkt auf die äußeren lokalen Variablen im Lambda-Ausdruck zugreifen:

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);　　//　Die Ausgabeergebnisse sind　3
　　　　}
　
　　　　public interface Converter<T1, T2> {
　　　　　　　　void convert(int i);
　　　　}
}

Die lokalen Variablen in Lambda-Ausdrücken müssen nicht als final deklariert werden, aber sie dürfen nicht von nachfolgendem Code geändert werden (d.h. sie haben implizit die Semantik von final).

int　num　=　1;　　
Converter<Integer,　String>　s　=　(param)　->　System.out.println(String.valueOf(param　+　num));
s.convert(2);
num　=　5;　　
//Fehlermeldung: Der lokale Variable "num" in einem umgebenden Bereich muss final oder effectively final sein　
　final

In Lambda-Ausdrücken ist es nicht erlaubt, einen Parameter oder eine lokale Variable mit demselben Namen zu deklarieren.

String　first　=　"";　　
Comparator<String>　comparator　=　(first,　second)　->　Integer.compare(first.length(),　second.length());　　//Der Compiler wird einen Fehler ausgeben

Java 8 Neue Funktionen