JAVA8 lambda执行效率

package lambdaPerfmTest;

import org.junit.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;

import java.security.SecureRandom;
import java.util.*;
import java.util.concurrent.TimeUnit;


public class PerfTest {

    private static List<Integer> integers = new ArrayList<>();

    public static final int size = 100000;
    {
        SecureRandom random = new SecureRandom();
        for (int i = 0; i < size; i++) {
            int i1 = random.nextInt(size);
            integers.add(i1);
        }
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    @BenchmarkMode(Mode.AverageTime)
    public int iteratorMaxInteger() {

        int max = Integer.MIN_VALUE;
        for (Iterator<Integer> it = integers.iterator(); it.hasNext(); ) {
            max = Integer.max(max, it.next());
        }
        return max;
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    @BenchmarkMode(Mode.AverageTime)
    public int forEachLoopMaxInteger() {
        int max = Integer.MIN_VALUE;
        for (Integer n : integers) {
            max = Integer.max(max, n);
        }
        return max;
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    @BenchmarkMode(Mode.AverageTime)
    public int forMaxInteger() {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < size; i++) {
            max = Integer.max(max, integers.get(i));
        }
        return max;
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    @BenchmarkMode(Mode.AverageTime)
    public int parallelStreamMaxInteger() {
        Optional<Integer> max;
        max = integers.parallelStream().reduce(Integer::max);
        return max.get();
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    @BenchmarkMode(Mode.AverageTime)
    public int lambdaMaxInteger() {
        return integers.stream().reduce(Integer.MIN_VALUE, (a, b) -> Integer.max(a, b));
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(PerfTest.class.getSimpleName())
                .warmupTime(TimeValue.seconds(1))
                .forks(1)
                .build();

        new Runner(opt).run();
    }

    @Test
    public void test()
    {
        time(new PerfTest()::parallelStreamMaxInteger);
    }




    public void time(Runnable run) {
        long startTime = System.currentTimeMillis();
        System.out.println("startTime = " + startTime);

        run.run();

        long endTime = System.currentTimeMillis();
        System.out.println("endTime = " + endTime);
        System.out.println("###################");
        long cost = endTime - startTime;
        System.out.println("cost = " + cost);

    }

    public void time(Runnable... runList) {
        for (Runnable runnable : runList) {
            time(runnable);
        }
    }

   /* public static void main(String[] args) {
        PerfTest test = new PerfTest();
        test.time(test::forEachLoopMaxInteger, test::forMaxInteger, test::iteratorMaxInteger, test::lambdaMaxInteger, test::parallelStreamMaxInteger);
    }*/


}

JMH执行结果：
Benchmark                                          Mode  Cnt  Score   Error  Units
lambdaPerfmTest.PerfTest.forEachLoopMaxInteger     avgt   20  1.026 ± 0.023  ms/op
lambdaPerfmTest.PerfTest.forMaxInteger             avgt   20  0.650 ± 0.016  ms/op
lambdaPerfmTest.PerfTest.iteratorMaxInteger        avgt   20  1.018 ± 0.030  ms/op
lambdaPerfmTest.PerfTest.lambdaMaxInteger          avgt   20  1.687 ± 0.041  ms/op
lambdaPerfmTest.PerfTest.parallelStreamMaxInteger  avgt   20  0.747 ± 0.021  ms/op

从结果来看,并行执行效率有提升，lamdba执行效率慢了60%。