我应该如何用溪流来总结一下？
[英]How should I sum something with streams?
问题描述
我已经看过并尝试过如何在流中对某些内容求和的不同实现。 这是我的代码：
List<Person> persons = new ArrayList<Person>();
for(int i=0; i < 10000000; i++){
persons.add(new Person("random", 26));
}
Long start = System.currentTimeMillis();
int test = persons.stream().collect(Collectors.summingInt(p -> p.getAge()));
Long end = System.currentTimeMillis();
System.out.println("Sum of ages = " + test + " and it took : " + (end - start) + " ms with collectors");
Long start3 = System.currentTimeMillis();
int test3 = persons.parallelStream().collect(Collectors.summingInt(p -> p.getAge()));
Long end3 = System.currentTimeMillis();
System.out.println("Sum of ages = " + test3 + " and it took : " + (end3 - start3) + " ms with collectors and parallel stream");
Long start2 = System.currentTimeMillis();
int test2 = persons.stream().mapToInt(p -> p.getAge()).sum();
Long end2 = System.currentTimeMillis();
System.out.println("Sum of ages = " + test2 + " and it took : " + (end2 - start2) + " ms with map and sum");
Long start4 = System.currentTimeMillis();
int test4 = persons.parallelStream().mapToInt(p -> p.getAge()).sum();
Long end4 = System.currentTimeMillis();
System.out.println("Sum of ages = " + test4 + " and it took : " + (end4 - start4) + " ms with map and sum and parallel stream");
这给了我以下结果：
Sum of ages = 220000000 and it took : 110 ms with collectors
Sum of ages = 220000000 and it took : 272 ms with collectors and parallel stream
Sum of ages = 220000000 and it took : 137 ms with map and sum
Sum of ages = 220000000 and it took : 134 ms with map and sum and parallel stream
我尝试了几次并且每次给我不同的结果（大多数时候最后的解决方案是最好的），所以我想知道：
1）正确的方法是什么？
2）为什么？ （与其他解决方案有什么区别？）
1 个解决方案
解决方案1
11 已采纳 2014-08-14 22:35:36
在我们进入实际答案之前，您应该了解一些事项：
您的测试结果可能会有很大差异，具体取决于许多因素（例如您运行它的计算机）。 以下是我的8核机器上运行的结果：
Sum of ages = 260000000 and it took : 94 ms with collectors Sum of ages = 260000000 and it took : 61 ms with collectors and parallel stream Sum of ages = 260000000 and it took : 70 ms with map and sum Sum of ages = 260000000 and it took : 94 ms with map and sum and parallel stream然后在以后的运行中：
Sum of ages = 260000000 and it took : 68 ms with collectors Sum of ages = 260000000 and it took : 67 ms with collectors and parallel stream Sum of ages = 260000000 and it took : 66 ms with map and sum Sum of ages = 260000000 and it took : 109 ms with map and sum and parallel stream微基准测试不是一个简单的主题。 有方法可以做到这一点（稍后我会介绍一些），但在大多数情况下，只是尝试使用
System.currentTimeMillies()将无法可靠地工作。仅仅因为Java 8使并行操作变得容易，这并不意味着它们应该在任何地方使用。 并行操作在某些情况下有意义，在其他情况下则不然。
好的，现在让我们来看看你正在使用的各种方法。
顺序收集器：您使用的
summingInt收集器具有以下实现：public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper) { return new CollectorImpl<>( () -> new int[1], (a, t) -> { a[0] += mapper.applyAsInt(t); }, (a, b) -> { a[0] += b[0]; return a; }, a -> a[0], Collections.emptySet()); }因此，首先将创建一个包含一个元素的新数组。 然后，对于流中的每个
Person元素，collect函数将使用Person#getAge()函数将age作为Integer（而不是int！）检索，并将该age添加到之前的（在1D-array中）。 最后，当处理完整个流时，它将从该数组中提取值并返回它。 所以，这里有很多自动装箱和装箱。- 并行收集器：它使用
ReferencePipeline#forEach(Consumer)函数来累积从映射函数获得的年龄。 再次有很多自动装箱和-unboxing。 顺序映射和求和：在此将
Stream<Person>映射到IntStream。 这意味着一件事就是不再需要自动装箱或装箱了; 在某些情况下，这可以节省大量时间。 然后使用以下实现对结果流求和：@Override public final int sum() { return reduce(0, Integer::sum); }这里的
reduce函数将调用ReduceOps#ReduceOp#evaluateSequential(PipelineHelper<T> helper, Spliterator<P_IN> spliterator)。 实质上，这将对所有数字使用Integer::sum函数，从0开始，第一个数字，然后是第二个数字的结果，依此类推。- 并行映射和求和：这里的事情变得有趣。 它使用相同的
sum()函数，但是在这种情况下，reduce将调用ReduceOps#ReduceOp#evaluateParallel(PipelineHelper<T> helper, Spliterator<P_IN> spliterator)而不是顺序选项。 这将基本上使用分而治之的方法来累加值。 现在，分而治之的巨大优势当然是它可以很容易地并行完成。 但是，它确实需要多次拆分和重新连接流，这需要花费时间。 因此它的速度变化很大，取决于它与元素有关的实际任务的复杂性。 在添加的情况下，在大多数情况下可能不值得; 正如你从我的结果中看到的那样，它总是一种较慢的方法。
现在，为了真正了解所需的时间，让我们做一个适当的微观基准测试。 我将使用JMH以下基准代码：
package com.stackoverflow.user2352924;
import org.openjdk.jmh.annotations.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MINUTES)
@Warmup(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 10, timeUnit = TimeUnit.SECONDS)
@State(Scope.Benchmark)
@Fork(1)
@Threads(2)
public class MicroBenchmark {
private static List<Person> persons = new ArrayList<>();
private int test;
static {
for(int i=0; i < 10000000; i++){
persons.add(new Person("random", 26));
}
}
@Benchmark
public void sequentialCollectors() {
test = 0;
test += persons.stream().collect(Collectors.summingInt(p -> p.getAge()));
}
@Benchmark
public void parallelCollectors() {
test = 0;
test += persons.parallelStream().collect(Collectors.summingInt(p -> p.getAge()));
}
@Benchmark
public void sequentialMapSum() {
test = 0;
test += persons.stream().mapToInt(p -> p.getAge()).sum();
}
@Benchmark
public void parallelMapSum() {
test = 0;
test += persons.parallelStream().mapToInt(p -> p.getAge()).sum();
}
}
这个maven项目的pom.xml如下所示：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.stackoverflow.user2352924</groupId>
<artifactId>StackOverflow</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<name>Auto-generated JMH benchmark</name>
<prerequisites>
<maven>3.0</maven>
</prerequisites>
<dependencies>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>${jmh.version}</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>${jmh.version}</version>
<scope>provided</scope>
</dependency>
</dependencies>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<jmh.version>0.9.5</jmh.version>
<javac.target>1.8</javac.target>
<uberjar.name>benchmarks</uberjar.name>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<compilerVersion>${javac.target}</compilerVersion>
<source>${javac.target}</source>
<target>${javac.target}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.2</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<finalName>microbenchmarks</finalName>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>org.openjdk.jmh.Main</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>2.5</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.1</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.1</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>2.4</version>
</plugin>
<plugin>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.9.1</version>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>2.6</version>
</plugin>
<plugin>
<artifactId>maven-site-plugin</artifactId>
<version>3.3</version>
</plugin>
<plugin>
<artifactId>maven-source-plugin</artifactId>
<version>2.2.1</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.17</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
确保Maven也在运行Java 8，否则你会遇到难看的错误。
我不会在这里详细介绍如何使用JMH（还有其他地方可以这样做），但这是我得到的结果：
# Run complete. Total time: 00:08:48
Benchmark Mode Samples Score Score error Units
c.s.u.MicroBenchmark.parallelCollectors thrpt 10 3658,949 775,115 ops/min
c.s.u.MicroBenchmark.parallelMapSum thrpt 10 2616,905 221,109 ops/min
c.s.u.MicroBenchmark.sequentialCollectors thrpt 10 5502,160 439,024 ops/min
c.s.u.MicroBenchmark.sequentialMapSum thrpt 10 6120,162 609,232 ops/min
因此，在我运行这些测试的系统上，顺序映射总和相当快，在并行映射总和（使用分而治之的方法）设法仅执行超过2600时，管理超过6100次操作事实上，顺序方法都比并行方法快得多。
现在，在一个可以更容易并行运行的情况下 - 例如， Person#getAge()函数比只是一个getter复杂得多 - 并行方法可能是一个更好的解决方案。 最后，这一切都取决于被测试案例中并行运行的效率。
另一件需要记住的事情是：如果有疑问，请做一个适当的微观基准。 ;-)
我应该如何正确使用 @GetMapping 来创建 /something/{id}/something/{id2} 路径？
[英]how should I use @GetMapping properly to create a /something/{id}/something/{id2} path?
如何使用 java8 流创建与以下逻辑等效的内容？
[英]How to create something equivalent to the following logic using java8 streams?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.