Java 8 Speed test by Simple Print List

This comparison is completely meaningless.

First, the first two variants are completely dominated by I/O time. Any loop over anything whatsoever that does output will usually be. The way you iterate has an effect that is probably in the noise. I/O is slow.

But it is not quite as slow as what you're doing in the third variant. In the third variant, you use parallelStream(), which invokes the join/fork machinery of Java8. You're spawning multiple threads (probably as many as you have CPU cores). You're distributing the tasks to write the list elements over these threads. You're then writing to the same stream from each of these threads, which serializes their operation, i.e. after you went through all the work of creating the threads and distributing tasks, you're still only doing one thing at a time, plus you're now also incurring massive synchronization overhead.

If you want to do an interesting comparison, you need to transform data into some other data, and you need to do non-trivial (but not synchronized) work on each item, so that the task management overhead doesn't swamp the computation time.

In the meantime, try using stream() instead of parallelStream(). That should get the time down to roughly the time of the other two variants. That doesn't make it any more meaningful though.

Disclaimer: You are doing micro benchmarks, and micro benchmarks are hard to do. I'm sure my slightly changed code below has enough problems by itself.

A parallelStream() needs some startup time, and you have the overhead multiple Threads are bringing with them.

Another problem is, that you are doing System.out.println() for each item - it's IO, so you are measuring a whole lot besides the iteration too. That's especially a problem when you are accessing one stream (System.out) from multiple threads.

If you delete your print statements, the JVM will problably just skip the loops, that's why I'm just adding every element to a sum. Should be quite fast, and it won't get optimized away.

When running the following example with a list size of 100000000 (takes about one minute to create), I get these results:

Milis Need JDK 1.4 : 190 Milis Need JDK 1.5 : 681 Milis Need JDK 1.8 : 198 

My code:

@Test public void testIterationSpeed() { List<Integer> data = new ArrayList<>(); for (int i = 0; i < 100000000; i++) { data.add(i); } /*Style Java 1.4*/ long dummySum = 0; long beforeStartJDK14 = System.currentTimeMillis(); for (int i = 0; i < data.size(); i++) { dummySum += data.get(i); } long afterPrintJDK14 = System.currentTimeMillis(); /*Style Java 1.5*/ dummySum = 0; long beforeStartJDK15 = System.currentTimeMillis(); for (Integer i : data) { dummySum += i; } long afterPrintJDK15 = System.currentTimeMillis(); /* Java 1.8 */ long beforeStartJDK18 = System.currentTimeMillis(); data.parallelStream().mapToLong(i -> i).sum(); long afterPrintJDK18 = System.currentTimeMillis(); System.out.println("Milis Need JDK 1.4 : " + (afterPrintJDK14 - beforeStartJDK14)); System.out.println("Milis Need JDK 1.5 : " + (afterPrintJDK15 - beforeStartJDK15)); System.out.println("Milis Need JDK 1.8 : " + (afterPrintJDK18 - beforeStartJDK18)); } 

Note that if you decrease the list size, the overhead of the parallelStream will be too much - this fact is also called Amdahl's Law. And the process of creating the sum is different than in the other loops, so it's not a good benchmark.

What's interesting is that for each is slower than for in this case.