Overhead in creating an empty array?

Question

In order convert a List to an array, you need an empty array like following:

List<Foo> fooList;
Foo[] foos = fooList.toArray(new Foo[0]);

I happen to use this code snippet a lot, so instead of creating an empty array every time, I decided to create a static empty array, and use it each time. e.g.

private static Foo[] EMPTY_FOOS = new Foo[0];

List<Foo> fooList;
Foo[] foos = fooList.toArray(EMPTY_FOOS);

Is this worth it or are we looking at a difference of 0.000000000000000000000000000000000000000000000000000001ms?

It can be worth it. This is what profiling is for. Only you can determine what is a bottleneck in your own code. — Kirk Woll
– Kirk Woll, Commented Feb 24, 2012 at 23:01
@Saeed, nonsense. The problem is optimizations before any observation of an actual problem. — Kirk Woll
– Kirk Woll, Commented Feb 24, 2012 at 23:05
Is there a specific reason Why you don't use the parameter less toArray() function? — Julien May
– Julien May, Commented Feb 24, 2012 at 23:05
@KirkWoll, If another developer use this static field it can be a devil. — Saeed Amiri
– Saeed Amiri, Commented Feb 24, 2012 at 23:09

Tomasz Nurkiewicz · Accepted Answer · 2012-02-24 23:04:56Z

7

Actually I believe this is the best performing version:

fooList.toArray(new Foo[fooList.size()]);

This way toArray() always has the exact array and no extra arrays are created. IntelliJ suggests such a refactoring out of the box.

answered Feb 24, 2012 at 23:04

Tomasz Nurkiewicz

342k72 gold badges713 silver badges680 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Alex D Over a year ago

Excellent point, +1. If you don't do this, it will allocate more arrays "under the hood" anyways.

user166390 Over a year ago

Or just don't use Java's "array" objects at all directly? (ArrayList, etc, use them internally.) They are really outcasts in the Java Collection framework.

Kevin Welker Over a year ago

If you pass an array of anything less than the size of the collection (including 0)., it will create exactly one more array (not "arrays") of exactly the correct number of elements. However, it does use reflection to do that, so your way is still preferable.

Alex D · Accepted Answer · 2012-02-24 23:05:02Z

2

On my computer, creating 100,000,000 Object[0] arrays takes 2.9 seconds. If you are creating a million arrays per second, or even 100,000, it might make a measurable difference.

answered Feb 24, 2012 at 23:05

Alex D

30.6k7 gold badges85 silver badges131 bronze badges

Comments

Kevin Hooke · Accepted Answer · 2012-02-24 23:53:28Z

1

I think it would make more sense to question why you need to convert arrays to Lists and vice versa in the first place. You'll be better off sticking with the Collection classes if you can and avoiding the use of arrays as they are more error prone that using Collection classes.

If you use that snippet of code 'a lot' then write a method that you can reuse, but in order to determine what effort you should invest in optimizing this code, you need to profile it and see what the overhead is in relation to your other code and how often this code is actually used at runtime.

As Knuth said: "premature optimization is the root of all evil" :-)

answered Feb 24, 2012 at 23:53

Kevin Hooke

2,6312 gold badges20 silver badges34 bronze badges

Collectives™ on Stack Overflow

Overhead in creating an empty array?

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related