Generic arrays in Java

Question

OK, I've been google'ing the web, and I just can't seem to find any solution to my problem. I found lots of solutions, just not any that fit.

I need to create an array of generics. But the generic type itself extends Comparable. When I try the following:

public class Hash<T extends Comparable<String>> {
    private T[] hashTable;
    private int tableSize;

    Hash(int records, double load) {
        tableSize = (int)(records / loadFactor);
        tableSize = findNextPrime(tableSize);
        hashTable = (T[])(new Object[tableSize]);  //Error: Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
    }
}

The problem is that the Object cannot be cast as a generic that extends Comparable. Is there a way around this?

Answer 1

Generics and arrays don't mix, basically. The short answer is that you can work around this problem. The longer answer is that you probably shouldn't and I'll explain why.

You could use Array.newInstance() like this:

private Comparable[] hashtable;

...

hashtable = (Comparable[])Array.newInstance(Comparable.class, tableSize);

but you can't create an array of your parameterized type.

Arrays are covariant. That means they retain the type of their elements at runtime. Java's generics are not. They use type erasure to basically mask the implicit casting that is going on. It's important to understand that.

So when you create an Object array you can't cast it to, say, a Comparable array (or any other type) because that is not correct.

To give you an example. With generics this is perfectly legal:

List<String> list = new ArrayList<String>();
List<Integer> list2 = (List<Integer>)list;
list.add(3);

It's also why you can't do this:

public <T> T newInstance(T t) {
  return new T(); // error!
}

ie at runtime there is no knowledge of T's class. This is why the above code is more often written as:

public <T> T newInstance(T t, Class<T> clazz) {
  return clazz.newInstance();
}

because their is no runtime type for the generic argument. But with arrays:

String arr[] = new String[10];
Integer arr2[] = (Integer[])arr; // error!

What you should be doing in this case (imho) is not using arrays but using an ArrayList. In all honesty, there is very little reason to use arrays over an ArrayList and generics is just one example of that.

For a better and more complete explanation see the (excellent) Java Generics FAQ:

Can I create an array whose component type is a concrete parameterized type?

No, 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[].

...

Answer 2

The other answers here generally all advocate a better approach for this (especially the recommendation to use an ArrayList instead), but a simple answer in this specific case could be to do:

hashTable = (T[])(new Comparable[tableSize]);

(i.e. create an array of type raw Comparable instead of Object)

If you properly encapsulate all access to this array inside your Hash object this should work, but (as the other answers explain) you could leave yourself vulnerable.

Answer 3

The cast you're attempting

(T[])(new Object[tableSize]);

fails, because the items in the array are instances of Object. Object does not extend Comparable<String>, so the cast (T[]) fails because T is defined as:

T extends Comparable<String>

To resolve this problem either:

• Instantiate the array so that it's items are instances of some class that does extend Comparable<String>
• Change hashTable from an Array (which is not a generic type), to a generic collection type, e.g. List<T> hashTable = new ArrayList<T>(tableSize>)

Answer 4

You often run into problems when you need to instantiate something of a generic type. The easiest way to get around this is to pass the class of actually will be stored in on the constructor. This way you can construct from the actual type. Try something like this:

public class Hash<T extends Comparable<String>>
{
  Hash(int records, double load, Class<T> class)
  {
    tableSize = (int)(records / loadFactor);
    tableSize = findNextPrime(tableSize);

    hashTable = java.lang.reflect.Array.newInstance(class, tableSize);
  }

private T[] hashTable;
private int tableSize;

}

Answer 5

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<K>[] 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.