Infer class type from a generic

Question

In the following class I want to assign the attribute clazz class type inferring it from the list given in the constructor.

class Foo<T> {
    private Class<T> clazz;

    Foo(List<T> list) {
        //this.clazz = tipo da classe inferido a partir da lista
    }

    ...
}

My first attempt was to use the method list.getClass() which proved to be wrong, because the value returned by the method was java.util.ArrayList.

How to infer the type of a bean informed in an Arraylist? It is possible to make this type of inference from the parameter, as in the example? If yes, how it would be? If not, which possibilities exist, or how to adjust this class so as to assign the correct value to the attribute clazz?

Answer 1

One possible trick is to change an instance of your class:

Foo<Integer> x = new Foo<Integer>(new ArrayList<Integer>());

By a subclass of her (in this case an anonymous class):

Foo<Integer> x = new Foo<Integer>(new ArrayList<Integer>()){}; 
//                                             Repare no {} ^

Done this you can use the strategy mentioned in Soen’s reply to infer the generic types of the superclass:

this.clazz = (Class<T>) ((ParameterizedType) getClass()
            .getGenericSuperclass()).getActualTypeArguments()[0];

In your case by definition the superclass type will be the list type.

How to instantiate the class directly will throw an error in Runtime is worth making Foo abstract:

abstract class Foo<T> {
    private final Class<T> clazz;

    public Foo(List<T> list) {
        this.clazz = (Class<T>) ((ParameterizedType) getClass()
                .getGenericSuperclass()).getActualTypeArguments()[0];
    }
}

Alternatively we can use the same strategy with the list:

this.clazz = (Class<T>) ((ParameterizedType) list.getClass()
        .getGenericSuperclass()).getActualTypeArguments()[0];
// ... 
List<Integer> t = new ArrayList<Integer>(){};
FooII<Integer> x = new FooII<>(t);

But this seems even more confusing (anonymous subclasses of ArrayList???).

---

Of course this strategy has limitations... The main one is that <T> has to be a real kind. If you build Foo other generic type the Casts will fail.

Functional version in Ideone

Answer 2

Apparently it is not possible to catch the type of the list at runtime, what to do is to check if she has any objeto inserted and catch the type of it. Example:

private Class clazz;

Foo(List<T> list) {
    this.clazz = (list != null && !list.isEmpty()) ? list.get(0).getClass() : null;
}

Example 1

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("1");
    Foo f = new Foo(list); // lista populada
    System.out.println(f.getClazz());
}

class java.lang.String

-

Example 2

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    Foo f = new Foo(list); // lista vazia
    System.out.println(f.getClazz());
}

null

UPDATE

Another solution is to pass an extra parameter in the constructor, example:

Foo(Class<T> typeClass, List<T> list) {
    this.clazz = typeClass;
    // ...
}

And to call:

new Foo(String.class, list);

Answer 3

Java does not maintain the type of Generic after the compilation (he makes such a "type Erasure"). In other words, the type of the parameter Generic (or "type Parameter") cannot be rescued at runtime.

There are some tricks that don’t work in all situations. So:

The usual way to read the type of a Generic at run time is not read the type of Generic at runtime, but to inform this type in a parameter.

For example, it would be nice if this code worked:

class AbstractFactory<T> {
    public T Create() {
        return T.newInstance(); // isso não funciona!!
    }
}
class CarroFactory extends AbstractFactory<Carro> {
}
...
CarroFactory carroFactory = new CarroFactory();
Carro carro = carroFactory.Create();

In the code above, my intention is to use Generic not only to keep the typed Factory, with proper compile time checks, but also to take advantage of the informed type as type Parameter Factory to create an instance of this type. This doesn’t work because the guy from type Parameter T will be lost after compilation.

So I have to do this:

class AbstractFactory<T> {
    private Class<T> type;
    public AbstractFactory(Class<T> type) {
        this.type = type; // no constutor eu peço o tipo do type parameter
    }
    public T Create() {
        // com o tipo que eu pedi no construtor eu posso criar uma instância
        return type.newInstance();
    }
}
class CarroFactory extends AbstractFactory<Carro> {
    // para poupar o consumidor desta tarefa,
    // eu informo aqui o tipo do type parameter
    public CarroFactory() {
        super(Carro.class);
    }
}
...
CarroFactory carroFactory = new CarroFactory();
Carro carro = carroFactory.Create();

Now, with a little more code and some redundancy, I have my Factory well typed and with the ability to create instances not of the type of type Parameter, but rather the kind I reported on the Factory builder.

Answer 4

• I believe it has already been well covered by all the answers the limitations of the type Erasure which is implemented by javac, i.e., type Generico has no way to be recovered directly.
• My intention then will be to show an alternative implementation to get these values in a very objective way:

The comparison in question will always be true because in time compilation both generic types are Erased by the compiler, however String.class != Integer.class

assert new ArrayList<String>().getClass() == new ArrayList<Integer>().getClass();

Now looking at this structure, it would be possible to get the type Source from the subclass Mystringsubclass seeking the information that is kept in the compiled bytecode <1.5 or more in the other will be ignored> .

class MyGenericClass<T> { }
class MyStringSubClass extends MyGenericClass<String> { }

First we would meet the superclass and later, we find the type Enerico obtaining the argument of the superclass.

ParameterizedType parameterizedType = (ParameterizedType) subClass.getGenericSuperclass();
Class<?> genericType = parameterizedType.getActualTypeArguments()[0];
assert genericType == String.class;

Remembering that this is a simplified demonstration, of a stylish hack to get the Generic type. However at API level the implementation would be more complex delivering the necessary coverage to several problematic scenarios.

The final recommendation is to use a great API for the Reflection of generic types: Generic type Reflection library for Java making you save a good time.

No more follows one more link with a high-level coverage of the subject, made by Rafael Winterhalter.