Warum ist der Java Stream API-Filter schneller als eine Imperativschleife? ⇐ Java

[Guest]

Ich habe eine wichtige Frage.
Ich habe einen Benchmark mit den folgenden Toolversionen durchgeführt:

Code: Select all

# JMH version: 1.37
# VM version: JDK 22, OpenJDK 64-Bit Server VM, 22+36-FR
# VM invoker: /home/jack/.sdkman/candidates/java/22-amzn/bin/java

Mir ist aufgefallen, dass bei Datensätzen mit 1000 oder mehr Elementen Java Stream API-Filtervorgänge schneller sind als ein zwingender Ansatz mit einer Schleife. Ist dieses Verhalten zu erwarten?
Der Benchmark-Code:

Code: Select all

package com.example;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Fork(1)
@Warmup(iterations = 20, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 20, time = 1, timeUnit = TimeUnit.SECONDS)
public class Main {

@Param({"1", "10", "100", "1000", "100000", "1000000"})
private int size;

private List list;

@Setup(Level.Iteration)
public void setup() {
list = generateNumberedList(size);
}

@Benchmark
public void streamFilter(Blackhole blackhole) {
blackhole.consume(list.stream().filter(x -> x % 2 == 0).toList());
}

@Benchmark
public void imperativeFilter(Blackhole blackhole) {
List result = new ArrayList(size);
for (int i = 0; i < list.size(); i++) {
if (list.get(i) % 2 == 0) {
result.add(list.get(i));
}
}
blackhole.consume(result);
}

private List generateNumberedList(int size) {
List list = new ArrayList(size);
for (int i = 1; i