Does anybody know why Java 1.6 has this behaviour:
List<String> list = ArrayList<String>();
String[] arr = (String[]) list.toArray();
And I get a ClassCastException, because it returns Object[] and not String[].
I thought
List<T>.toArray() should return T[] - no? Does anyone have an answer why this inconvenience exists in the language?
And also how to work around this? How do I get a String[] from List<String> without looping thru the items?
You need to pass in an array so its runtime type can be used as a hint by toArray. Try toArray(new String[0]) instead. You can also pass in a pre-sized array.
To understand, consider what type erasure would have to do to make
new T[4]
work. If Java allowed that, the best it could do post erasure is
new Object[4]
Most toArray implementations use java.lang.reflect.Array to construct an output array of the right type given a type hint passed as a Class.
toArray(new String[list.size()]) if you want to avoid allocation of a size 0 array
List<E> interface can't provide an E[] toArray() method because it would conflict with the older Object[] toArray() method, which was introduced in 1.2 and required for backwards compatibility. This makes sense as you can't have two method signatures that vary only by the return type. But your answer implies that E[] toArray() wouldn't work because of type erasure - did I read that right? Or is there a nuance between you using T as your generic type and the List interface using E for its declaration?E get(int index) work because they're enforced at compile time and don't have to know or construct the type at run time. E[] toArray() could have its returned value assignment/pass/etc. checked at run time, but actually constructing the array requires knowledge of the correct type.Because arrays have been in Java since the beginning, while generics were only introduced in Java 5. And the List.toArray() method was introduced in Java 1.2, before generics existed, and so it was specified to return Object[]. Lots of existing code now expects List.toArray() to return Object[], so it can't be changed now.
Furthermore, generics are erased at runtime, so ArrayList couldn't even construct an array of the proper type if it wanted to.
The loophole for this is the List.toArray(T[]) method, which will return you an array of the correct type, provided you give it an array of the correct type so it knows what type to use.
T[] instead of Object[]. But due to the weird way in which array variance works:, would it be correct to return T[]? My general rule of thumb is that you can use generics, or make use of array covariance, but should avoid trying to use both at the same time.toArray() methods in all of its superclasses (Collection) would also be changed to T[]. As to your question about whether it would be correct, supposing that a method could magically return a T[], it would be correct in most cases, because T[] is a subclass of Object[], so anyone who expects an Object[] should be able to take a T[]. The only exception would be if they tried to then insert an element into the array of a different type, a highly unusual possibility.To understand why that happens, just have a look at the javadoc for Collection.toArray() and then look at the Collection.toArray(T[] a) method. Also keep in mind that generics in Java are erased at runtime.
Since Java 11 it's even easier than String[] str = list.toArray(new String[0]) or String[] str = list.toArray(new String[list.size()]):
String[] str = list.toArray(String[]::new);
The reasons are two:
The method preceded Generics and they couldn't change the signature without breaking backwards compatibility.
In any case, as the List is constructed without a Class<T> there is no way for the implementation to construct an array of type T.
Workaround will be to use:
List<String> list = new ArrayList<>();
list.add("Sputnik");
list.add("Explorer");
//String[] str = list.toArray();
This is bound to throw an : incompatible types: Object[] cannot be converted to String[] error
Instead use:
String[] str = list.toArray(new String[0]);
or
String[] str = list.toArray(new String[list.size()]);
T[].