拆箱会减慢 Java 流的速度吗？

Question

我有以下课程：

public final class App {
    private App() {
    }

    public static void main(String[] args) {
        Stopwatch stopwatch = Stopwatch.createStarted();
        new App().main();
        System.out.println(((double) stopwatch.elapsed(TimeUnit.MICROSECONDS) * 1_000_000) + " seconds!");
    }

    private void main() {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 1000000; i++) {
            list.add(ThreadLocalRandom.current().nextInt(1000));
        }
        System.out.println(minNoUnboxing(list));
        System.out.println(minWithUnboxing(list));
    }

    private Integer minNoUnboxing(List<Integer> list) {
        return list.stream().min(Integer::compareTo).orElse(-1);
    }

    private Integer minWithUnboxing(List<Integer> list) {
        return list.stream().mapToInt(x -> x).min().orElse(-1);
    }
}

这个类有 2 个方法，它们接受一个整数列表并返回最小的数字。一种方法是在 min() 函数中将 Integer 的 compareTo() 方法作为比较器传递。另一种方法是从列表中获取一个 IntStream 并在其上调用 min() 函数。

第二种方法使用拆箱来映射包装的整数。拆箱以频繁使用时速度慢而闻名，但我看不出在这个程序中使用和不使用它的区别。

哪种方式更快？或者它们都一样？

谢谢。

编辑：

我接受了 Code-Apprentice 的建议，并使用这种方法进行了一系列测量：

    Stopwatch noUnboxing = Stopwatch.createStarted();
    for (int i = 0; i < 1000; i++) {
        minNoUnboxing(list);
    }
    System.out.println((double) noUnboxing.elapsed(TimeUnit.MILLISECONDS) / 1000 + " no unboxing seconds");

    Stopwatch withUnboxing = Stopwatch.createStarted();
    for (int i = 0; i < 1000; i++) {
        minWithUnboxing(list);
    }
    System.out.println((double) withUnboxing.elapsed(TimeUnit.MILLISECONDS) / 1000 + " with unboxing seconds");

事实证明，拆箱实际上比第一种方式快 2 倍。这是为什么呢？

输出：

4.166 no unboxing seconds
1.922 with unboxing seconds

Answer 1

拆箱无非就是读取Integer对象的int字段的值。这不会减慢操作速度，至于与其他变体中的Integer 实例相比，这些字段也必须读取。

因此，这些操作适用于不同的抽象。

当您使用mapToInt(x -> x) 时，您正在使用ToIntFunction 告诉实现如何获取int 值，然后，min 操作直接作用于int 值。

当您使用min(Integer::compareTo) 时，您使用Comparator 来告诉通用实现，哪个对象比另一个小。

基本上，这些操作等价于

private Optional<Integer> minNoUnboxing(List<Integer> list) {
    Comparator<Integer> c = Integer::compareTo;

    if(list.isEmpty()) return Optional.empty();
    Integer o = list.get(0);
    for(Integer next: list.subList(1, list.size())) {
        if(c.compare(o, next) > 0) o = next;
    }
    return Optional.of(o);
}

private OptionalInt minWithUnboxing(List<Integer> list) {
    ToIntFunction<Integer> toInt = x -> x;

    if(list.isEmpty()) return OptionalInt.empty();
    int i = toInt.applyAsInt(list.get(0));
    for(Integer next: list.subList(1, list.size())) {
        int nextInt = toInt.applyAsInt(next);
        if(i > nextInt) i = nextInt;
    }
    return OptionalInt.of(i);
}

除非运行时优化器消除所有差异，否则我希望拆箱版本对于较大的列表更快，因为拆箱会为每个元素提取一次 int 字段，而 compareTo 必须提取两个 @987654334 @ 每次比较的值。

Answer 2

性能影响几乎与拆箱无关，而与您正在比较两个根本不同的操作（使用比较器最小化与归约）这一事实有关。

查看这些基准：

@Benchmark
public Integer minNoUnboxing(BenchmarkState state) {
    return state.randomNumbers.stream().min(Integer::compareTo).orElse(-1);
}

@Benchmark
public Integer minNoUnboxingReduce(BenchmarkState state) {
    return state.randomNumbers.stream().reduce((a, b) -> a < b ? a : b).orElse(-1);
}

@Benchmark
public Integer minWithUnboxingReduce(BenchmarkState state) {
    return state.randomNumbers.stream().mapToInt(x -> x).min().orElse(-1);
}

结果：

Benchmark                          (listSize)   Mode  Cnt    Score    Error  Units
MyBenchmark.minNoUnboxing             1000000  thrpt    5  128.585 ± 17.617  ops/s
MyBenchmark.minNoUnboxingReduce       1000000  thrpt    5  317.772 ± 27.659  ops/s
MyBenchmark.minWithUnboxingReduce     1000000  thrpt    5  300.348 ± 23.458  ops/s

编辑：还请注意，与装箱相比，拆箱非常快。在最坏的情况下，拆箱只是一个字段访问/指针取消引用，而装箱可能涉及对象实例化。