java - IntelliJ IDEA 建议用 foreach 方法替换 for 循环。我应该尽可能这样做吗？

Question

IDEA 建议替换，例如，这个:

for (Point2D vertex : graph.vertexSet()) {
  union.addVertex(vertex);
}

用这个:

graph.vertexSet().forEach(union::addVertex);

这个新版本肯定更具可读性。但是，在某些情况下，我最好坚持用于可迭代对象的良好旧语言构造，而不是使用新的 foreach 方法？

例如，如果我理解正确的话，方法引用机制意味着构造一个匿名的 Consumer 对象，否则(使用 for 语言构造)将不会被构造。这会成为某些操作的性能瓶颈吗？

所以我写了这个不是很详尽的基准:

package org.sample;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.infra.Blackhole;
import org.tendiwa.geometry.Point2D;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class LanguageConstructVsForeach {
    private static final int NUMBER_OF_POINTS = 10000;
    private static final List<Point2D> points = IntStream
        .range(0, NUMBER_OF_POINTS)
        .mapToObj(i -> new Point2D(i, i * 2))
        .collect(Collectors.toList());

    @Benchmark
    @Threads(1)
    @Fork(3)
    public void languageConstructToBlackhole(Blackhole bh) {
        for (Point2D point : points) {
            bh.consume(point);
        }
    }
    @Benchmark
    @Threads(1)
    @Fork(3)
    public void foreachToBlackhole(Blackhole bh) {
        points.forEach(bh::consume);
    }
    @Benchmark
    @Threads(1)
    @Fork(3)
    public List<Point2D> languageConstructToList(Blackhole bh) {
        List<Point2D> list = new ArrayList<>(NUMBER_OF_POINTS);
        for (Point2D point : points) {
            list.add(point);
        }
        return list;
    }
    @Benchmark
    @Threads(1)
    @Fork(3)
    public List<Point2D> foreachToList(Blackhole bh) {
        List<Point2D> list = new ArrayList<>(NUMBER_OF_POINTS);
        points.forEach(list::add);
        return list;
    }

}

并得到:

Benchmark                                                       Mode  Samples      Score     Error  Units
o.s.LanguageConstructVsForeach.foreachToBlackhole              thrpt       60  33693.834 ± 894.138  ops/s
o.s.LanguageConstructVsForeach.foreachToList                   thrpt       60   7753.941 ± 239.081  ops/s
o.s.LanguageConstructVsForeach.languageConstructToBlackhole    thrpt       60  16043.548 ± 644.432  ops/s
o.s.LanguageConstructVsForeach.languageConstructToList         thrpt       60   6499.527 ± 202.589  ops/s

为什么 foreach 在这两种情况下都更有效率:当我几乎什么都不做时，当我做一些实际工作时？ foreach不就是简单封装了Iterator吗？这个基准是否正确？如果是，今天是否有任何理由在 Java 8 中使用旧语言结构？

Answer 1

您正在将语言的“增强型”循环与 Iterable.forEach() 进行比较方法。基准测试并没有明显错误，而且在您深入研究实现之前，结果可能看起来令人惊讶。

请注意，points 列表是 ArrayList 的一个实例，因为它是由 Collectors.toList() 收集器创建的。

Iterable 上的增强型 for 循环从中获取一个 Iterator，然后调用 hasNext() 和 next() 重复，直到没有更多的元素。 (这不同于数组上的增强型 for 循环，它执行算术和直接数组元素访问。)因此，当循环遍历 Iterable 时，此循环将在每次迭代中执行至少两次方法调用.

相比之下，调用 ArrayList.forEach() 在包含列表元素的数组上运行一个传统的、基于 int 的 for 循环，并在每次迭代中调用一次 lambda。这里每次迭代只有一次调用，而增强型 for 循环每次迭代调用两次。这或许可以解释为什么 ArrayList.forEach() 在这种情况下更快。

黑洞案例似乎除了运行循环之外几乎没有做任何工作，所以这些案例似乎是在测量纯粹的循环开销。这可能就是为什么 ArrayList.forEach() 在这里显示出如此大的优势。

当循环只做一点点工作(添加到目标列表)时，ArrayList.forEach() 仍然有速度优势，但差异要小得多。我怀疑如果你在循环内做更多的工作，优势会更小。这表明任一构造的循环开销都非常小。尝试在循环中使用 BlackHole.consumeCPU()。如果两种构造之间的结果变得无法区分，我不会感到惊讶。

请注意，由于 Iterable.forEach() 最终在 ArrayList.forEach() 中有一个专门的实现，因此会出现巨大的速度优势。如果您对不同的数据结构运行 forEach()，您可能会得到不同的结果。

我不会以此为理由用调用 Iterable.forEach() 来盲目替换所有增强型 for 循环。编写最清晰、最有意义的代码。如果您正在编写性能关键代码，请对其进行基准测试!不同的表单会有不同的性能，这取决于工作负载、遍历的数据结构等。