Why Lambda Expressions
Now Lets Iterate through the simple ArrayList
Without Lambda Expressions
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
for (int number : numbers)
{
System.out.println(number);
}
We iterate the collection externally, explicitly pulling out and processing the items one by one. Now through Lambda Expressions, we are using an internal iteration the JIT compiler could optimize it processing the items in parallel or in a different order. These optimizations are impossible if we iterate the collection externally as we are used to doing in Java and more in general with the imperative programming.
With Lambda Expressions
numbers.forEach((Integer value) -> System.out.println(value)); (or) numbers.forEach(value -> System.out.println(value));
Apart from the above reason Lambdas allows us to
- Enable to treat functionality as a method argument, or code as data.
- A function that can be created without belonging to any class.
- A lambda expression can be passed around as if it was an object and executed on demand.
- It reduces the line of code.
- It Supports Sequential and Parallel execution by passing behavior in methods with collection stream API
- Using Stream API and lambda expression we can achieve higher efficiency (parallel execution) in the case of bulk operations on collections
Java 8 Lambda uses JVM Opcode – invokedynamic
The Following code will result in Anonymous class being created when you compile the code.
So if you have 10 anonymous classes then it would be 10 more classes like(ClassName$1.class,ClassName$2.class….ClassName$10.class) in the final jar.
AccountService accountServiceAnonymous = new AccountService(){
public void createAccount(){
Account account = new Account();
save(account);
}
};
But Java 8 lambda uses invokedynamic to call lambdas thus if you have 10 lambdas it will not result in any anonymous classes thus reducing the final jar size.
AccountService accountServiceLambda = () -> {
Account account = new Account();
save(account);
}
