.toArray（new MyClass [0]）或.toArray（new MyClass [myList.size（）]）？

假设我有一个ArrayList

ArrayList<MyClass> myList;

我想调用toArray，是否有使用性能的理由

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

过度

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

？

我更喜欢第二种样式，因为它不太冗长，并且我假设编译器将确保不会真正创建空数组，但是我一直在想那是否是真的。

当然，在99％的情况下，它不会以一种或另一种方式改变，但是我想在我的普通代码和优化的内部循环之间保持一致的样式...

违反直觉的是，在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]);
  }
}

您可以在博客文章古代智慧阵列中找到类似的结果，完整的分析和讨论。总结一下：JVM和JIT编译器包含一些优化，使其可以廉价地创建和初始化一个新的正确大小的数组，而如果您自己创建该数组，则不能使用这些优化。

从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;
}

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

通过JetBrains Intellij Idea检查：

有两种样式可以将集合转换为数组：使用预大小数组（如c.toArray（new String [c.size（）]））或使用空数组（如c.toArray（new String [ 0]）。

在较早的Java版本中，建议使用预先设置大小的数组，因为创建适当大小的数组所需的反射调用非常慢。但是，由于OpenJDK 6的更新较晚，因此此调用很吸引人，与空大小版本相比，空数组版本的性能相同，有时甚至更好。同样，传递预大小的数组对于并发或同步收集也是危险的，因为如果size和toArray 调用在操作过程中同时收缩，则在size和toArray调用之间可能会发生数据争用 ，这可能会在数组末尾产生额外的null。

此检查允许遵循统一的样式：使用空数组（在现代Java中建议使用）或使用预定大小的数组（在较早的Java版本或基于非HotSpot的JVM中可能更快）。

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

toArray检查所传递的数组的大小是否正确（即足够大以适合列表中的元素），如果是，则使用该数组。因此，如果提供的数组大小小于要求的大小，则会反身创建一个新的数组。

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

可以说，更快的版本是传递正确大小的数组，但除非可以证明此代码是性能瓶颈，否则除非可读性强，否则应优先考虑可读性而不是运行时性能。

第一种情况更有效。

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

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;
}

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

第二个是微乎其微的可读性，但是几乎没有什么改进是不值得的。第一种方法更快，在运行时没有缺点，所以这就是我使用的方法。但是我用第二种方式编写它，因为键入速度更快。然后，我的IDE会将其标记为警告，并提出对其进行修复。只需一次按键，它将代码从第二种类型转换为第一种类型。

将'toArray'与正确大小的数组一起使用会更好，因为替代方法将首先创建零大小的数组，然后创建正确大小的数组。但是，正如您所说，差异可能微不足道。

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

因此，问题的答案很大程度上取决于样式，但出于一致性的考虑，应成为您遵守的任何编码标准的一部分（无论是有文件证明的还是其他形式的证明）。

整数的示例代码：

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