205

假设我有一个 ArrayList

ArrayList<MyClass> myList;

我想调用toArray，是否有性能原因使用

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

超过

MyClass[] arr = myList.toArray(new MyClass[0]);

?

我更喜欢第二种风格，因为它不那么冗长，而且我假设编译器会确保不会真正创建空数组，但我一直想知道这是不是真的。

当然，在 99% 的情况下，它不会以某种方式产生影响，但我想在我的正常代码和优化的内部循环之间保持一致的风格......

4

9 回答 9

139

与直觉相反，Hotspot 8 上最快的版本是：

MyClass[] arr = myList.toArray(new MyClass[0]);

我已经使用 jmh 运行了一个微型基准测试，结果和代码如下，表明具有空数组的版本始终优于具有预定义数组的版本。请注意，如果您可以重用正确大小的现有数组，结果可能会有所不同。

基准测试结果（分数以微秒为单位，更小 = 更好）：

Benchmark                      (n)  Mode  Samples    Score   Error  Units
c.a.p.SO29378922.preSize         1  avgt       30    0.025 ▒ 0.001  us/op
c.a.p.SO29378922.preSize       100  avgt       30    0.155 ▒ 0.004  us/op
c.a.p.SO29378922.preSize      1000  avgt       30    1.512 ▒ 0.031  us/op
c.a.p.SO29378922.preSize      5000  avgt       30    6.884 ▒ 0.130  us/op
c.a.p.SO29378922.preSize     10000  avgt       30   13.147 ▒ 0.199  us/op
c.a.p.SO29378922.preSize    100000  avgt       30  159.977 ▒ 5.292  us/op
c.a.p.SO29378922.resize          1  avgt       30    0.019 ▒ 0.000  us/op
c.a.p.SO29378922.resize        100  avgt       30    0.133 ▒ 0.003  us/op
c.a.p.SO29378922.resize       1000  avgt       30    1.075 ▒ 0.022  us/op
c.a.p.SO29378922.resize       5000  avgt       30    5.318 ▒ 0.121  us/op
c.a.p.SO29378922.resize      10000  avgt       30   10.652 ▒ 0.227  us/op
c.a.p.SO29378922.resize     100000  avgt       30  139.692 ▒ 8.957  us/op

供参考，代码：

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
public class SO29378922 {
  @Param({"1", "100", "1000", "5000", "10000", "100000"}) int n;
  private final List<Integer> list = new ArrayList<>();
  @Setup public void populateList() {
    for (int i = 0; i < n; i++) list.add(0);
  }
  @Benchmark public Integer[] preSize() {
    return list.toArray(new Integer[n]);
  }
  @Benchmark public Integer[] resize() {
    return list.toArray(new Integer[0]);
  }
}

您可以在博文 Arrays of Wisdom of the Ancients中找到类似的结果、完整的分析和讨论。总结一下：JVM 和 JIT 编译器包含一些优化，使其能够廉价地创建和初始化一个新的大小正确的数组，如果您自己创建数组，则无法使用这些优化。

于 2015-04-04T09:05:26.537 回答
122

从Java 5 中的 ArrayList开始，如果数组具有正确的大小（或更大），它将已经被填充。最后

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

将创建一个数组对象，填充它并将其返回给“arr”。另一方面

MyClass[] arr = myList.toArray(new MyClass[0]);

将创建两个数组。第二个是长度为 0 的 MyClass 数组。因此，会为将立即丢弃的对象创建对象。就源代码而言，编译器/JIT 无法优化这个，因此它不会被创建。此外，使用零长度对象会导致在 toArray() - 方法中进行强制转换。

查看 ArrayList.toArray() 的来源：

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

使用第一种方法，以便只创建一个对象并避免（隐式但昂贵的）强制转换。

于 2008-10-06T12:57:28.773 回答
38

来自 JetBrains Intellij Idea 检查：

将集合转换为数组有两种方式：使用预先确定大小的数组（如c.toArray(new String[c.size()])或使用空数组（如c.toArray(new String[ 0])。

在较旧的 Java 版本中，建议使用预先确定大小的数组，因为创建适当大小的数组所必需的反射调用非常慢。然而，由于 OpenJDK 6 的更新较晚，这个调用被内化了，使得空数组版本的性能与预先调整大小的版本相同，有时甚至更好。此外，传递预先确定大小的数组对于并发或同步集合也是危险的，因为在 size和toArray 调用之间可能存在数据竞争，如果在操作期间集合同时收缩，这可能会导致数组末尾出现额外的空值。

This inspection allows to follow the uniform style: either using an empty array (which is recommended in modern Java) or using a pre-sized array (which might be faster in older Java versions or non-HotSpot based JVMs).

于 2018-06-07T09:41:52.163 回答
17

现代 JVM 在这种情况下优化了反射数组的构造，因此性能差异很小。在这样的样板代码中将集合命名两次并不是一个好主意，所以我会避免使用第一种方法。第二个的另一个优点是它适用于同步和并发集合。如果要进行优化，请重用空数组（空数组是不可变的并且可以共享），或者使用分析器（！）。

于 2008-10-06T13:17:25.830 回答
3

toArray 检查传递的数组的大小是否正确（即，大到足以容纳列表中的元素），如果是，则使用它。因此，如果数组的大小比要求的小，则将自反地创建一个新数组。

在您的情况下，大小为零的数组是不可变的，因此可以安全地提升为静态最终变量，这可能会使您的代码更简洁，从而避免在每次调用时创建数组。无论如何，都会在方法内部创建一个新数组，因此这是一个可读性优化。

可以说，更快的版本是传递正确大小的数组，但除非您能证明此代码是性能瓶颈，否则在证明并非如此之前，更喜欢可读性而不是运行时性能。

于 2008-10-06T12:46:40.103 回答
2

第一种情况效率更高。

那是因为在第二种情况下：

MyClass[] arr = myList.toArray(new MyClass[0]);

运行时实际上创建了一个空数组（大小为零），然后在 toArray 方法中创建另一个数组以适应实际数据。使用以下代码（取自 jdk1.5.0_10）使用反射完成此创建：

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.
    newInstance(a.getClass().getComponentType(), size);
System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

通过使用第一种形式，您可以避免创建第二个数组，也可以避免反射代码。

于 2008-10-06T12:44:46.393 回答
-1

第二个可读性稍强，但改进很小，不值得。第一种方法更快，在运行时没有缺点，所以这就是我使用的。但我是用第二种方式写的，因为这样打字更快。然后我的 IDE 将其标记为警告并提供修复它。只需一次击键，它将代码从第二种类型转换为第一种。

于 2013-08-20T00:36:42.027 回答
-2

将“toArray”与正确大小的数组一起使用会更好，因为替代方案将首先创建零大小的数组，然后创建正确大小的数组。但是，正如您所说，差异可能可以忽略不计。

另外，请注意 javac 编译器不执行任何优化。如今，所有优化都是由 JIT/HotSpot 编译器在运行时执行的。我不知道任何 JVM 中围绕“toArray”的任何优化。

那么，您的问题的答案主要是风格问题，但为了保持一致性，应该成为您遵守的任何编码标准的一部分（无论是记录还是其他）。

于 2008-10-06T12:43:58.847 回答
-4

整数示例代码：

Integer[] arr = myList.toArray(new integer[0]);
于 2013-08-03T10:21:47.523 回答