Java泛型：使用参数化类型实例化数组：非法吗？

Question

I must be confused here.

I read everywhere that in generics arrays of parametrized types are illegal.

Example from AngelikaLanger :

static void test() {  
  Pair<Integer,Integer>[] intPairArr = new Pair<Integer,Integer>[10] ; // error  
  addElements(intPairArr);   
  Pair<Integer,Integer> pair = intPairArr[1];  
  Integer i = pair.getFirst();  
  pair.setSecond(i);  
} 

Quote from Langer (but everywhere else I read it says the same thing):

The compiler prohibits creation of arrays whose component type is a concrete parameterized type, like Pair in our example. We discussed in the preceding entry why is it reasonable that the compiler qualifies a Pair[] as illegal.

So far ok.

But in my code here:

private MyEntry<E> [] elements = (MyEntry<E>[])new Object[capacity];  

I do exactly that, it compiles fine (I use eclipse) but get a class cast exception error (Object can not be cast to MyEntry):

My question is, why does this line compiles in the first place?

I thought that this instantiation is disallowed by the compiler.

What I am doing wrong/differerent here?

UPDATE:

On the same page, why am I able to succesfully do:

List<E> elements[] = (List<E>[])new LinkedList[capacity];  

and have no runtime exceptions ?

UPDATE:

Everywhere I have read (mentioned Langer since she's quoted often) it says that this declaration (arrays of parametrized types) is disallowed by compiler.
I can understand what happens after that.
I can't understand why the compiler doesn't report an error.
I am not judging, I am saying everywhere I read, it says this does not compile.
Am I missreading something?

UPDATE: I saw some comments related to the missing parameter in the new part.
This also has no issue:

List<Entry<KeyType, ValueType>> table[] = (List<Entry<KeyType, ValueType>>[])new LinkedList[capacity];

Answer 1

In your first example, there's no problem with the instantiation - here's exactly what you're creating:

new Object[capacity]

Perfectly legal. You do however get a runtime exception when you attempt to cast, because an array of Object is not an array of MyEntry<E> . You might have a point that the cast or declaration could be rejected by the compiler, if these generically-parameterised arrays can't exist, though this depends what order erasure kicks in. In any case, the instantiation itself is fine.

In the second example, you're creating a non-generic array of LinkedList . You then assign it to a genericised reference, which at runtime will have been erased to just a List[] . This works fine (because rightly or wrongly, arrays are covariant).

I'm not sure why you were expecting a runtime exception; it's not much different to calling, say

List<E> = new LinkedList();

You would get some unchecked warnings, but nothing that would stop the code compiling or running.

Answer 2

Because LinkedList is an instance of List . But Object is NOT an instance of MyEntry . Also compiler don't check can one object be cast to another or not. Because it is runtime operation.

You should use:

private MyEntry<E> [] elements = new MyEntry [capacity];

Or:

class SomeOtherEntry extends MyEntry {}

private MyEntry<E> [] elements = new SomeOtherEntry [capacity];

But not:

class SomeOtherEntry extends MyEntry {}

private SomeOtherEntry <E> [] elements = new MyEntry [capacity];

UPDATE:

List<Entry<KeyType, ValueType>> [] table = (List<Entry<KeyType,ValueType>> []) new Linked[capacity];

Answer 3

You have completely misunderstood whatever you have read. There is absolutely nothing wrong with having the type that is an array of a parameterized type: MyEntry<E>[] or HashMap<String,Integer>[][] or whatever. You can have variables of such types all you want, and use them anywhere a type can be used.

However, with array creation, you cannot do something like new MyEntry<E>[...] . It is not allowed by the language (for type safety reasons we will not go into here), so it is a compile error.

The best solution is either new MyEntry[] (array of raw type) or new MyEntry<?>[] (array of wildcard type); either one is allowed by the language. Both of them will require you to do an explicit cast back to MyEntry<E>[] .

Since you ask about your code examples, your first example is syntactically correct (there is nothing wrong with new Object[...] , and it is syntactically okay to cast to MyEntry<E>[] ), so there is no compile error. However, the runtime check of the cast fails at runtime, because the object's actual type Object[] is not a subtype of MyEntry[] .

The second code example is also syntactically correct, and plus the runtime check of the cast succeeds ( LinkedList[] is a subtype of List[] ).