Collection.toArray() 与 Collection.stream().toArray()

Question

考虑以下代码：

List<String> myList = Arrays.asList(1, 2, 3);
String[] myArray1 = myList.toArray(new String[myList.size()]);
String[] myArray2 = myList.stream().toArray(String[]::new);
assert Arrays.equals(myArray1, myArray2);

在我看来，使用流要简单得多。

因此，我测试了每一个的速度。

List<String> myList = Arrays.asList("1", "2", "3");
double start;

start = System.currentTimeMillis();
for (int i = 0; i < 10_000_000; i++) {
    String[] myArray1 = myList.toArray(new String[myList.size()]);
    assert myArray1.length == 3;
}
System.out.println(System.currentTimeMillis() - start);

start = System.currentTimeMillis();
for (int i = 0; i < 10_000_000; i++) {
    String[] myArray2 = myList.stream().toArray(String[]::new);
    assert myArray2.length == 3;
}
System.out.println(System.currentTimeMillis() - start);

结果是使用流大约慢了四倍。在我的机器上，816 毫秒（流）与 187 毫秒（无流）。我还尝试切换时间语句（myArray2 在 myArray1 之前），这对结果影响不大。为什么这么慢？创建Stream 的计算量这么大吗？

我听从了@Holger 的建议，对 JVM 测试进行了一些研究（当然还不够），阅读了this post、this article、this article，并使用了JMH。

---

结果（通过 JMH）：

private static final List<String> myList = IntStream.range(1, 1000).mapToObj(String::valueOf).collect(Collectors.toList());

@Benchmark
public void testMethod() {
    String[] myArray = myArrayList.stream().toArray(String[]::new);
}

StreamToArrayArrayListBenchmark.testMethod avgt 5 2846.346 ± 32.500 ns/op

private static final List<String> myList = IntStream.range(1, 1000).mapToObj(String::valueOf).collect(Collectors.toList());

@Benchmark
public void testMethod() {
    String[] myArray = myArrayList.toArray(new String[0]);
}

ToArrayEmptyArrayListBenchmark.testMethod avgt 5 1417.474 ± 20.725 ns/op

private static final List<String> myList = IntStream.range(1, 1000).mapToObj(String::valueOf).collect(Collectors.toList());

@Benchmark
public void testMethod() {
    String[] myArray = myArrayList.toArray(new String[myList.size()]);
}

ToArraySizedArrayListBenchmark.testMethod avgt 5 1853.622 ± 178.351 ns/op

---

private static final List<String> myList = new LinkedList<>(IntStream.range(1, 1000).mapToObj(String::valueOf).collect(Collectors.toList()));

@Benchmark
public void testMethod() {
    String[] myArray = myArrayList.stream().toArray(String[]::new);
}

StreamToArrayLinkedListBenchmark.testMethod avgt 5 4152.003 ± 59.281 ns/op

private static final List<String> myList = new LinkedList<>(IntStream.range(1, 1000).mapToObj(String::valueOf).collect(Collectors.toList()));

@Benchmark
public void testMethod() {
    String[] myArray = myArrayList.toArray(new String[0]);
}

ToArrayEmptyLinkedListBenchmark.testMethod avgt 5 4089.550 ± 29.880 ns/op

private static final List<String> myList = new LinkedList<>(IntStream.range(1, 1000).mapToObj(String::valueOf).collect(Collectors.toList()));

@Benchmark
public void testMethod() {
    String[] myArray = myArrayList.toArray(new String[myList.size()]);
}

ToArraySizedArrayListBenchmark.testMethod avgt 5 4115.557 ± 93.964 ns/op

---

总结一下：

              | ArrayList | LinkedList
stream        | 2846      | 4152
toArray sized | 1853      | 4115
toArray empty | 1417      | 4089

---

使用 JMH（可能很天真），我仍然看到 ArrayList::toArray 的速度大约是 Stream::toArray 的两倍。然而，这似乎是因为ArrayList 能够只进行数组复制，正如@Andreas 指出的那样，因为当源是LinkedList 时，结果大致相同。

很高兴知道myList.toArray(new String[0])。

Answer 1

Arrays.asList() 创建一个固定大小的List，它直接由可变参数数组参数支持。 Javadoc 甚至这样说：

返回由指定数组支持的固定大小的列表。

toArray() 的实现是一个简单的System.arraycopy()。 非常快。

另一方面，当您执行myList.stream().toArray(String[]::new) 时，大小是未知的，因此Stream.toArray() 方法必须消耗流，收集所有值，然后创建数组并将值复制到数组中。这会慢很多，并且需要很多更多的内存。

总之就是浪费资源。

如果你想要更简单，就不要给出数组大小。它仍然比使用 Streams 更快且占用更少的内存：

String[] myArray1 = myList.toArray(new String[0]);

Answer 2

在底层，流比普通数组复杂得多。编译器会变得更好，但目前，顺序 for 循环应该比流操作更快。

This article 有一些关于流管道的背景知识，这些管道用于实现流。它有助于理解其背后的复杂性。

流的优点是代码可以更清晰，更容易并行化。