从列表中查找最大元素的java流性能

Question

我编写了一个简单的程序来比较流的性能，以查找整数的最大形式列表。令人惊讶的是我发现“流方式”的性能是“通常方式”的1/10。难道我做错了什么？ Stream方式有没有什么条件会效率不高呢？有人能对这种行为有一个很好的解释吗？

“流方式”花了 80 毫秒“通常方式”花了 15 毫秒请找到下面的代码

public class Performance {

public static void main(String[] args) {

    ArrayList<Integer> a = new ArrayList<Integer>();
    Random randomGenerator = new Random();
    for (int i=0;i<40000;i++){
        a.add(randomGenerator.nextInt(40000));
    }
    long start_s = System.currentTimeMillis( );

            Optional<Integer> m1 = a.stream().max(Integer::compare);

    long diff_s = System.currentTimeMillis( ) - start_s;
    System.out.println(diff_s);


    int e = a.size();
    Integer m = Integer.MIN_VALUE;

    long start = System.currentTimeMillis( );
    for(int i=0; i < e; i++) 
      if(a.get(i) > m) m = a.get(i);

    long diff = System.currentTimeMillis( ) - start;
    System.out.println(diff);


}

}

Answer 1

是的，对于如此简单的操作，流速度较慢。但你的数字完全无关。如果您认为 15 毫秒对于您的任务来说是令人满意的时间，那么有个好消息:预热后的流代码可以在 0.1-0.2 毫秒内解决这个问题，速度提高了 70-150 倍。

这是快速而肮脏的基准:

import java.util.concurrent.TimeUnit;
import java.util.*;
import java.util.stream.*;

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

@Warmup(iterations = 5, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(3)
@State(Scope.Benchmark)
public class StreamTest {
    // Stream API is very nice to get random data for tests!
    List<Integer> a = new Random().ints(40000, 0, 40000).boxed()
                                  .collect(Collectors.toList());

    @Benchmark
    public Integer streamList() {
        return a.stream().max(Integer::compare).orElse(Integer.MIN_VALUE);
    }

    @Benchmark
    public Integer simpleList() {
        int e = a.size();
        Integer m = Integer.MIN_VALUE;
        for(int i=0; i < e; i++) 
            if(a.get(i) > m) m = a.get(i);
        return m;
    }
}

结果是:

Benchmark               Mode  Cnt    Score    Error  Units
StreamTest.simpleList   avgt   30   38.241 ±  0.434  us/op
StreamTest.streamList   avgt   30  215.425 ± 32.871  us/op

这是微秒。所以 Stream 版本实际上比你的测试快得多。然而，简单版本甚至更快。因此，如果您对 15 毫秒感到满意，您可以使用您喜欢的这两个版本中的任何一个:两者都会执行得更快。

如果你想获得尽可能最好的性能，无论如何，你应该摆脱装箱的Integer对象并使用原始数组:

int[] b = new Random().ints(40000, 0, 40000).toArray();

@Benchmark
public int streamArray() {
    return Arrays.stream(b).max().orElse(Integer.MIN_VALUE);
}

@Benchmark
public int simpleArray() {
    int e = b.length;
    int m = Integer.MIN_VALUE;
    for(int i=0; i < e; i++) 
        if(b[i] > m) m = b[i];
    return m;
}

两个版本现在都更快:

Benchmark               Mode  Cnt    Score    Error  Units
StreamTest.simpleArray  avgt   30   10.132 ±  0.193  us/op
StreamTest.streamArray  avgt   30  167.435 ±  1.155  us/op

实际上，流版本的结果可能会有很大差异，因为它涉及到许多中间方法，这些方法是在不同时间进行 JIT 编译的，因此经过几次迭代后，速度可能会向任何方向发生变化。

顺便说一句，您原来的问题可以通过良好的旧 Collections.max 方法来解决，无需 Stream API，如下所示:

Integer max = Collections.max(a);

一般来说，您应该避免测试不能解决实际问题的人工代码。使用人工代码，您将获得人工结果，这些结果通常与真实条件下的 API 性能无关。