在 Java 流的性能方面哪个更好：组合过滤器或组合环境？ [复制]

Question

需要过滤适合其字段的某些情况的所有对象。 假设对象有几个字段：

class Price {
int first;
int second; 
String third; 
}

和价格流：

Stream<Price> streamPrices; 

什么是最好的选择：

1.

streamPrices
    .parallel()
    .filter(p0->p0.first> 10)
    .filter(p1->p1.second <30)
    .filter(p2-> p2.third.length() > 8);

2.

streamPrices
   .parallel()
   .filter(p-> (p.first > 10) 
      && (p->p.second <30) 
      && (p-> p.third.length() > 8)
    );

我使用了 JMH 框架，但没有得出明确的结论。

Answer 1

不用担心性能，毕竟过早的优化是万恶之源。它通常远没有精心设计的可读且易于维护的代码那么重要。

衡量性能很棘手，尤其是在涉及streams 时。例如，对于较小的列表，您可能会发现 parallel 比 sequential 慢，因为线程的开销超过了收益。您还会发现 streams 通常比传统的 iterators 效率低，因为流是编译器将其转换为对象和方法调用的语法糖。

话虽如此，差异是如此微不足道，以至于根本不值得考虑。

Answer 2

使用您的价格等级进行测量，其中第一个过滤器去除 50%，第二个过滤器去除下一个 50%，第三个过滤器去除 50%，结果表明方法 2 所需的时间是方法 1 的一半多一点。

编辑：按照 Lino 在 cmets 中的建议改进了数字，略微减少了数字，但方法 1 总体减少了 50%。

方法 1：118 毫秒 / 10000000 项

平均：118 毫秒，最小：107 毫秒，最大：252 毫秒

方法 2：79 毫秒 / 10000000 项

平均：79 毫秒，最小：70 毫秒，最大：91 毫秒

因此，方法 2 的性能肯定更高，但在我的计算机上实际差异小于 40 毫秒/1000 万个项目，因此除非您使用非常大的集合，否则它可以忽略不计。

我个人更喜欢方法 1，因为它更易于阅读。如果您从另一个函数传递谓词，方法 2 会很有用。

public class FilterTest extends Test {
int i = 10000000;
Random random = new Random(i);
List<Price> prices;

public void setup() {
    prices = Stream.generate(new Supplier<Price>() {
        @Override
        public Price get() {
            return new Price(random);
        }
    }).limit(i).collect(Collectors.toList());
}

@Override
public void run() {
    // Method 1
    // prices.stream().parallel()
    //     .filter(p -> p.v1 > 0.5d)
    //     .filter(p -> p.v2 > 0.5d)
    //     .filter(p -> p.s.length() > 16)
    //     .collect(Collectors.toList());

    // Method 2
    prices.stream().parallel()
            .filter(p -> p.v1 > 0.5d && p.v2 > 0.5 && p.s.length() > 16)
            .collect(Collectors.toList());
}

public static class Price {
    double v1, v2;
    String s;

    public Price(Random random) {
        this.v1 = random.nextDouble();
        this.v2 = random.nextDouble();
        this.s = UUID.randomUUID().toString().substring(0,(int)(32*random.nextDouble()));
    }
}
}