Concurrent programming methods using Lambda expressions

An important addition in Java SE 8 is the lambda expression feature. Use expressions to express method interfaces clearly and concisely. Collection libraries are very helpful. Collections can be iterated, filtered, and data extracted for useful purposes. To implement functional interfaces, lambda expressions are widely used. It saves a lot of code. Lambda expressions allow us to provide implementations without redefining methods. It is only here that the implementation code is formed by writing the code. The compiler does not create a .class file because Java lambda expressions are treated as functions.

Functional interface

@FunctionalInterface is a Java annotation that declares an interface as a functional interface. Functional interface is an interface with only one abstract method. Lambda expressions allow you to implement this functional interface.

Why use Lambda expressions?

• It provides the implementation of functional interface.

• It provides less encoding.

Java Lambda Expression Syntax

(argument-list)
{
   //body
}

It consists of three components −

• Argument-List − Can be empty or non-empty

• Arrow-Taken − Used to connect the parameter list and the body of the expression

• Body − Expressions and statements containing lambda expressions

No parameter syntax

()
{
   // body of no parameter lambda
}

One parameter syntax

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

Two parameter syntax

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

Example: Java Lambda expression

@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

Example: Lambda expression not used

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

Example: No parameters

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

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

Output

Hello, World
Hello, World

Example: Multiple parameters

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

in conclusion

Using expressions, Java SE 8 provides a valuable addition through the lambda expression feature. Expressing method interfaces in a clear and concise way has become a piece of cake. Iterating, filtering, and extracting data are among the many practical uses provided by collection libraries. Lambda expressions have been widely used to implement functional interfaces, and they can greatly reduce the amount of code. An excellent feature of lambda expressions is the ability to give implementations without redundantly redefining methods. In this space, writing gives implementation code form. The compiler does not create a .class file because functions are treated as Java lambda expressions.

The above is the detailed content of Concurrent programming methods using Lambda expressions. For more information, please follow other related articles on the PHP Chinese website!