.toArray(new MyClass[0]) or .toArray(new MyClass[myList.size()])?

问题:

Assuming I have an ArrayList

ArrayList myList; 

And I want to call toArray, is there a performance reason to use

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

over

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

?

I prefer the second style, since it's less verbose, and I assumed that the compiler will make sure the empty array doesn't really get created, but I've been wondering if that's true.

Of course, in 99% of the cases it doesn't make a difference one way or the other, but I'd like to keep a consistent style between my normal code and my optimized inner loops...

回答1:

As of ArrayList in Java 5, the array will be filled already if it has the right size (or is bigger). Consequently

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

will create one array object, fill it and return it to "arr". On the other hand

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

will create two arrays. The second one is an array of MyClass with length 0. So there is an object creation for an object that will be thrown away immediately. As far as the source code suggests the compiler / JIT cannot optimize this one so that it is not created. Additionally, using the zero-length object results in casting(s) within the toArray() - method.

See the source of ArrayList.toArray():

public  T[] toArray(T[] a) {     if (a.length  size)         a[size] = null;     return a; } 

Use the first method so that only one object is created and avoid (implicit but nevertheless expensive) castings.

回答2:

Counterintuitively, the fastest version, on Hotspot 8, is:

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

I have run a micro benchmark using jmh the results and code are below, showing that the version with an empty array consistently outperforms the version with a presized array. Note that if you can reuse an existing array of the correct size, the result may be different.

Benchmark results (score in microseconds, smaller = better):

---

For reference, the code:

@State(Scope.Thread) @BenchmarkMode(Mode.AverageTime) public class SO29378922 {   @Param({"1", "100", "1000", "5000", "10000", "100000"}) int n;   private final List list = new ArrayList();   @Setup public void populateList() {     for (int i = 0; i 

回答3:

Modern JVMs optimise reflective array construction in this case, so the performance difference is tiny. Naming the collection twice in such boilerplate code is not a great idea, so I'd avoid the first method. Another advantage of the second is that it works with synchronised and concurrent collections. If you want to make optimisation, reuse the empty array (empty arrays are immutable and can be shared), or use a profiler(!).

回答4:

The first case is more efficient.

That is because in the second case:

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

the runtime actually creates an empty array (with zero size) and then inside the toArray method creates another array to fit the actual data. This creation is done using reflection using the following code (taken from jdk1.5.0_10):

public  T[] toArray(T[] a) {     if (a.length  size)         a[size] = null;     return a; } 

By using the first form, you avoid the creation of a second array and also avoid the reflection code.

回答5:

toArray checks that the array passed is of the right size (that is, large enough to fit the elements from your list) and if so, uses that. Consequently if the size of the array provided it smaller than required, a new array will be reflexively created.

In your case, an array of size zero, is immutable, so could safely be elevated to a static final variable, which might make your code a little cleaner, which avoids creating the array on each invocation. A new array will be created inside the method anyway, so it's a readability optimisation.

Arguably the faster version is to pass the array of a correct size, but unless you can prove this code is a performance bottleneck, prefer readability to runtime performance until proven otherwise.

回答6:

Use the first case because it is easier and provides cleaner code. The reason for this is that the underlying method of how the ToArray method works is to perform a copy operation which is O(n). The immutable memory isn't a big deal. Management of such objects is done very efficiently and it will expand to the desired size.

Don't optimize too much until you've established that something is a bottleneck in your code. If you spend too much time optimizing this you're just wasting time. I am sure there are plenty of other things you can optimize, so I would say use either one. If you want readability and less verboseness take the first one. If you don't mind the extra code and lessening of clarity, use the latter.

回答7:

Using 'toArray' with the array of the correct size will perform better as the alternative will create first the zero sized array then the array of the correct size. However, as you say the difference is likely to be negligible.

Also, note that the javac compiler does not perform any optimization. These days all optimizations are performed by the JIT/HotSpot compilers at runtime. I am not aware of any optimizations around 'toArray' in any JVMs.

The answer to your question, then, is largely a matter of style but for consistency's sake should form part of any coding standards you adhere to (whether documented or otherwise).

回答8:

The second one is marginally mor readable, but there so little improvement that it's not worth it. The first method is faster, with no disadvantages at runtime, so that's what I use. But I write it the second way, because it's faster to type. Then my IDE flags it as a warning and offers to fix it. With a single keystroke, it converts the code from the second type to the first one.

回答9:

sample code for integer :

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

文章来源: .toArray(new MyClass[0]) or .toArray(new MyClass[myList.size()])?