Kaedah pengaturcaraan serentak menggunakan ungkapan Lambda

Tambahan penting dalam Java SE 8 ialah ciri ekspresi lambda. Gunakan ungkapan untuk menyatakan antara muka kaedah dengan jelas dan padat. Perpustakaan koleksi sangat membantu. Koleksi boleh diulang, ditapis dan data diekstrak untuk tujuan yang berguna. Untuk melaksanakan antara muka berfungsi, ungkapan lambda digunakan secara meluas. Ia menjimatkan banyak kod. Ungkapan Lambda membolehkan kami menyediakan pelaksanaan tanpa mentakrifkan semula kaedah. Di sini sahaja kod pelaksanaan dibentuk dengan menulis kod. Pengkompil tidak mencipta fail .class kerana ungkapan lambda Java dianggap sebagai fungsi.

Antara muka berfungsi

@FunctionalInterface ialah anotasi Java yang mengisytiharkan antara muka sebagai antara muka berfungsi. Antara muka berfungsi ialah antara muka dengan hanya satu kaedah abstrak. Ungkapan Lambda membolehkan anda melaksanakan antara muka berfungsi ini.

Mengapa menggunakan ungkapan Lambda?

• Ia menyediakan pelaksanaan antara muka berfungsi.

• Ia menyediakan kurang pengekodan.

Sintaks Ungkapan Lambda Java

(argument-list)
{
   //body
}

Ia terdiri daripada tiga komponen−

• Argument-List − boleh kosong atau tidak kosong

• Arrow-Taken − Digunakan untuk menyambung senarai parameter dan badan ungkapan

• Badan − Ungkapan dan pernyataan yang mengandungi ungkapan lambda

Sintaks tanpa parameter

()
{
   // body of no parameter lambda
}

Sintaks satu parameter

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

Dua sintaks parameter

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

Contoh: Ekspresi Java Lambda

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

Output

Drawing 10

Contoh: tanpa menggunakan ungkapan Lambda

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

Output

Drawing 10

Contoh: tiada 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());  
   }  
}

Output

Don’t settle for average

Contoh: parameter tunggal

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

Output

Hello, World
Hello, World

Contoh: berbilang 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));  
   }  
}

Output

40
400

Kesimpulan

Menggunakan ungkapan, Java SE 8 menyediakan tambahan berharga dengan ciri ekspresi lambda. Menyatakan antara muka kaedah dengan cara yang jelas dan ringkas telah menjadi satu kek. Mengulang, menapis dan mengekstrak data adalah antara banyak kegunaan praktikal yang disediakan oleh perpustakaan koleksi. Ungkapan Lambda telah digunakan secara meluas untuk melaksanakan antara muka berfungsi, dan ia boleh mengurangkan jumlah kod dengan banyak. Ciri terbaik ungkapan lambda ialah keupayaan untuk memberikan pelaksanaan tanpa mentakrifkan semula kaedah secara berlebihan. Dalam ruang ini, penulisan memberikan bentuk kod pelaksanaan. Pengkompil tidak mencipta fail .class kerana fungsi dianggap sebagai ungkapan lambda Java.

Atas ialah kandungan terperinci Kaedah pengaturcaraan serentak menggunakan ungkapan Lambda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!