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

Question

假设我有一个 ArrayList

ArrayList<MyClass> myList;

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

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

结束

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

?

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

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

Answer 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]);
  }
}

---

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

Answer 2

从ArrayList in Java 5 开始，如果数组大小合适（或更大），则数组将被填充。结果

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

Answer 5

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

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

可以说，更快的版本是传递正确大小的数组，但除非您能够证明此代码是性能瓶颈，否则在证明其他情况之前，优先考虑可读性而不是运行时性能。

Answer 6

第一种情况效率更高。

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

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

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

Answer 7

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

Answer 8

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

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

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

Answer 9

整数示例代码：

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