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

您正在比较语言＆＃34;增强型用于＆＃34;使用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循环的理由。编写最清晰且最有意义的代码。如果您正在编写性能关键代码，请对其进不同的表单将具有不同的性能，具体取决于工作负载，正在遍历的数据结构等。

Answer 2

使用旧版本的一个显而易见的原因是，您将与Java 7兼容。如果您的代码使用了许多新的Java 8好东西，这不是一个选项，但如果您只使用一些新功能，这可能是一个优点，特别是如果您的代码在通用库中。

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

2 个答案: