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

Posted 2023-02-25

【中文标题】.toArray(new MyClass[0]) 还是 .toArray(new MyClass[myList.size()])？

【英文标题】：.toArray(new MyClass[0]) or .toArray(new MyClass[myList.size()])?

【发布时间】：2010-09-15 12:04:42

【问题描述】：

假设我有一个 ArrayList

ArrayList<MyClass> myList;

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

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

结束

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

?

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

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

【问题讨论】：

看起来这个问题已经在 Aleksey Shipilёv 的新博文中得到了解决，Arrays of Wisdom of the Ancients！

来自博文：“底线：toArray(new T[0]) 似乎更快、更安全、合同更简洁，因此现在应该是默认选择。”

【参考方案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 编译器包含一些优化，使其能够廉价地创建和初始化一个新的大小正确的数组，如果您自己创建数组，则无法使用这些优化。

【讨论】：

非常有趣的评论。我很惊讶没有人对此发表评论。我想这是因为它与这里的其他答案相矛盾，就速度而言。还值得注意的是，这个家伙的声誉几乎高于所有其他答案（ers）的总和。

我离题了。我还想查看MyClass[] arr = myList.stream().toArray(MyClass[]::new); 的基准测试。我想这会慢一些。另外，我想看看与数组声明的差异的基准。如：MyClass[] arr = new MyClass[myList.size()]; arr = myList.toArray(arr); 和 MyClass[] arr = myList.toArray(new MyClass[myList.size()]); 之间的区别......或者应该没有任何区别？我猜这两个是toArray 函数发生之外的问题。但是，嘿！我不认为我会了解其他错综复杂的差异。

@PimpTrizkit 刚刚检查过：使用额外的变量不会产生预期的影响，使用流比直接调用 toArray 需要多 60% 到 100% 的时间（大小越小，相对开销）

在这里发现了同样的结论：shipilev.net/blog/2016/arrays-wisdom-ancients

@xenoterracide 如上面 cmets 中所述，流速度较慢。

【参考方案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;

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

【讨论】：

两个 cmets，可能有人感兴趣：1) LinkedList.toArray(T[] a) 更慢（使用反射：Array.newInstance）并且更复杂; 2) 另一方面，在 JDK7 版本中，我很惊讶地发现，通常非常缓慢的 Array.newInstance 执行速度几乎与通常的数组创建一样快！

@ktaria size 是 ArrayList 的私有成员，指定 ****suprise**** 的大小。见ArrayList SourceCode

在没有基准的情况下猜测性能仅适用于微不足道的情况。实际上，new Myclass[0] 更快：shipilev.net/blog/2016/arrays-wisdom-ancients

从 JDK6+ 开始，这不再是有效的答案

【参考方案3】：

来自 JetBrains Intellij Idea 检查：

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

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

此检查允许遵循 统一样式：使用空数组（推荐在 现代 Java）或使用预先确定大小的数组（在 较旧的 Java 版本或非基于 HotSpot 的 JVM）。

【讨论】：

如果所有这些都是复制/引用的文本，我们可以相应地对其进行格式化并提供源链接吗？我实际上是因为 IntelliJ 检查而来到这里的，我对查看他们所有检查及其背后原因的链接非常感兴趣。

在这里您可以查看检查文本：github.com/JetBrains/intellij-community/tree/master/plugins/…

github.com/JetBrains/intellij-community/blob/master/plugins/…

【参考方案4】：

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

【讨论】：

赞成“重用空数组”，因为这是值得考虑的可读性和潜在性能之间的折衷。传递声明为 private static final MyClass[] EMPTY_MY_CLASS_ARRAY = new MyClass[0] 的参数不会阻止通过反射构造返回的数组，但它确实会阻止每次都构造一个额外的数组。

Machael 是对的，如果你使用 零长度数组 就没有办法了： (T[])java.lang.reflect.Array.newInstance(a. getClass().getComponentType(), 大小);如果大小 >= actualSize (JDK7)

，这将是多余的

如果您可以引用“现代 JVM 在这种情况下优化反射数组构造”，我会很乐意为这个答案投票。

我在这里学习。如果我改为使用：MyClass[] arr = myList.stream().toArray(MyClass[]::new); 对同步和并发集合有帮助还是有伤害。为什么？请。

【参考方案5】：

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

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

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

【参考方案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;

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

【讨论】：

toArray() 不使用反射。至少只要您不将“投射”计入反射，无论如何;-)。

toArray(T[]) 可以。它需要创建一个适当类型的数组。现代 JVM 将这种反射优化为与非反射版本大致相同的速度。

我认为它确实使用了反射。 JDK 1.5.0_10 确实可以，反射是我知道的唯一方法来创建一个你在编译时不知道的类型的数组。

那么她的源代码示例之一（上面的或我的）已经过时了。遗憾的是，我没有找到正确的子版本号。

Georgi，您的代码来自 JDK 1.6，如果您看到 Arrays.copyTo 方法的实现，您将看到该实现使用反射。

【参考方案7】：

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

【参考方案8】：

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

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

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

【讨论】：

OTOH，如果标准是使用零长度数组，那么偏离的情况意味着性能是一个问题。

【参考方案9】：

整数示例代码：

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