How to create a generic array in Java

Question

Due to the implementation of Java generics  you can t have code like this    public class GenSet lt E gt        private E a         public GenSet             a   new E INITIAL ARRAY LENGTH      error  generic array creation           How can I implement this while maintaining type safety   I saw a solution on the Java forums that goes like this   import java lang reflect Array   class Stack lt T gt        public Stack Class lt T gt  clazz  int capacity            array    T   Array newInstance clazz  capacity              private final T   array      But I really don t get what s going on

User · Answer

You could create an Object array and cast it to E everywhere  Yeah  it s not very clean way to do it but it should at least work

User · Answer

Here s how to use generics to get an array of precisely the type you   re looking for while preserving type safety  as opposed to the other answers  which will either give you back an Object array or result in warnings at compile time    import java lang reflect Array     public class GenSet lt E gt          private E   a         public GenSet Class lt E   gt  clazz  int length              a   clazz cast Array newInstance clazz getComponentType    length                   public static void main String   args              GenSet lt String gt  foo   new GenSet lt String gt  String   class  1             String   bar   foo a            foo a 0     xyzzy             String baz   foo a 0                 That compiles without warnings  and as you can see in main  for whatever type you declare an instance of GenSet as  you can assign a to an array of that type  and you can assign an element from a to a variable of that type  meaning that the array and the values in the array are of the correct type   It works by using class literals as runtime type tokens  as discussed in the Java Tutorials  Class literals are treated by the compiler as instances of java lang Class  To use one  simply follow the name of a class with  class  So  String class acts as a Class object representing the class String  This also works for interfaces  enums  any-dimensional arrays  e g  String   class   primitives  e g  int class   and the keyword void  i e  void class     Class itself is generic  declared as Class lt T gt   where T stands for the type that the Class object is representing   meaning that the type of String class is Class lt String gt    So  whenever you call the constructor for GenSet  you pass in a class literal for the first argument representing an array of the GenSet instance s declared type  e g  String   class for GenSet lt String gt    Note that you won t be able to get an array of primitives  since primitives can t be used for type variables   Inside the constructor  calling the method cast returns the passed Object argument cast to the class represented by the Class object on which the method was called  Calling the static method newInstance in java lang reflect Array returns as an Object an array of the type represented by the Class object passed as the first argument and of the length specified by the int passed as the second argument  Calling the method getComponentType returns a Class object representing the component type of the array represented by the Class object on which the method was called  e g  String class for String   class  null if the Class object doesn t represent an array    That last sentence isn t entirely accurate  Calling String   class getComponentType   returns a Class object representing the class String  but its type is Class lt   gt   not Class lt String gt   which is why you can t do something like the following   String foo   String   class getComponentType   cast  bar       won t compile   Same goes for every method in Class that returns a Class object   Regarding Joachim Sauer s comment on this answer  I don t have enough reputation to comment on it myself   the example using the cast to T   will result in a warning because the compiler can t guarantee type safety in that case     Edit regarding Ingo s comments   public static  lt T gt  T   newArray Class lt T   gt  type  int size       return type cast Array newInstance type getComponentType    size

User · Answer

If you really want to wrap a generic array of fixed size you will have a method to add data to that array  hence you can initialize properly the array there doing something like this   import java lang reflect Array   class Stack lt T gt        private T   array   null      private final int capacity   10     fixed or pass it in the constructor     private int pos   0       public void push T value            if  value    null              throw new IllegalArgumentException  Stack does not accept nulls            if  array    null              array    T    Array newInstance value getClass    capacity              put logic  e g          if pos    capacity               throw new IllegalStateException  push on full stack            array pos      value             public T pop   throws IllegalStateException           if  pos    0              throw new IllegalStateException  pop on empty stack            return array --pos             in this case you use a java lang reflect Array newInstance to create the array  and it will not be an Object    but a real T    You should not worry of it not being final  since it is managed inside your class  Note that you need a non null object on the push   to be able to get the type to use  so I added a check on the data you push and throw an exception there   Still this is somewhat pointless  you store data via push and it is the signature of the method that guarantees only T elements will enter  So it is more or less irrelevant that the array is Object   or T

User · Answer

The forced cast suggested by other people did not work for me  throwing an exception of illegal casting   However  this implicit cast worked fine   Item lt K gt    array   new Item SIZE     where Item is a class I defined containing the member   private K value    This way you get an array of type K  if the item only has the value  or any generic type you want defined in the class Item

User · Answer

I made this code snippet to reflectively instantiate a class which is passed for a simple automated test utility   Object attributeValue   null  try       if clazz isArray             Class lt   gt  arrayType   clazz getComponentType            attributeValue   Array newInstance arrayType  0             else if  clazz isInterface             attributeValue   BeanUtils instantiateClass clazz           catch  Exception e        logger debug  Cannot instanciate          new Object   clazz        Note this segment       if clazz isArray             Class lt   gt  arrayType   clazz getComponentType            attributeValue   Array newInstance arrayType  0           for array initiating where Array newInstance class of array  size of array   Class can be both primitive  int class  and object  Integer class    BeanUtils is part of Spring

User · Answer

To extend to more dimensions  just add    s and dimension parameters to newInstance    T is a type parameter  cls is a Class lt T gt   d1 through d5 are integers    T   array    T   Array newInstance cls  d1   T     array    T     Array newInstance cls  d1  d2   T       array    T       Array newInstance cls  d1  d2  d3   T         array    T         Array newInstance cls  d1  d2  d3  d4   T           array    T           Array newInstance cls  d1  d2  d3  d4  d5     See Array newInstance   for details

User · Answer

private E a    private int size   public GenSet int elem        size   elem      a    E    new E size

User · Answer

I found a sort of a work around to this problem    The line below throws generic array creation error  List lt Person gt    personLists new ArrayList lt Person gt    10     However if I encapsulate List lt Person gt  in a separate class  it works   import java util ArrayList  import java util List    public class PersonList        List lt Person gt  people       public PersonList                 people new ArrayList lt Person gt               You can expose people in the class PersonList thru a getter  The line below will give you an array  that has a List lt Person gt  in every element  In other words array of List lt Person gt    PersonList   personLists new PersonList 10     I needed something like this in some code I was working on and this is what I did to get it to work  So far no problems

User · Answer

Java generics work by checking types at compile time and inserting appropriate casts  but erasing the types in the compiled files  This makes generic libraries usable by code which doesn t understand generics  which was a deliberate design decision  but which means you can t normally find out what the type is at run time   The public Stack Class lt T gt  clazz int capacity  constructor requires you to pass a Class object at run time  which means class information is available at runtime to code that needs it  And the Class lt T gt  form means that the compiler will check that the Class object you pass is precisely the Class object for type T  Not a subclass of T  not a superclass of T  but precisely T   This then means that you can create an array object of the appropriate type in your constructor  which means that the type of the objects you store in your collection will have their types checked at the point they are added to the collection

User · Answer

No one else has answered the question of what is going on in the example you posted   import java lang reflect Array   class Stack lt T gt        public Stack Class lt T gt  clazz  int capacity            array    T   Array newInstance clazz  capacity              private final T   array      As others have said generics are  erased  during compilation  So at runtime an instance of a generic doesn t know what its component type is  The reason for this is historical  Sun wanted to add generics without breaking the existing interface  both source and binary    Arrays on the other hand do know their component type at runtime   This example works around the problem by having the code that calls the constructor  which does know the type  pass a parameter telling the class the required type   So the application would construct the class with something like  Stack lt foo gt    new Stack lt foo gt  foo class 50    and the constructor now knows  at runtime  what the component type is and can use that information to construct the array through the reflection API   Array newInstance clazz  capacity     Finally we have a type cast because the compiler has no way of knowing that the array returned by Array newInstance   is the correct type  even though we know    This style is a bit ugly but it can sometimes be the least bad solution to creating generic types that do need to know their component type at runtime for whatever reason  creating arrays  or creating instances of their component type  etc

User · Answer

Passing a list of values     public  lt T gt  T   array T    values        return values

User · Answer

In Java 8  we can do a kind of generic array creation using a lambda or method reference  This is similar to the reflective approach  which passes a Class   but here we aren t using reflection    FunctionalInterface interface ArraySupplier lt E gt        E   get int length      class GenericSet lt E gt        private final ArraySupplier lt E gt  supplier      private E   array       GenericSet ArraySupplier lt E gt  supplier            this supplier   supplier          this array      supplier get 10              public static void main String   args            GenericSet lt String gt  ofString               new GenericSet lt  gt  String    new           GenericSet lt Double gt  ofDouble               new GenericSet lt  gt  Double    new             For example  this is used by  lt A gt  A   Stream toArray IntFunction lt A   gt     This could also be done pre-Java 8 using anonymous classes but it s more cumbersome

User · Answer

What about this solution    SafeVarargs public static  lt T gt  T   toGenericArray T     elems        return elems      It works and looks too simple to be true  Is there any drawback

User · Answer

I actually found a pretty unique solution to bypass the inability to initiate a generic array  What you have to do is create a class that takes in the generic variable T like so   class GenericInvoker  lt T gt        T variable      public GenericInvoker T variable           this variable   variable            and then in your array class just have it start like so   GenericInvoker lt T gt    array  public MyArray        array   new GenericInvoker        starting a new Generic Invoker   will cause an issue with unchecked but there shouldn t actually be any issues   To get from the array you should call the array i  variable like so   public T get int index       return array index  variable      The rest  such as resizing the array can be done with Arrays copyOf   like so   public void resize int newSize       array   Arrays copyOf array  newSize       And the add function can be added like so   public boolean add T element          the variable size below is equal to how many times the add function has been called         and is used to keep track of where to put the next variable in the array     arrays size    new GenericInvoker element       size

User · Answer

This is covered in Chapter 5  Generics  of Effective Java  2nd Edition  item 25   Prefer lists to arrays  Your code will work  although it will generate an unchecked warning  which you could suppress with the following annotation    SuppressWarnings   unchecked      However  it would probably be better to use a List instead of an Array   There s an interesting discussion of this bug feature on the OpenJDK project site

User · Answer

Actually an easier way to do so  is to create an array of objects and cast it to your desired type like the following example   T   array    T   new Object SIZE     where SIZE is a constant and T is a type identifier

User · Answer

This is the only answer that is type safe  E   a   a   newArray size     SafeVarargs static  lt E gt  E   newArray int length  E    array        return Arrays copyOf array  length

User · Answer

try this   private int m   0  private int n   0  private Element lt T gt      elements   null   public MatrixData int m  int n        this m   m      this n   n       this elements   new Element m  n       for  int i   0  i  lt  m  i                  for  int j   0  j  lt  n  j                          this elements i  j    new Element lt T gt

User · Answer

I have to ask a question in return  is your GenSet  checked  or  unchecked   What does that mean    Checked  strong typing  GenSet knows explicitly what type of objects it contains  i e  its constructor was explicitly called with a Class lt E gt  argument  and methods will throw an exception when they are passed arguments that are not of type E  See Collections checkedCollection   -  in that case  you should write   public class GenSet lt E gt         private E   a       public GenSet Class lt E gt  c  int s               Use Array native method to create array            of a type only known at run time          SuppressWarnings  unchecked           final E   a    E    Array newInstance c  s           this a   a             E get int i            return a i            Unchecked  weak typing  No type checking is actually done on any of the objects passed as argument   -  in that case  you should write  public class GenSet lt E gt         private Object   a       public GenSet int s            a   new Object s              E get int i             SuppressWarnings  unchecked           final E e    E  a i           return e            Note that the component type of the array should be the erasure of the type parameter   public class GenSet lt E extends Foo gt       E has an upper bound of Foo      private Foo   a     E erases to Foo  so use Foo        public GenSet int s            a   new Foo s                       All of this results from a known  and deliberate  weakness of generics in Java  it was implemented using erasure  so  generic  classes don t know what type argument they were created with at run time  and therefore can not provide type-safety unless some explicit mechanism  type-checking  is implemented

User · Answer

You can do this   E   arr    E   new Object INITIAL ARRAY LENGTH     This is one of the suggested ways of implementing a generic collection in Effective Java  Item 26   No type errors  no need to cast the array repeatedly   However this triggers a warning because it is potentially dangerous  and should be used with caution   As detailed in the comments  this Object   is now masquerading as our E   type  and can cause unexpected errors or ClassCastExceptions if used unsafely   As a rule of thumb  this behavior is safe as long as the cast array is used internally  e g  to back a data structure   and not returned or exposed to client code   Should you need to return an array of a generic type to other code  the reflection Array class you mention is the right way to go     Worth mentioning that wherever possible  you ll have a much happier time working with Lists rather than arrays if you re using generics   Certainly sometimes you don t have a choice  but using the collections framework is far more robust

User · Answer

I have found a quick and easy way that works for me  Note that i have only used this on Java JDK 8  I don t know if it will work with previous versions   Although we cannot instantiate a generic array of a specific type parameter  we can pass an already created array to a generic class constructor   class GenArray  lt T gt        private T theArray       reference array                  GenArray T   arr            theArray   arr                Do whatever with the array        Now in main we can create the array like so   class GenArrayDemo       public static void main String   args            int size   10     array size            Here we can instantiate the array of the type we want  say Character  no primitive types allowed in generics          Character   ar   new Character size            GenArray lt Character gt    new Character lt  gt  ar      create the generic Array                            For more flexibility with your arrays you can use a linked list eg  the ArrayList and other methods found in the Java util ArrayList class

User · Answer

I m wondering if this code would create an effective generic array   public T    createArray int desiredSize       ArrayList lt T gt  builder   new ArrayList lt T gt         for int x 0 x lt desiredSize x             builder add null             return builder toArray zeroArray          zeroArray should  in theory  create a zero-sized array of T   when it is not given any parameters   private T    zeroArray T    i       return i      Edit  Perhaps an alternate way of creating such an array  if the size you required was known and small  would be to simply feed the required number of  null s into the zeroArray command   Though obviously this isn t as versatile as using the createArray code

User · Answer

The example is using Java reflection to create an array  Doing this is generally not recommended  since it isn t typesafe  Instead  what you should do is just use an internal List  and avoid the array at all

User · Answer

You do not need to pass the Class argument to the constructor  Try this   public class GenSet lt T gt        private final T   array       SuppressWarnings  unchecked       public GenSet int capacity  T    dummy            if  dummy length  gt  0              throw new IllegalArgumentException                 Do not provide values for dummy argument             Class lt   gt  c   dummy getClass   getComponentType            array    T   Array newInstance c  capacity              Override     public String toString             return  GenSet of     array getClass   getComponentType   getName                       array length                  and  GenSet lt Integer gt  intSet   new GenSet lt  gt  3   System out println intSet   System out println new GenSet lt String gt  2      result   GenSet of java lang Integer 3  GenSet of java lang String 2

User · Answer

An easy  albeit messy workaround to this would be to nest a second  holder  class inside of your main class  and use it to hold your data   public class Whatever lt Thing gt       private class Holder lt OtherThing gt           OtherThing thing            public Holder lt Thing gt    arrayOfHolders   new Holder lt Thing gt  10

User · Answer

Generic array creation is disallowed in java but you can do it like  class Stack lt T gt    private final T   array  public Stack int capacity        array    T    new Object capacity

User · Answer

According to vnportnoy the syntax  GenSet lt Integer gt  intSet     new GenSet 3     creates an array of null references  to be filled as  for  int i   0  i  lt  3  i         intSet i    new GenSet lt Integer gt         which is type safe

User · Answer

Hi although the thread is dead  I would like to draw your attention to this   Generics is used for type checking during compile time    Therefore the purpose is to check that what comes in is what you need  What you return is what the consumer needs  Check this        Do don t worry about typecasting warnings when you are writing generic class  Worry when you are using it

User · Answer

You could use a cast   public class GenSet lt Item gt        private Item   a       public GenSet int s            a    Item    new Object s

User · Answer

Maybe unrelated to this question but while I was getting the  generic array creation  error for using   Tuple lt Long String gt    tupleArray   new Tuple lt Long String gt  10     I find out the following works  and worked for me  with   SuppressWarnings   unchecked       Tuple lt Long  String gt    tupleArray   new Tuple 10

User · Answer

Look also to this code   public static  lt T gt  T   toArray final List lt T gt  obj        if  obj    null    obj isEmpty              return null            final T t   obj get 0       final T   res    T    Array newInstance t getClass    obj size         for  int i   0  i  lt  obj size    i              res i    obj get i             return res      It converts a list of any kind of object to an array of the same type

[java] How to create a generic array in Java?

Examples related to java

Examples related to arrays

Examples related to generics

Examples related to reflection

Examples related to instantiation