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

performance coding-style java

2022-08-31 06:06:14

假设我有一个数组列表

ArrayList<MyClass> myList;

而且我想打电话给Array，有没有性能原因要使用

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

多

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

?

我更喜欢第二种样式，因为它不那么冗长，并且我认为编译器将确保不会真正创建空数组，但我一直在怀疑这是否属实。

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

答案 1

与直觉相反，在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编译器包含几个优化，使其能够以较低的成本创建和初始化一个正确大小的新数组，如果您自己创建数组，则无法使用这些优化。

答案 2

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

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