Double Generic Instantiation in Java

Question

I have a class that uses generics. Because it needs a reference to the generic type, the constructor has a Class parameter (as discussed in this question), so it looks like this:

MyGenericClass<T>
public MyGenericClass( final Class<T> valueClass ) {
    this.clazz = valueClass;
}

Now I want to pass MyGenericClass as the T, but I can't get it working.

MyGenericClass<MyGenericClass<String>> foo = 
        new MyGenericClass<MyGenericClass<String>>(MyGenericClass<String>.class);

is giving me a compiler error.

It looks like it's a problem of Type Erasure (see this SO question). With this dual layer of generics, I'm not sure if it's possible to do what I want to do.

Any suggestions?

UTA:

I can't post the entire code because it's corporate code and I'm not sure of the rules of posting. The class is essentially a MultipleValueMap that maps a single key to a list of values. The class object is used to create a typed array of the values in the list (using list.toArray(T[]))

In this case, I want to have a key that maps to more than one list of values. And that's causing the issue.

Answer 1

Generics begin to break down in a situation such as this. List<String> is a type but not a class, so there's only a List.class.

Guava's TypeToken was created for these situations.

class MyGenericClass<T> {
    private Class<T> raw;

    /* the code in this constructor
     * has similar semantics to e.g.
     *  MyGenericClass<String>[] arr = new MyGenericClass[10];
     * when passing a
     *  new TypeToken<MyGenericClass<String>>() {}
     */
    MyGenericClass(TypeToken<T> type) {
        @SuppressWarnings("unchecked")
        final Class<T> unchecked = (Class<T>) type.getRawType();
        raw = unchecked;

        @SuppressWarnings("unchecked")
        T[] arr = (T[]) Array.newInstance(type, 10);
        //
    }
}

MyGenericClass<MyGenericClass<String>> g =
    new MyGenericClass<>(new TypeToken<MyGenericClass<String>>() {});

Otherwise your options are a bit limited. There are kludgy options:

MyGenericClass<MyGenericClass<String>> g =
    new MyGenericClass<MyGenericClass<String>>(
        (Class) MyGenericClass.class);

Also possibly changing Class<T> to Class<? extends T> and passing a subclass (which I see somebody's already posted so I won't bother to repeat it).

If you don't need to return the array to the outside world, you could do:

class MyGenericClass<T> {
    private Class<? super T> maybeSuper;

    MyGenericClass(Class<? super T> maybeSuper) {
        this.maybeSuper = maybeSuper;

        // array which accepts T
        Object[] arr = (Object[]) Array.newInstance(maybeSuper, 10);
    }
}

Then you can do:

MyGenericClass<MyGenericClass<String>> g =
    new MyGenericClass<MyGenericClass<String>>(
        MyGenericClass.class);

because the raw type is a supertype of a parameterized type.

Answer 2

I don't think you want to use Class. This expects a Class object.

Just use T or Object<T> instead if Class. This is what it seems like you want from your example

Answer 3

From what I've seen, it seems to me, that you want to instantiate Class<MyGenericClass<String>> in some way like MyGenericClass<String>.class. This way is prohibited and you have to use another option: you may accept Class<? extends T> as a parameter for constructor and create something like inner class, which extends generic class with concrete generification:

private static class MGCString extends MyGenericClass<String> {
}

and instantiate your new member as

MyGenericClass<MyGenericClass<String>> foo = new MyGenericClass<>(MGCString.class);

Note from @Radiodef: This depends on what you are doing with the array you create. If you want to put e.g. a new GenericClass<String>(String.class) into the array, then this doesn't work. (It throws array store exception.) If you are instantiating the elements with reflection too (through class.newInstance(), for example) then possibly it works.

AFTER UPDATE

Since you've posted the update for the question, I can now answer your question :) The usual way to convert List to array is to move List's elements to some array, which is provided by user.

For example, we can look at List.toArray(T[]). This method puts all of the list's elements into passed array in case it is big enough. Else it creates new array (yes, we can get its type by running a.getClass()).

Also, in Java 8, Streams API introduced the brand new way to do the same thing: to provide the generator for T[]:

//get new Stream<String>, for example, someway
        .toArray(String[]::new)

You can add this ability to your code, if you create some method, which accepts IntFunction<T[]> arrayGenerator and runs arrayGenerator.apply(list.size()) to get the array of requested size.

Answer 4

You can do it, sort of..,

Your basic problem is that the type T of Class<T> can not itself be generic, that is:

Class<List> a; // OK
Class<List<String>> b; // can't do this

But! You can get around this by creating a type to prepresent the typed type, eg:

interface StringList extends List<String> {}
Class<? extends StringList> c; OK!

Translating this to your situation, you would have to create an interface to prepresent MyGenericClass (to avoid the constructor problem in the abstract type) then have subtypes of that and pass those in to your constructors.

Answer 5

It kind of depends on what your purpose is.

You can get an expression of type Class<MyGenericClass<String>> by doing some unsafe casting of MyGenericClass.class:

(Class<MyGenericClass<String>>)(Class<?>)MyGenericClass.class

But is this really what you want? Why need the unsafe casts?

In some sense, you can't "truly" have a Class<MyGenericClass<String>>, because Class<T> can check at runtime whether a given object is type T, with its .isIntance() method, but you can never check an object's generic type arguments at runtime because it's erased. For some purposes however, it may be good enough to "pretend" that MyGenericClass.class (of type Class<MyGenericClass>) is a Class<MyGenericClass<String>> (which is what the unsafe casts above are doing).

So it comes down to what your function does with the class object. From your description, you say "The class object is used to create a typed array of the values in the list (using list.toArray(T[]))". As you know, generic array creation is not allowed in Java. So even if you were working with the concrete class directly instead of T, you still couldn't do new MyGenericClass<String>[42]. The best you can do is (MyGenericClass<String>[])new MyGenericClass[42] or (MyGenericClass<String>[])new MyGenericClass<?>[42]. In other words, you are creating the array using the raw-type class, and then "pretending" that the created array is an array of the parameterized type using unsafe casts.

This is analogous to the casts above with the class object:

(Class<MyGenericClass<String>>)(Class<?>)MyGenericClass.class

-- you are using the raw-type class object, and then "pretending" that the class is of the parameterized type using unsafe casts, so that when you make the array you will think it's an array of the parameterized type.