Gleichzeitige Programmiermethoden mit Lambda-Ausdrücken

Eine wichtige Ergänzung in Java SE 8 ist die Lambda-Ausdrucksfunktion. Verwenden Sie Ausdrücke, um Methodenschnittstellen klar und prägnant auszudrücken. Sammlungsbibliotheken sind sehr hilfreich. Sammlungen können für nützliche Zwecke iteriert, gefiltert und Daten extrahiert werden. Zur Implementierung funktionaler Schnittstellen werden häufig Lambda-Ausdrücke verwendet. Es spart viel Code. Mit Lambda-Ausdrücken können wir Implementierungen bereitstellen, ohne Methoden neu zu definieren. Erst hier wird der Implementierungscode durch das Schreiben von Code gebildet. Der Compiler erstellt keine .class-Datei, da Java-Lambda-Ausdrücke als Funktionen behandelt werden.

Funktionsschnittstelle

@FunctionalInterface ist eine Java-Annotation, die eine Schnittstelle als funktionale Schnittstelle deklariert. Eine funktionale Schnittstelle ist eine Schnittstelle mit nur einer abstrakten Methode. Mit Lambda-Ausdrücken können Sie diese funktionale Schnittstelle implementieren.

Warum Lambda-Ausdrücke verwenden?

• Es bietet die Implementierung einer funktionalen Schnittstelle.

• Es bietet weniger Codierung.

Java-Lambda-Ausdruckssyntax

(argument-list)
{
   //body
}

Es besteht aus drei Komponenten−

• Argument-List − kann leer oder nicht leer sein

• Arrow-Taken − Wird verwendet, um die Parameterliste und den Hauptteil des Ausdrucks zu verbinden

• Body − Ausdrücke und Anweisungen, die Lambda-Ausdrücke enthalten

Parameterlose Syntax

()
{
   // body of no parameter lambda
}

Ein-Parameter-Syntax

(p1)
{
   // body of single parameter lambda
}

Zwei-Parameter-Syntax

(p1,p2)
{
   //body of multiple parameter lambda
}

Beispiel: Java-Lambda-Ausdruck

@FunctionalInterface  //It is optional  
interface Drawable{  
   public void draw();  
}  
  
public class LambdaExpressionExample2 {  
   public static void main(String[] args) {  
      int width=10;  
          
      //with lambda  
      Drawable d2=()->{  
         System.out.println("Drawing "+width);  
      };  
      d2.draw();  
   }  
}

Ausgabe

Drawing 10

Beispiel: ohne Verwendung des Lambda-Ausdrucks

interface Drawable{  
   public void draw();  
}  
public class LambdaExpressionExample {  
   public static void main(String[] args) {  
      int width=10;  
  
      //without lambda, Drawable implementation using anonymous class  
      Drawable d=new Drawable(){  
         public void draw(){System.out.println("Drawing "+width);}  
      };  
      d.draw();  
   }  
}

Ausgabe

Drawing 10

Beispiel: keine Parameter

interface Sayable{  
   public String say();  
}  
public class LambdaExpressionExample3{  
   public static void main(String[] args) {  
      Sayable s=()->{  
         return "Don’t settle for average.";  
      };  
      System.out.println(s.say());  
   }  
}

Ausgabe

Don’t settle for average

Beispiel: einzelner Parameter

interface Sayable {  
   public String say(String name);  
}  
  
public class LambdaExpressionExample4{  
   public static void main(String[] args) {  
      
      // Lambda expression with single parameter.  
      Sayable s1=(name)->{  
         return "Hello, "+name;  
      };  
      System.out.println(s1.say("World"));  
          
      // You can omit function parentheses    
      Sayable s2= name ->{  
         return "Hello, "+name;  
      };  
      System.out.println(s2.say("World"));  
   }  
}

Ausgabe

Hello, World
Hello, World

Beispiel: mehrere Parameter

interface Addable{  
   int add(int a,int b);  
}  
  
public class LambdaExpressionExample5{  
   public static void main(String[] args) {  
          
      // Multiple parameters in lambda expression  
      Addable ad1=(a,b)->(a+b);  
      System.out.println(ad1.add(20,20));  
          
      // Multiple parameters with data type in lambda expression  
      Addable ad2=(int a,int b)->(a+b);  
      System.out.println(ad2.add(200,200));  
   }  
}

Ausgabe

40
400

Fazit

Durch die Verwendung von Ausdrücken bietet Java SE 8 mit der Lambda-Ausdrucksfunktion eine wertvolle Ergänzung. Methodenschnittstellen klar und prägnant auszudrücken ist zum Kinderspiel geworden. Das Iterieren, Filtern und Extrahieren von Daten gehören zu den vielen praktischen Einsatzmöglichkeiten, die Sammlungsbibliotheken bieten. Lambda-Ausdrücke werden häufig zur Implementierung funktionaler Schnittstellen verwendet und können die Codemenge erheblich reduzieren. Ein hervorragendes Merkmal von Lambda-Ausdrücken ist die Möglichkeit, eine Implementierung bereitzustellen, ohne die Methode redundant neu zu definieren. In diesem Bereich gibt das Schreiben die Form eines Implementierungscodes an. Der Compiler erstellt keine .class-Datei, da Funktionen als Java-Lambda-Ausdrücke behandelt werden.

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