What s the reason I can t create generic array types in Java

Question

What s the reason why Java doesn t allow us to do  private T   elements   new T initialCapacity     I could understand  NET didn t allow us to do that  as in  NET you have value types that at run-time can have different sizes  but in Java all kinds of T will be object references  thus having the same size  correct me if I m wrong    What is the reason

User · Answer

It is because generics were added on to java after they made it  so its kinda clunky because the original makers of java thought that when making an array the type would be specified in the making of it  So that does not work with generics so you have to do  E   array  E    new Object 15   This compiles but it gives a warning

User · Answer

I know I m a little late to the party here  but I figured I might be able to help any future googlers since none of these answers fixed my issue   Ferdi265 s answer helped immensely though   I m trying to create my own Linked list  so the following code is what worked for me   package myList  import java lang reflect Array   public class MyList lt TYPE gt          private Node lt TYPE gt  header   null       public void clear       header   null          public void add TYPE t      header   new Node lt TYPE gt  t header             public TYPE get int position     return getNode position  getObject             SuppressWarnings  unchecked       public TYPE   toArray                    TYPE   result    TYPE   Array newInstance header getObject   getClass   size                     for int i 0   i lt size     i      result i    get i            return result              public int size             int i   0              Node lt TYPE gt  current   header           while current    null                  current   current getNext               i                      return i            In the toArray   method lies the way to create an array of a generic type for me   TYPE   result    TYPE   Array newInstance header getObject   getClass   size

User · Answer

Quote      Arrays of generic types are not   allowed because they re not sound  The   problem is due to the interaction of   Java arrays  which are not statically   sound but are dynamically checked    with generics  which are statically   sound and not dynamically checked    Here is how you could exploit the   loophole   class Box lt T gt        final T x      Box T x            this x   x           class Loophole       public static void main String   args            Box lt String gt    bsa   new Box lt String gt  3           Object   oa   bsa          oa 0    new Box lt Integer gt  3      error not caught by array store check         String s   bsa 0  x     BOOM                We had proposed to resolve this   problem using statically safe arrays    aka Variance  bute that was rejected   for Tiger       -- gafter     I believe it is Neal Gafter  but am not sure   See it in context here  http   forums sun com thread jspa threadID 457033 amp forumID 316

User · Answer

There surely must be a good way around it  maybe using reflection   because it seems to me that that s exactly what ArrayList toArray T   a  does  I quote      public  lt T gt  T   toArray T   a       Returns an array containing all of the   elements in this list in the correct order  the runtime type of the   returned array is that of the specified array  If the list fits in the   specified array  it is returned therein  Otherwise  a new array is   allocated with the runtime type of the specified array and the size of   this list    So one way around it would be to use this function i e  create an ArrayList of the objects you want in the array  then use toArray T   a  to create the actual array  It wouldn t be speedy  but you didn t mention your requirements   So does anyone know how toArray T   a  is implemented

User · Answer

The main reason is due to the fact that arrays in Java are covariant   There s a good overview here

User · Answer

The reason this is impossible is that Java implements its Generics purely on the compiler level  and there is only one class file generated for each class  This is called Type Erasure   At runtime  the compiled class needs to handle all of its uses with the same bytecode  So  new T capacity  would have absolutely no idea what type needs to be instantiated

User · Answer

If the class uses  as a parameterized type  it can declare an array of type T    but it cannot directly instantiate such an array  Instead  a common approach is to instantiate an array of type Object    and then make a narrowing cast to type T    as shown in the following     public class Portfolio lt T gt      T   data   public Portfolio int capacity       data   new T capacity                      illegal  compiler error    data    T    new Object capacity           legal  but compiler warning     public T get int index    return data index      public void set int index  T element    data index    element

User · Answer

It s because Java s arrays  unlike generics  contain  at runtime  information about its component type  So you must know the component type when you create the array  Since you don t know what T is at runtime  you can t create the array

User · Answer

Try this   List lt   gt    arrayOfLists   new List lt   gt  4

User · Answer

If we cannot instantiate generic arrays  why does the language have generic array types  What s the point of having a type without objects   The only reason I can think of  is varargs - foo T      Otherwise they could have completely scrubbed generic array types   Well  they didn t really have to use array for varargs  since varargs didn t exist before 1 5  That s probably another mistake    So it is a lie  you can instantiate generic arrays  through varargs   Of course  the problems with generic arrays are still real  e g   static  lt T gt  T   foo T    args       return args    static  lt T gt  T   foo2 T a1  T a2       return foo a1  a2      public static void main String   args       String   x2   foo2  a    b       heap pollution      We can use this example to actually demonstrate the danger of generic array   On the other hand  we ve been using generic varargs for a decade  and the sky is not falling yet  So we can argue that the problems are being exaggerated  it is not a big deal  If explicit generic array creation is allowed  we ll have bugs here and there  but we ve been used to the problems of erasure  and we can live with it   And we can point to foo2 to refute the claim that the spec keeps us from the problems that they claim to keep us from  If Sun had more time and resources for 1 5  I believe they could have reached a more satisfying resolution

User · Answer

Arrays Are Covariant     Arrays are said to be covariant which basically means that  given the subtyping rules of Java  an array of type T   may contain elements of type T or any subtype of T  For instance   Number   numbers   new Number 3   numbers 0    newInteger 10   numbers 1    newDouble 3 14   numbers 2    newByte 0        But not only that  the subtyping rules of Java also state that an array S   is a subtype of the array T   if S is a subtype of T  therefore  something like this is also valid    Integer   myInts    1 2 3 4   Number   myNumber   myInts       Because according to the subtyping rules in Java  an array Integer   is a subtype of an array Number   because Integer is a subtype of Number       But this subtyping rule can lead to an interesting question  what would happen if we try to do this    myNumber 0    3 14    attempt of heap pollution   This last line would compile just fine  but if we run this code  we would get an ArrayStoreException because we   re trying to put a double into an integer array  The fact that we are accessing the array through a Number reference is irrelevant here  what matters is that the array is an array of integers   This means that we can fool the compiler  but we cannot fool the run-time type system  And this is so because arrays are what we call a reifiable type  This means that at run-time Java knows that this array was actually instantiated as an array of integers which simply happens to be accessed through a reference of type Number     So  as we can see  one thing is the actual type of the object  an another thing is the type of the reference that we use to access it  right   The Problem with Java Generics  Now  the problem with generic types in Java is that the type information for type parameters is discarded by the compiler after the compilation of code is done  therefore this type information is not available at run time  This process is called type erasure  There are good reasons for implementing generics like this in Java  but that   s a long story  and it has to do with binary compatibility with pre-existing code      The important point here is that since at run-time there is no type information  there is no way to ensure that we are not committing heap pollution    Let   s consider now the following unsafe code   List lt Integer gt  myInts   newArrayList lt Integer gt     myInts add 1   myInts add 2   List lt Number gt  myNums   myInts    compiler error myNums add 3 14     heap polution   If the Java compiler does not stop us from doing this  the run-time type system cannot stop us either  because there is no way  at run time  to determine that this list was supposed to be a list of integers only  The Java run-time would let us put whatever we want into this list  when it should only contain integers  because when it was created  it was declared as a list of integers  That   s why the compiler rejects line number 4 because it is unsafe and if allowed could break the assumptions of the type system   As such  the designers of Java made sure that we cannot fool the compiler  If we cannot fool the compiler  as we can do with arrays  then we cannot fool the run-time type system either   As such  we say that generic types are non-reifiable  since at run time we cannot determine the true nature of the generic type   I skipped some parts of this answers you can read full article here  https   dzone com articles covariance-and-contravariance

User · Answer

By failing to provide a decent solution  you just end up with something worse IMHO   The common work around is as follows   T   ts   new T n     is replaced with  assuming T extends Object and not another class   T   ts    T    new Object n     I prefer the first example  however more academic types seem to prefer the second  or just prefer not to think about it     Most of the examples of why you can t just use an Object   equally apply to List or Collection  which are supported   so I see them as very poor arguments   Note  this is one of the reasons the Collections library itself doesn t compile without  warnings   If you this use-case cannot be supported without warnings  something is fundamentally broken with the generics model IMHO

User · Answer

From Oracle tutorial      You cannot create arrays of parameterized types  For example  the following code does not compile   List lt Integer gt    arrayOfLists   new List lt Integer gt  2       compile-time error       The following code illustrates what happens when different types are inserted into an array   Object   strings   new String 2   strings 0     hi        OK strings 1    100        An ArrayStoreException is thrown        If you try the same thing with a generic list  there would be a problem   Object   stringLists   new List lt String gt         compiler error  but pretend it s allowed stringLists 0    new ArrayList lt String gt          OK stringLists 1    new ArrayList lt Integer gt         An ArrayStoreException should be thrown                                                 but the runtime can t detect it        If arrays of parameterized lists were allowed  the previous code would fail to throw the desired ArrayStoreException    To me  it sounds very weak  I think that anybody with a sufficient understanding of generics  would be perfectly fine  and even expect  that the ArrayStoredException is not thrown in such case

User · Answer

As others already mentioned  you can of course create via some tricks    But it s not recommended    Because the type erasure and more importantly the covariance in array which just allows a subtype array can be assigned to a supertype array  which forces you to use explicit type cast when trying to get the value back causing run-time ClassCastException which is one of the main objectives that generics try to eliminate  Stronger type checks at compile time   Object   stringArray      hi    me     stringArray 1    1  String aString    String  stringArray 1      boom  the TypeCastException   A more direct example can found in Effective Java  Item 25     covariance  an array of type S   is a subtype of T   if S is a subtype of T

User · Answer

I like the answer indirectly given by Gafter   However  I propose it is wrong   I changed Gafter s code a little   It compiles and it runs for a while then it bombs where Gafter predicted it would  class Box lt T gt         final T x       Box T x            this x   x           class Loophole        public static  lt T gt  T   array final T    values            return  values              public static void main String   args             Box lt String gt  a   new Box  Hello            Box lt String gt  b   new Box  World            Box lt String gt  c   new Box                         Box lt String gt    bsa   array a  b  c           System out println  I created an array of generics              Object   oa   bsa          oa 0    new Box lt Integer gt  3           System out println  error not caught by array store check             try               String s   bsa 0  x            catch  ClassCastException cause                System out println  BOOM                 cause printStackTrace                        The output is  I created an array of generics  error not caught by array store check BOOM  java lang ClassCastException  java lang Integer cannot be cast to java lang String     at Loophole main Box java 26    So it appears to me you can create generic array types in java   Did I misunderstand the question

User · Answer

In my case  I simply wanted an array of stacks  something like this   Stack lt SomeType gt    stacks   new Stack lt SomeType gt  2     Since this was not possible  I used the following as a workaround    Created a non-generic wrapper class around Stack  say MyStack  MyStack   stacks   new MyStack 2  worked perfectly well   Ugly  but Java is happy   Note  as mentioned by BrainSlugs83 in the comment to the question  it is totally possible to have arrays of generics in  NET

User · Answer

The answer was already given but if you already have an Instance of T then you can do this   T t    Assuming you already have this object instantiated or given by parameter  int length  T   ts    T    Array newInstance t getClass    length     Hope  I could Help  Ferdi265

[java] What's the reason I can't create generic array types in Java?

Examples related to java

Examples related to generics

Examples related to type-erasure