Arrays of specific generic types are not allowed.Explain.

[Bindu Lakhanpal]

This is from The Complete Reference Java(7th ed) (Herbert Schildt),page 356:

You can't declare an array of references to specific generic type.
[B]That is, this line:

// Gen<Integer> gens[]=new Gen<Integer>[10];//Wrong!

won't complile.Arrays of specific generic types simply are not allowed,because they can lead to a loss of type safety.[/B]
You can create an array of references to a generic type if you use a wildcard,however, as shown here:

Gen<?> gens[]=new Gen<?>[10]// OK

This approach is better than using an array of raw types,because atleast some type checking will still be enforced.

Can anyone please explain this?

[ December 15, 2008: Message edited by: Daisy Lakhanpal ]
[ December 15, 2008: Message edited by: Daisy Lakhanpal ]

[Punit Singh]

Because it is not type-safe.
Arrays are covariant, which means that an array of supertype references is a supertype of an array of subtype references. That is, Object[] is a supertype of String[] and a string array can be accessed through a reference variable of type Object[].

  Object[] objArr = new String[10];
objArr[0] = new Long(0L); // compiles; fails at runtime
with ArrayStoreException  

When an element is inserted into the array, the information about
the array's component type is used to perform a type check - the so-called array store check. In our example the array store check will fail because we are trying to add a Long to an array of Strings. Failure of the array store check is reported by means of a ArrayStoreException.

But because of type erasure of generics, parameterized types donot have exact runtime type information. So there is no array-store-check possible in generics case.

class Gen<T>{
T obj;
        public Gen(T obj){
this.obj=obj;
}
public T getObj(){
return obj;
}
}
 
Gen<Integer> gens[]=new Gen<Integer>[10];
 Object[] objArray=gens;
 objArray[0]=new Gen<String>("Passing String inplace of Integer");//this should fail, but not as runtime there is not generic info
 Integer i=gens[0].getObj();

Suppose Arrays of concrete parameterized type were allowed, then what would have happened?

Gen<Integer> gens[]=new Gen<Integer>[10];
Object[] objArray=gens;//line 1

We could assign this array to Object[] objArray at line1.

objArray[0]=new Gen<String>("Passing String inplace of Integer");////this should fail, but not as runtime there is not generic info

And we could have stored String Object in the array opposed to Integer Array. At runtime an array store check must be performed when an array element is added to the array. Since we are trying to add a Gens<String> to a Gens<Integer>[] we would expect that the type check fails.

However, the JVM cannot detect any type mismatch here: at runtime, after type erasure, objArray would have the dynamic type Gen[] and the element to be stored has the matching dynamic type Pair. Hence the store check succeeds, although it should not.

The array in our example would contain different types of Gens instead of pairs of the same type. This is in contradiction to the expectation that arrays hold elements of the same type (or subtypes thereof).

This undesired situation would most likely lead to program failure some time later, perhaps when a method is invoked on the array elements.
like:

Integer i=gens[0].getObj();

Now JVM would have executed above code that is actually returning String, so it would have tried to convert String to Integer and this would have cause java.lang.ClassCastException.

In order to prevent programs that are not type safe all arrays holding elements whose type is a concrete parameterized type are illegal.
[ December 15, 2008: Message edited by: Punit Singh ]

[Harvinder Thakur]

Nice explanation punit

[Bindu Lakhanpal]

Thanks Punit,
Thats what i made out from your detailed explanation.

In Non Generic code::

public class Arr{
  public static void main(String [] arg)
                  { 
                  Object [] obj = new Object[4];
                 String [] str= new String[4];
                 obj =str;
                 obj[3]= new Integer(8); //compiles but ArrayStoreException at run time and hence we are prevented from entering Integer                                                       // in a String Array
                 }
  
                        }
                              

If we use Generics like ::

class Gen<T>
                     {
                   T obj;  
            public Gen(T obj)
                    {
                   this.obj=obj;
                    }
          public T getObj()
                             {
            return obj;
                }
               }
         class ArrGen 
                         {
                  public static void main(String [] arg)
                             {
                               
                              Object [] obj = new Object[4];
                               Gen<String> gens[]=new Gen<String>[4]; //1 
                              obj=gens; 
                              obj[3]=new Gen<Integer>(8);//2, will compile and run too as there is no generic info at run time and                                                                                                
                               }
                          }

line 2 would not give any run time exception as generic info is not there at run time. and line 1 will appear to JVM as

Gen [] gens=new Gen[4] 

and line 2 as

obj[3]=new Gen(8)

,so there will be no ArrayStoreException!
And it would add objects of Gen<Integer> to a an array of Gen<String>. But we expect only Gen<String> in this array.So to avoid this ,compiler does not allow declaration as in line 1 .

Am I right?

[Jesper de Jong]

See also my blog post about this.

[Punit Singh]

Yes you are right Daisy!