Re: casting Object[] to String[] - why not?
Patricia Shanahan wrote:
K
I am curious; I tend to use the form:
tokens.toArray(new String[tokens.size()]);
thinking that passing in an appropriately sized array would eliminate
the need to reallocate memory for the array, as it seems would be
necessary when sending in a zero length array. Am I wasting my time
(and possibly memory and processor cycles, when I thought I was saving
both)?
For most lists, I don't think it matters much. It should not take much
time to allocate a zero element array that immediately becomes unreachable.
There's a little more expense than creating and collecting
away the zero-length array. If the passed array is too short,
the implementation has to use reflection to discover its run-time
element type and to instantiate a new array of sufficient size.
Reflective operations have a reputation for being noticeably more
expensive than non-reflective alternatives. (ArrayList was the
only concrete implementation I actually checked, but I cannot
imagine how any other could allocate an array of "Same type as
him over there, but bigger" without resorting to reflection.)
But as you say, it probably doesn't make a huge difference.
If the List is subject to access from multiple threads, the zero length
array approach works provided toArray is synchronized. The the size()
based form needs additional synchronization to ensure there is no change
in the size of the List between the size call and the toArray call.
Looks like a wash to me: The synchronization must be done in
any case, whether by the List implementation or by the user. At
worst, the penalty ought to be a couple of recursive acquisitions
of a lock already held.
--
Eric Sosman
esosman@ieee-dot-org.invalid