.toArray(new MyClass [0])或.toArray(new MyClass [myList.size()])？

Question

假设我有一个ArrayList

ArrayList<MyClass> myList;

我想打电话给阿瑞,是否有使用性能的原因

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

过度

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

？

我更喜欢第二种风格,因为它不那么冗长,我认为编译器会确保空数组不会真正被创建,但我一直想知道这是不是真的.

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

Answer 1

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

使用第一种方法,以便只创建一个对象并避免(隐式但仍然很昂贵)铸件.

Answer 2

与直觉相反,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 the Ancients中找到类似的结果,完整的分析和讨论.总结一下:JVM和JIT编译器包含几个优化,使它能够廉价地创建和初始化一个新的正确大小的数组,如果你自己创建数组,则不能使用这些优化.

Answer 3

来自JetBrains Intellij Idea检查:

将集合转换为数组有两种样式:使用预先调整大小的数组(如c.toArray(new String [c.size()]))或使用空数组(如c.toArray(new String [ 0]).

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

此检查允许遵循统一样式:使用空数组(在现代Java中推荐)或使用预先调整大小的数组(在旧Java版本或基于非HotSpot的JVM中可能更快).

Answer 4

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