Which would be better in terms of performance Lambda or simple loop?

Question

I have quickly read over the Oracle Lambda Expression documentation.

This kind of example has helped me to understand better, though:

//Old way:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
for(Integer n: list) {
System.out.println(n);
}

//New way:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
list.forEach(n -> System.out.println(n));


//or we can use :: double colon operator in Java 8
list.forEach(System.out::println);

Still, I don't understand why it's such an innovation. It's just a method that dies when the "method variable" ends, right? Why should I use this instead of a real method? Which would be better option in terms of performance. Lambda or simple loop.

Answer 1

My advice would be:

1. Use the style that you and your coworkers agree is most maintainable.

2. If you and your colleagues are not yet comfortable with lambdas, keep learning.

3. Don't obsess over performance. It is often not the most important thing.

Generally speaking, lambdas and streams provide a more concise and (once everyone is up to speed) more readable way of expressing this kind of algorithm. Performance is not the primary goal.

If performance does become an issue, then the standard advice is to code, test, benchmark, profile and optimize. And do it in that order! You can easily waste a lot time by optimizing at the coding stage, or by optimizing code that has minimal impact on overall application performance.

• Let the application benchmarks tell you if you need to optimize at all.
• Let the profiler point out the parts of your code that are worthy of the effort of optimization.

---

In this specific example, the performance difference is going to be too small to measure. And if you scaled up to a list of millions of elements, the performance will be dominated by the time taken to build the list and write the numbers. The different ways of iteration will only contribute a small part to the overall performance.

---

And for folks, who (despite all of the above) still want to know whether it is faster to use a lambda or a conventional loop, the best general answer is:

"It depends on all sorts of factors that 1) are not well understood, and 2) liable to change as Java compiler technology evolves.

We could give you an answer for a specific example with a specific Java major/minor/patch release, but it would be unwise to generalize.

Answer 2

Why should I use this instead of a real method?

You should not. Use the approach which you like more.

As for performance, I guess, all these versions are roughly equally fast. Here I/O operation (println) is much slower than all possible overhead of calling lambda or creating an iterator. In general forEach might be slightly faster as it does everything inside the single method without creating the Iterator and calling hasNext and next (which is implicitly done by for-each loop). Anyway, this depends on many factors, such as how often you call this code, how long your list is, whether JIT compiler managed to devirtualize the iterator and/or lambda, and so on.

Answer 3

It allows you write in one line (while having enough readability) something, what was not possible before. Performance is not issue here O(n) stays O(n).

For example in my Windows Phone App, I have sessions and in that sessions are performers and I want to select all sessions which have one concrete performer (like you want to see all the movies some actor plays in). In Java 1.7 or less I had to create loop with inner loop, checking for it, returning null if there is no performer etc. And with lambda expressions, I can do this :

//performerId is parameter passed by method before
Sessions.Where(x => x.Performers.Where(y => y.PerformerId == performerId).FirstOrDefault() != null)

It is same in Java now (however I am not working on 1.8 project right now, I do not have Java example, but I am looking forward to it).

Answer 4

If you want to understand the value of lambda expressions you shouldn’t look at the only new method which has a language counterpart which existed before. How about these examples:

button.addActionListener( ev -> BACKGROUND_EXECUTOR_SERVICE.execute( () -> {
   String result = longComputation();
   SwingUtilities.invokeLater( () -> label.setText(result) );
});

Just think about how the equivalent pre-Java 8 code looks like and you see that the main advantage is not performance here.

If you want to look at Collection operations, how about this one?

map.merge(key, 1, Integer::sum);

This will put 1 into the map, if the key doesn’t exist in the map yet or add 1 to the value of the existing mapping otherwise. Again, think about how the old counterpart looks like. The fact that it might be even more efficient as it avoids multiple hash operations, if the map has an appropriate implementation of the method, is only an additional benefit.

Surely, the forEach method can not provide such a big gain in expressiveness as there is the for-each language counterpart. Still, not needing to declare a loop variable can improve the source code, if the declaration requires to repeat a long type name and generic parameters. That’s especially true in the context of Maps:

Map<ContainerOrderFocusTraversalPolicy, List<AttributedCharacterIterator>> map;
//…

 

map.forEach((p,l)->l.forEach(i->{ /* do your work using p and i */}));

here, this new iteration clearly wins over

for(Map.Entry<ContainerOrderFocusTraversalPolicy, List<AttributedCharacterIterator>> e:
                                                                      map.entrySet()) {
    ContainerOrderFocusTraversalPolicy p=e.getKey();
    for(AttributedCharacterIterator i: e.getValue()) {
        /* do your work using p and i */
    }
}

Of course, it only matters if the actual work statements are small enough but that’s how lambda expressions should be used: to encapsulate small pieces of code. And there are still tasks which can’t be done this way and require an ordinary for-each loop, just as there are also tasks which can’t be done with a for-each loop and need the even-older for loop dealing with an Iterator manually…

Answer 5

In terms of performance a normal function will be better as compare to lambda because in groovy there are closures present which is more or like same as lambda.

These things are working in a way like if you write a closure for any collection it will internally create a another class which actually does action for mentioned closure or lambda expression.

But, by using lambda and closure i can iterate things in better way as well as i can debug easily. You can write less line of codes.

Answer 6

When using lambda in your code, you are telling what to do not how to do it. Above code passing a method reference instead of looping over the list, I think the lambda one is more ergonomic.

As far as performance is concerned, printing of a list of 1 million items took almost same time but I have not bench-marked other kind of operation.

The above code is a trivial operation but lambda has quite a few advantages as you can have functions which you can pass around, using multiple core(parallel streams) is easy etc.

Answer 7

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Timeout;
import org.openjdk.jmh.annotations.Warmup;

/**
 *
 * @author devb
 */
@BenchmarkMode(Mode.Throughput)
@Fork(value = 1)
@Warmup(iterations = 1, time = 32, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 16, time = 1, timeUnit = TimeUnit.SECONDS)
@Timeout(time = 1, timeUnit = TimeUnit.SECONDS)
@State(Scope.Benchmark)
public class CheckLamdaPerformance {

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

    @Benchmark
    public void testPerOld() {
        //Old way:
        for (Integer n : list) {
            System.out.println(n);
        }
    }

    @Benchmark
    public void testPerNew() {
        //New way:
        list.forEach(n -> System.out.println(n));
    }

    @Benchmark
    public void testPerDoubleColon() {
        //or we can use :: double colon operator in Java 8
        list.forEach(System.out::println);
    }

}

To Test benchmark

import java.io.IOException;
import org.openjdk.jmh.Main;
import org.openjdk.jmh.runner.RunnerException;

/**
 *
 * @author devb
 */
public class MyBenchmark {

    private static final String TEST = ".*CheckLamdaPerformance.*"; 

    public static void main(String[] args) throws IOException, RunnerException {
        Main.main(getArguments(TEST, 1, 5000, 1));
    }

    private static String[] getArguments(String className, int nRuns, int runForMilliseconds, int nThreads) {
        return new String[]{className,
            "-i", "" + nRuns,
            "-r", runForMilliseconds + "ms",
            "-t", "" + nThreads,
            "-w", "5000ms",
            "-wi", "1"
        };
    }

}

After Running Output is:

# Run complete. Total time: 00:00:34

Benchmark                                  Mode  Cnt     Score   Error  Units
CheckLamdaPerformance.testPerDoubleColon  thrpt        776.008          ops/s
CheckLamdaPerformance.testPerNew          thrpt       1096.423          ops/s
CheckLamdaPerformance.testPerOld          thrpt        873.542          ops/s

Answer 8

Look at first part in Guava documentation. It is about older Java version but makes important point - using lambdas everywhere might actually make code less readable. Better example might be the one from Stream API:

 // Group employees by department
 Map<Department, List<Employee>> byDept
     = employees.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment));

Answer 9

The run-time and readability certainly seems to vary case-by-case, but in my mind there is a pretty good answer to

Why should I use this instead of a real method?

You can pass a lambda function as a variable
Correct me if I'm off base on this, as I've been mostly a Fantom user for a while now, but you can pass a Lambda function as an argument to a method call. For example, if you have a sort method built, it could take a lambda argument as the comparator to use, allowing you to use the single sort method to compare different fields in an object, or even completely different object, easily.