假设我有一个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]);
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]);
}
}
toArray 多60%至100%（大小越小，相对开销越大）。 - assyliasMyClass[] 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;
}
new Myclass[0]更快：https://shipilev.net/blog/2016/arrays-wisdom-ancients/ - Karol Sc.toArray(new String[c.size()])
2. 空数组，例如 c.toArray(new String[0])
在旧版本的Java中，推荐使用预设大小的数组，因为创建正确大小的数组需要使用反射调用，速度较慢。size 和 toArray 调用之间可能存在数据竞争。如果在操作期间集合被同时缩小，可能会在数组末尾产生额外的 null 值。现代的JVM在反射数组构造方面进行了优化，因此性能差异非常小。在这种样板代码中两次命名集合并不是一个好主意，因此我会避免使用第一种方法。第二种方法的另一个优点是它可以与同步和并发集合一起使用。如果想要进行优化，可以重用空数组（空数组是不可变的，可以共享），或使用分析工具（！）。
private static final MyClass [] EMPTY_MY_CLASS_ARRAY = new MyClass [0]的参数并不能防止通过反射构造返回的数组，但它确实可以防止每次都构造一个额外的数组。 - Michael ScheperMyClass[] arr = myList.stream().toArray(MyClass[]::new);
这会对同步和并发集合有帮助还是有害？为什么？谢谢。 - Pimp Trizkit.stream().toArray(MyClass[]::new)时，您会失去同步，并且必须手动同步。在并发集合的情况下，这并不重要，因为两种toArray方法都是弱一致的。无论哪种情况，直接在集合上调用toArray(new MyClass[0])可能会更快。 （考虑到问题后引入的API，即JDK 11+，直接在集合上调用.toArray(MyClass[]::new)只是委托给.toArray(new MyClass[0])，因为那已经是最好的方法了。） - HolgertoArray检查传递的数组是否具有正确的大小（即足够大以容纳列表中的元素），如果是，则使用该数组。因此，如果提供的数组大小小于所需大小，则会自反地创建一个新数组。
在您的情况下，大小为零的数组是不可变的，因此可以安全地将其提升为静态final变量，这可能使您的代码更清晰，避免在每次调用时创建数组。无论如何，在方法内部都将创建一个新数组，因此这是一种可读性优化。
可以说，更快的版本是传递正确大小的数组，但除非您可以证明此代码是性能瓶颈，否则应优先考虑可读性而非运行时性能。
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'进行的优化。
那么，对于您的问题，主要是风格问题，但出于一致性考虑，应该成为您遵循的任何编码标准的一部分（无论是否记录）。