Java-Lambda-Ausdrücke

Lambda-Ausdrücke sind die neue Funktionserweiterung, die in Java8 eingeführt wurde. Es beschreibt grundsätzlich alle Instanzen funktionaler Schnittstellen. Seine Implementierung funktioniert so, dass es nur eine abstrakte Funktion umfasst und die funktionalen Schnittstellen implementiert. Java 8 Lambda Expression kann ein Methodenargument erstellen oder den gesamten Code als Daten betrachten. Es kann eine Funktion implementieren, die keine bestimmte Klasse hat, also eine abstrakte Klasse. Dieser Ausdruck kann an das nächste Objekt übergeben und bei Bedarf ausgeführt werden. Lambda-Ausdrücke können wie Funktionen betrachtet werden und können Parameter wie andere Funktionen akzeptieren.

Syntax:

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

lambda_operator -> body

Parameter von Java-Lambda-Ausdrücken

Die an den lambda_operator übergebenen Parameter lauten wie folgt:

• # Null-Parameter: Dieser Parameter bedeutet, dass er keines der Argumente der Funktion übergeben kann, die wie folgt dargestellt wird:
• (): System.out.println(“Zerolambda-Argument”);
• # Ein Parameter: Dieser Parameter bedeutet, dass er jedes beliebige Argument der Funktion übergeben kann, das wie folgt dargestellt wird:
• (p): System.out.println(“Ein Argument: ” + p);
• # Mehrere Parameter: Wie der Name schon sagt, kann dieser Parameter verwendet werden, um mehr als einen Parameter an den Operator zu übergeben, und er wird wie folgt dargestellt:
• (q1, q2): System.out.println(“Mehrere Argumente: ” + q1 + “, ” + q2);

Warum brauchen wir Java-Lambda-Ausdrücke?

Lambda Expressions wurde mit Java 8 eingeführt und hat die gesamte komplexe Ausführung des Codeblocks, der zur Ausführung weitergegeben werden kann, transformiert und vereinfacht. Es handelt sich um eine sehr häufige Funktion, die viele andere Programmiersprachen verwenden, ebenso wie Java 8; Nach seiner Einführung erfordert die frühere Funktion von Java zunächst die Erstellung eines Objekts und die anschließende Weitergabe des Objekts, beispielsweise zur Erstellung eines strategischen Entwurfsmusters. Aber Lambda-Ausdrücke erwiesen sich als Retter des oben beschriebenen Problems, da sie einen Mehrwert für die Verbesserung der funktionalen Schnittstellenimplementierung darstellen. Die Implementierung wurde dadurch vereinfacht, dass die Funktion lambda_operator auf den Hauptteil des Programms verweist und über null, einen oder mehrere Parameter verfügt, die an die Funktion weitergegeben werden sollen. Es nutzt auch die Funktion, die erstellt wird und keiner definierten Klasse angehört. Es verfügt über eine sehr gute Funktion, die die Funktionalität als Methodenargument der Funktion übernehmen kann, die als Daten als Ganzes betrachtet wird.

Lambda-Ausdrücke in Java 8 sind sehr leistungsstark und sehr überzeugend. Es wird dringend empfohlen, die mit der Funktionsschnittstelle verbundenen Objekte für deren endgültige Ausgabe zu konvertieren.

Wie funktionieren Java-Lambda-Ausdrücke?

In jedem der Ausdrücke gibt es ein verstecktes Arbeitsmuster, sodass er als Lambda-Ausdruck auch über ein Arbeitsmuster verfügt, das wie folgt dargestellt wird:

(int arg_a, String arg_b)
{System.out.println("two arguments"+ arg_a+" and "+arg_b);}

Diese beiden Argumente int arg_a und String arg_b bilden die Liste der Argumente mit null Argumenten, einem Argument oder mehr als zwei Argumenten, d. h. mehreren Argumenten. Diese Argumente werden als Argumentliste mit Hilfe des Pfeil-Tokens an den Körper des Lambda-Ausdrucks übergeben. Dieses Pfeil-Token mit seiner Argumentliste folgt kontinuierlich dem Lambda-Körper. Darüber hinaus nutzt der Lambda-Ausdruck in diesem Format eine funktionale Schnittstelle für seine Implementierung. Wenn es sich jedoch um mehrere Argumentlisten handelt, ist es zwingend erforderlich, die Klammern oder den Codeblock zu schließen, und dann ist der Rückgabetyp der anonymen Funktion derselbe wie der Werttyp, der den Block- oder Void-Code zurückgeben muss, wenn das nicht zurückgegeben wird oder einen Wert dafür besitzt.

Beispiele zur Implementierung von Java-Lambda-Ausdrücken

Unten finden Sie Beispiele für Java-Lambda-Ausdrücke:

Beispiel #1

Dieses Programm veranschaulicht die Schnittstellenausführung ohne die Verwendung von Lambda-Ausdrücken und nicht einmal durch die Erstellung einer abstrakten Klasse zum Drucken der Größe des Rechtecks.

Code:

interface Shapes
{
public void rectangle();
}
public class WithoutLambdaExpression {
public static void main(String[] args) {
int size=15;
Shapes wd=new Shapes(){
public void rectangle()
{
System.out.println("Get the shape" +  size );
}
};
wd.rectangle();
}
}

Ausgabe:

Beispiel #2

Dieses Programm veranschaulicht die Erstellung funktionaler Schnittstellen mithilfe der Lambda-Ausdrücke und stellt so die erforderliche Ausgabe der Formen bereit.

Code:

interface Shapes{
public void Rectangle();
}
public class UsinglmbdaExpression {
public static void main(String[] args) {
int size=20;
Shapes r8=()->
{
System.out.println("Shapes of all sizes "+ size);
};
r8.Rectangle();
}
}

Ausgabe:

Example #3

This program is used to illustrate the Lambda Expression for Java 8 by not passing any parameter implemented just with the function parameter and the associated abstract classes of the implemented functional interface as shown.

Code:

interface SomethingFishy{
public String strange();
}
public class LambdaWithNoArg{
public static void main(String[] args) {
SomethingFishy k=()->{
return "Very Strange View.";
};
System.out.println(k.strange());
}
}

Output:

Example #4

This program illustrates the lambda Expression with the implementation of functional parameters, thereby passing the single parameter from the function of the interface and the lambda expression associated with it.

Code:

interface JuicyFruit{
public String juicy(String name);
}
public class SinglParamLambda
{
public static void main(String[] args)
{
JuicyFruit jf1=(name)->{
return "Kiwi, "+name;
};
System.out.println(jf1.juicy("orange"));
JuicyFruit jf2= name ->{
return "Mango, "+name;
};
System.out.println(jf2.juicy("Pineapple"));
}
}

Output:

Example #5

This program is used to illustrate the Multiple parameter lambda Expression with the functional interface of division and its values to be divided using the class’s div function.

Code:

interface Division{
int div(int p,int q);
}
public class MultiParamLambdaExpression{
public static void main(String[] args) {
Division div1=(p,q)->(p/q);
System.out.println(div1.div(20,40));
Division div2=(int p,int q)->(p/q);
System.out.println(div2.div(400,600));
}
}

Output

Note: Lambda expressions are exclusively used to implement the functional interfaces, and they can contain any type of argument such as zero, two or multiple.

Conclusion

Lambda Expression introduced with Java 8 has simplified the execution of the block of code using the array operator and operator arrow pointing to the lambda body, and then it will be used for implementing the interfaces with the abstract classes associated with each class. Thus, Lambda Expression of Java 8 has really transformed the interface interaction and the implementation of the functions and method easier with the abstract classes.

Das obige ist der detaillierte Inhalt vonJava-Lambda-Ausdrücke. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!