Is Lambda Expression in Java 8 reduce execution time?

Question

I am new to Java 8 and getting a bit confused about the scope of Lambda Expression. I read some articles expressing that Lambda Expression reduces execution time, so to find the same I wrote following two programs

1) Without using Lambda Expression

import java.util.*;

public class testing_without_lambda
{
  public static void main(String args[])
  {
    long startTime =  System.currentTimeMillis();       
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
    for (int number : numbers) 
    {
        System.out.println(number); 
    }   
    long stopTime =  System.currentTimeMillis();
    System.out.print("without lambda:");
    System.out.println(stopTime - startTime);
  }//end main
}

output:

2) With using Lambda Expression

import java.util.*;
public class testing_with_lambda
{
  public static void main(String args[])
  {  
    long startTime =  System.currentTimeMillis();
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);    
    numbers.forEach((Integer value) -> System.out.println(value));  
    long stopTime =  System.currentTimeMillis();
    System.out.print("with lambda:");
    System.out.print(stopTime - startTime);
  }//end main
}

output:

Is this means Lambda Expression requires more time to execute?

Answer 1

There is no general statement about “execution time” possible, as even the term “execution time” isn’t always meaning the same. Of course, there is no reason, why just using a lambda expression should reduce the execution time in general.

Your code is measuring the initialization time of the code and it’s execution time, which is fair, when you consider the total execution time of that tiny program, but for real life applications, it has no relevance, as they usually run significantly longer than their initialization time.

What make the drastic difference in initialization time, is the fact that the JRE uses the Collection API itself internally, so its classes are loaded and initialized and possibly even optimized to some degree, before your application even starts (so you don’t measure its costs). In contrast, it doesn’t use lambda expressions, so your first use of a lambda expression will load and initialize an entire framework behind the scenes.

Since you are usually interested in how code would perform in a real application, where the initialization already happened, you would have to execute the code multiple times within the same JVM to get a better picture. However, allowing the JVM’s optimizer to process the code bears the possibility that it gets over-optimized due to its simpler nature (compared to a real life scenario) and shows too optimistic numbers then. That’s why it’s recommended to use sophisticated benchmark tools, developed by experts, instead of creating your own. Even with these tools, you have to study their documentation to understand and avoid the pitfalls. See also How do I write a correct micro-benchmark in Java?

---

When you compare the for loop, also known as “external iteration” with the equivalent forEach call, also known as “internal iteration”, the latter does indeed bear the potential of being more efficient, if properly implemented by the particular Collection, but its outcome is hard to predict, as the JVM’s optimizer is good at removing the drawbacks of the other solution. Also, your list is far too small to ever exhibit this difference, if it exists.

It also must be emphasized that this principle is not tight to lambda expressions. You could also implement the Consumer via an anonymous inner class, and in your case, where the example suffers from the first time initialization cost, the anonymous inner class would be faster than the lambda expression.