Object []数组中泛型类的调用方法

Question

I have a generic class, called Node<E> and I'm trying to define a static method that will return an array of objects of this type. I understand that Java does not allow the creation of generic type arrays within a class so we have to create an Object array and pass our generic types through the object.

For an example of the code, let's define it as:

public static Object[] returnArray() {
    Object[] output;
    //code which adds Node<E> to output
    return output;

When I implement this code though, I am not able to:

• perform this class's methods on the objects within the array as they are of type Object
  • If Node<E> had a method .getVal() the following code results in an error:
    • Object[] nodes = Node.returnArray(head); nodes[0].getVal();
• cast and return method array to a Node<E>[] array, even when explicit of the type.
  • Node<Integer>[] nodes = (Node<Integer>[]) Node.returnArray(head);

So the only way I am currently accessing the methods of each node is by assigning them to a variable by casting:

Object[] nodes = Node.returnArray(head);
Node<Integer> returned1 = (Node<Integer>) nodes[0];
Node<Integer> returned2 = (Node<Integer>) nodes[1];

But you can see how redundant it gets as the code grows. Is there a better way to access generic objects passed to an array?

Answer 1

You can create generic arrays. You just need the Class object for that. Consider this overly complicated program for printing the number 6:

public class GenericClass<T> {

    T[] array;

    public GenericClass(int length, Class<T> clazz) {
        array = (T[]) java.lang.reflect.Array.newInstance(clazz, length);
    }

    public T get(int i) {
        return array[i];
    }

    public T set(int i, T val) {
        return array[i] = val;
    }

    public static void main(String... args) {
        GenericClass<Integer> example = new GenericClass<>(5, Integer.class);
        example.set(0, 6);
        System.out.println(example.get(0)); //Prints 6
    }
}

This way, the array you create is really of type T[] , not Object[] , so it's safe to use and even externalize. Another option, of course, is just to use a list.