String[]

[Roel De Nijs]

I have following code:

ArrayList pk = new ArrayList();
pk.add("String 1");
pk.add("String 2");
pk.add("String 3");
...
pk.add("String n");
[B]String[] pkColumns = (String[])pk.toArray();[/B]

This code gives a ClassCastException on the bold line. So have i have to do a cast for each element?

[David Ulicny]

You can't do this conversion.

Use it in this way

 
Object[] pkColumns = pk.toArray();
System.out.println(((String)pkColumns[1]).length());

[Peter Chase]

Collection.toArray() returns Object[], even if all the elements of the Collection happen to be castable to a narrower type.

Collection.toArray(Object[]) is declared to return Object[], but the run-time type of the returned array is the same as the run-time type of the array given as an argument.

In your case, if you construct an array of type String[] and pass that in, then the returned array will be of run-time type String[] and your cast will then succeed.

The String[] that you construct can be of length zero, in which case Java will automatically construct and return a new array of the correct length. Alternatively, you can construct your String[] array with the correct length (using Collection.size() to see what that is); Java will then use that array and return it.

Messy, but it does work and you get used to it.

ArrayList stringList = new ArrayList();
stringList.add("foo");
stringList.add("bar");
String[] stringArray = new String[stringList.size()];
String[] stringArray2 = (String[]) stringList.toArray(stringArray);
assert stringArray == stringArray2;

In Java 5.0, you can use generics to make a Collection that stores only String objects. Its toArray() method will then automatically return the correct type.
[ February 18, 2005: Message edited by: Peter Chase ]

[Stan James]

The size of the array in toArray argument does not matter, just the type. I use it like this all the time:

String[] x = (String[])list.toArray(new String[0]);

[Ernest Friedman-Hill]

Originally posted by Stan James:
The size of the array in toArray argument does not matter, just the type.

Maybe it's a micro-optimization, but note that if the array is the right size, it will be used, whereas if it's not, a new one of the right type needs to be allocated. Therefore, if you have to allocate a 0-element array, you might as well allocate one of the right size and save an allocation.

Both IntelliJ IDEA and Eclipse come with an intention action built-in which lets you type the whole thing, including allocating the array at the proper size, with just a few keystrokes.

[Roel De Nijs]

Originally posted by Ernest Friedman-Hill:


Maybe it's a micro-optimization, but note that if the array is the right size, it will be used, whereas if it's not, a new one of the right type needs to be allocated. Therefore, if you have to allocate a 0-element array, you might as well allocate one of the right size and save an allocation.

Both IntelliJ IDEA and Eclipse come with an intention action built-in which lets you type the whole thing, including allocating the array at the proper size, with just a few keystrokes.

Could you tell me which keystrokes in Eclipse i have to use?

[Ernest Friedman-Hill]

Let's see. In Eclipse, you type "toarray", and press Ctrl-? (or whatever you've got completion bound to.) The little template that appears lets you supply the type for the array and the variable name for the collection, sometimes with the correct variable name already filled in.

In IDEA, you type "toar" and press TAB. IDEA seems to be considerably smarter about figuring out the type and variable name.

[Roel De Nijs]

Thank you all for helping me out with this one. It's working great.

now it's weekend, so it's time to