What is Lambda expression?
As per Wikipedia, lambda expression also called as anonymous function. It’s a function without name and does not belong to any class. Lambda expression is introduced as part of Java 8 features.
A traditional method or function in java has these main parts.
- Name
- Parameter list
- Body
- Return type
A lambda expression in java has these main parts.
- No Name: as this is anonymous function there is no name needed
- Parameter list
- Body: this is the main part of the function
- No return type: you don’t need to mention the return type in lambda’s expression. The java 8+ compiler is able to infer the return type by checking the code.
Program of using lambda expression without any parameters:
@FunctionalInterface interface NoParamInterface{ String printHelloWorld(); } public class NoParamLambdaTest{ public static void main(String[] args) { NoParamInterface noParamInterface= () -> "Hello World"; System.out.println(noParamInterface.printHelloWorld()); } }
Program of using Lambda expression with single parameter:
@FunctionalInterface interface SingleParam{ int incrementBy10(int x); } public class SingleParamLambdaTest { public static void main(String[] args) { SingleParam singleParam = (x) -> x+10; System.out.println(singleParam.incrementBy10(5)); } }
Program of using Lambda expression with multiple parameters:
@FunctionalInterface interface MultiParam{ String concat(String x, String y); } public class MultiParamLambdaTest { public static void main(String[] args) { MultiParam multiParam = (x, y) -> x+" "+y; System.out.println(multiParam.concat("Hello", "World")); } }
Program of using Lambda expression with Runnable interface:
public class RunnableExample { public static void main(String[] args) { //Traditional way of implementation Runnable runnable = new Runnable() { @Override public void run() { int sum=0; for(int i=0;i<10;i++) sum +=i; System.out.println("Traditional : "+sum); } }; new Thread(runnable).start(); //Implementing using lambda Runnable runnable1 = () -> { int sum=0; for(int i=0;i<10;i++) sum +=i; System.out.println("Lambda : "+sum); }; new Thread(runnable1).start(); //Implementing Thread with Lambda new Thread(()->{ int sum=0; for(int i=0;i<10;i++) sum +=i; System.out.println("Thread with Lambda : "+sum); }).start(); } }
Program of using Lambda expression with Callable interface:
import java.util.Arrays; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.stream.IntStream; public class CallableExample { public static int[] array = IntStream.range(0,5000).toArray(); public static int count = IntStream.range(0,5000).sum(); public static void main(String[] args) throws InterruptedException, ExecutionException { Callable<Integer> callable1 = () -> { int sumOfEven=0; for(int i=0;i<array.length;i++){ if(i%2 == 0) sumOfEven = sumOfEven + i; } return sumOfEven; }; Callable<Integer> callable2 = () -> { int sumOfOdd=0; for(int i=0;i<array.length;i++){ if(i%2 == 1) sumOfOdd = sumOfOdd + i; } return sumOfOdd; }; ExecutorService executorService = Executors.newFixedThreadPool(2); System.out.println("Sum of Even of given range: "+executorService.invokeAny(Arrays.asList(callable1))); System.out.println("Sum of Odd of given range: "+executorService.invokeAny(Arrays.asList(callable2))); executorService.shutdown(); System.out.println("Count of the given range is : "+count); System.out.println("Sum of Odd and Even is equals to count"); } }