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<E> {     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<T> {     public Stack(Class<T> clazz, int capacity) {         array = (T[])Array.newInstance(clazz, capacity);     }      private final T[] array; } 

But I really don't get what's going on.

Answer 1

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.

Answer 2

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<E> 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<E> {      private E[] a;      public GenSet(Class<E> 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<E> {      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<E extends Foo> { // 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.