Lambda-Ausdrücke in Aktion

Einige einfache Beispiele, die die Grundkonzepte von Lambda-Ausdrücken in die Praxis umsetzen:

Beispiel 1 – Vergleich der Implementierung ohne und mit Lambda

Keine Verwendung von Lambda:

MyValueSemLambda1-Schnittstelle {
double getValue(); // Abstrakte Methode
}
Die Klasse MyValueImpl implementiert MyValueSemLambda1{
privater Doppelwert;
// Konstruktor zum Initialisieren des value
-Attributs public MyValueImpl(double value) {
this.value = value;
}
// Implementierung der getValue-Methode
@Override
public double getValue() {
gib diesen.Wert zurück;
}
}
öffentliche Klasse MyValueSemLambda {
public static void main(String[] args) {
MyValueSemLambda1 myVal = new MyValueImpl(98.6); // Dem Attribut einen Wert zuweisen
System.out.println("Value: " myVal.getValue()); // Druckt 98,6
}
}

Lambda verwenden:

MyValueCompare-Schnittstelle {
double getValue();
}
öffentliche Klasse MyValueComparacao {
public static void main(String[] args) {
// Lambda-Ausdruck ohne Attribut, aber Rückgabe eines Werts
MyValueCompares myVal = () -> 98,6;
System.out.println("Value: " myVal.getValue()); // Druckt 98,6
}
}

Beispiel 2 – LambdaDemo

// Eine funktionale Schnittstelle.
Schnittstelle MyValue {
double getValue();
}
// Eine weitere funktionale Schnittstelle.
Schnittstelle MyParamValue {
double getValue(double v);
}
Klasse LambdaDemo {
public static void main(String args[])
{
MyValue myVal; // eine Schnittstellenreferenz deklarieren
// Hier ist der Lambda-Ausdruck einfach ein konstanter Ausdruck.
// Wenn es myVal zugewiesen wird, wird die Instanz
erstellt // einer Klasse, in der der Lambda-Ausdruck das
implementiert // getValue()-Methode von MyValue.
myVal = () -> 98,6; Ein einfacher Lambda-Ausdruck
// Ruft getValue() auf, das von
bereitgestellt wird // zuvor zugewiesener Lambda-Ausdruck.
System.out.println("Ein konstanter Wert: " myVal.getValue());
// Erstellen Sie nun einen parametrisierten Lambda-Ausdruck und weisen Sie ihn zu
// für eine MyParamValue-Referenz. Dieser Lambda-Ausdruck gibt
zurück // der Kehrwert seines Arguments.
MyParamValue myPval = (n) -> 1,0/n; Ein Lambda-Ausdruck
welches einen Parameter hat
// Rufen Sie getValue() über die myPval-Referenz auf.
System.out.println("Kehrwert von 4 ist " myPval.getValue(4.0));
System.out.println("Kehrwert von 8 ist " myPval.getValue(8.0));
// Ein Lambda-Ausdruck muss mit der definierten Methode kompatibel sein
// über die funktionale Schnittstelle. Daher funktionieren diese Anweisungen nicht:
// myVal = () -> "drei"; // Fehler! String ist nicht kompatibel mit double!
// myPval = () -> Math.random(); // Fehler! Der Parameter ist erforderlich!
}
}

Ausgabe:
Ein konstanter Wert: 98,6
Der Kehrwert von 4 ist 0,25
Der Kehrwert von 8 ist 0,125

• Der Lambda-Ausdruck muss mit der von Ihnen implementierten abstrakten Methode kompatibel sein.

Beispiel für Inkompatibilitäten:

• Ein String-Wert kann nicht verwendet werden, wenn der erwartete Rückgabetyp double ist.

• Eine Methode, die einen Parameter erfordert, kann nicht verwendet werden, ohne ihn bereitzustellen.

• Eine funktionale Schnittstelle kann mit jedem kompatiblen Lambda-Ausdruck verwendet werden.

Beispiel 3 – NumerischerTest

Teilbarkeitstest:Überprüft, ob die erste Zahl durch die zweite teilbar ist.
Größenvergleich:Bestimmt, ob die erste Zahl kleiner als die zweite ist.
Vergleich absoluter Werte: Gibt „true“ zurück, wenn die absoluten Werte der beiden Zahlen gleich sind.

• In main() werden drei verschiedene Tests mit Lambda-Ausdrücken erstellt.

// Funktionsschnittstelle, die zwei Parameter int und
akzeptiert // gibt ein boolesches Ergebnis zurück.
Schnittstelle NumericTest {
boolescher Test(int n, int m);
}
Klasse LambdaDemo2 {
public static void main(String args[])
{
// Dieser Lambda-Ausdruck bestimmt, ob eine Zahl
// ist ein Faktor eines anderen.
NumericTest isFactor = (n, d) -> (n % d) == 0;
if(isFactor.test(10, 2))
System.out.println("2 ist ein Faktor von 10");
if(!isFactor.test(10, 3))
System.out.println("3 ist kein Faktor von 10");
System.out.println();
// Dieser Lambda-Ausdruck gibt true zurück, wenn
// erstes Argument ist kleiner als das zweite.
NumericTest lessThan = (n, m) -> (n < m);
if(lessThan.test(2, 10))
System.out.println("2 ist kleiner als 10");
if(!lessThan.test(10, 2))
System.out.println("10 ist nicht kleiner als 2");
System.out.println();
// Dieser Lambda-Ausdruck gibt true zurück, wenn Sie
// absolute Werte der Argumente sind gleich.
NumericTest absEqual = (n, m) -> (n < 0 ? -n : n) == (m < 0 ? -m : m);
if(absEqual.test(4, -4))
System.out.println("Absolute Werte von 4 und -4 sind gleich.");
if(!lessThan.test(4, -5))
System.out.println("Absolute Werte von 4 und -5 sind nicht gleich.");
System.out.println();
}
}

Ausgabe:
2 ist ein Faktor von 10
3 ist kein Faktor von 10
2 ist kleiner als 10
10 ist nicht weniger als 2
Absolute Werte von 4 und -4 sind gleich.
Absolute Werte von 4 und -5 sind nicht gleich.

• Kompatible Lambda-Ausdrücke können mit derselben funktionalen Schnittstelle verwendet werden.

• Die gleiche Referenzvariable kann für verschiedene Lambda-Ausdrücke wiederverwendet werden.

• Die Wiederverwendung von Variablen erleichtert das Lesen und spart Ressourcen im Code.

• Im Beispiel wird die gleiche Schnittstelle für verschiedene Implementierungen verwendet:

NumericTest myTest;
myTest = (n, d) -> (n % d) == 0; //Implementierung 1
if(myTest.test(10, 2))
System.out.println("2 ist ein Faktor von 10");
// ...
myTest = (n, m) -> (n < m); //Implementierung 2
if(myTest.test(2, 10))
System.out.println("2 ist kleiner als 10");
//...
myTest = (n, m) -> (n < 0 ? -n : n) == (m < 0 ? -m : m); //Implementierung 3
if(myTest.test(4, -4))
System.out.println("Absolute Werte von 4 und -4 sind gleich.");
// ...

Klarheit mit Referenzvariablen

Durch die Verwendung verschiedener Referenzvariablen (z. B. isFactor, lessThan, absEqual) können Sie klar identifizieren, welchen Lambda-Ausdruck jede Variable darstellt.

Mehrere Parameterspezifikation

Mehrere Parameter in Lambda-Ausdrücken werden durch Kommas in einer Klammerliste auf der linken Seite des Lambda-Operators getrennt.
Beispiel: (n, d) -> (n % d) == 0.

Verwendung verschiedener Typen in Lambda-Ausdrücken

Es gibt keine Einschränkung hinsichtlich der Art der Parameter oder der Rückgabe in abstrakten Methoden funktionaler Schnittstellen.
Nicht-primitive Datentypen wie String können in Lambda-Ausdrücken verwendet werden.

Beispiel für einen Test mit Strings

Eine funktionale Schnittstelle kann verwendet werden, um bestimmte Zeichenfolgen-bezogene Bedingungen zu testen, z. B. um zu prüfen, ob eine Zeichenfolge in einer anderen enthalten ist.

// Eine funktionale Schnittstelle, die zwei Strings testet.
Schnittstelle StringTest {
boolean test(String aStr, String bStr);
}
Klasse LambdaDemo3 {
public static void main(String args[])
{
// Dieser Lambda-Ausdruck bestimmt, ob ein String dies tut
// Teil eines anderen.
StringTest isIn = (a, b) -> a.indexOf(b) != -1;
String str = „Dies ist ein Test“;
System.out.println("Testing string: " str);
if(isIn.test(str, "is a"))
System.out.println("'ist ein' gefunden.");
sonst
System.out.println("'ist ein' nicht gefunden.");
if(isIn.test(str, "xyz"))
System.out.println("'xyz' Gefunden");
sonst
System.out.println("'xyz' nicht gefunden");
}
}

Ausgabe:
Testzeichenfolge: Dies ist ein Test
'ist ein' gefunden.
'xyz' nicht gefunden

StringTest-Funktionsschnittstelle

Definiert einen abstrakten Methodentest (String aStr, String bStr), der einen booleschen Wert zurückgibt.

Implementierung mit Lambda-Ausdruck

Der Lambda-Ausdruck (a, b) -> a.indexOf(b) != -1 prüft, ob eine Zeichenfolge (b) in einer anderen (a) enthalten ist.

Typinferenz in Parametern

Es wird angenommen, dass die Parameter a und b vom Typ String sind, was die Verwendung von Methoden der String-Klasse ermöglicht, wie z. B. indexOf.

Das Programm testet die Zeichenfolge „Dies ist ein Test“, um zu sehen, ob sie die Teilzeichenfolgen „is a“ und „xyz“ enthält, und druckt die Ergebnisse entsprechend aus.

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