Java Reflection: How to obtain an instance of Class<T> from the ParameterizedType.getActualTypeArguments() array?

Question

What I'm trying to do is to get a generic typearg of a Field using

Type type = f.getGenericType();
if (type instanceof ParameterizedType) {
    ParameterizedType ptype = (ParameterizedType) type;
    // ...
    Class<?> typearg0 = ??? // ptype.getActualTypeArguments()[0]
}

(where f is an instance of java.lang.Field ). I need that instance of Class<?> to perform a Foo.class.isAssignableFrom(typearg0) check later, which only takes Class<T> es as an argument. At the same time, I know (or expect) said typearg0 to be a parameterized type as well , so there's a contradiction: typearg0 cannot be Class<?> and ParameterizedType at the same time, because Class<?> is itself a class and does not implement ParameterizedType .

Can I achieve the isAssignableFrom() check in any other way? Or is my goal generally impossible to achieve?

Thank you very much!

Edit:

Here is an example:

Suppose you expect a Field of type Map<Foo, Set<Bar>> , but all you got is a java.lang.reflect.Field instance. Now, you don't want it to precisely match Map<Foo, Set<Bar>> , you just want the respective types to be instances of Map or Set . It is not a rigid specification check, it's more of a "sanity check". I would attempt this check like this:

1. Get the field type as a class ( .getType() )
2. Check whether Map is assignable from the field type
3. Get the field type as a (possibly) parameterized type ( .getGenericType() )
4. Check that the first generic parameter is Foo (this should be an exact match)
5. Get the second generic parameter as a class
6. Check whether Set is assignable from this nested type
7. Check whether the nested type is itself a ParameterizedType and cast it
8. Check that the first generic parameter of the nested type is Bar (this should be an exact match)

However, I don't know how to achieve 5 and/or 6.

(using java 11)

Answer 1

Just like you've done with Map , Set is likely to be an instance of ParameterizedType so you can check it and then cast it.

From that ParameterizedType (which represents the Set<Something> ), you can get use getRawType to get a Set . That's a Type too -- but this should be safely castable to Class . Just in case it's not, you can use a fallback and load the class using its name.

final Type valueType = mapType.getActualTypeArguments()[1];
final ParameterizedType pValueType = (ParameterizedType) valueType;
final Class<?> valueClass = pValueType.getRawType() instanceof Class ?
    ((Class<?>) pValueType.getRawType()) :
    // Should be castable, but just in case it's not, fallback
    getClass().getClassLoader().loadClass(
        pValueType.getRawType().getTypeName()
    );
if (Set.class.isAssignableFrom(valueClass)) { /* do something*/ }

Here's a full runnable example .

class Foo {}
class Bar {}
interface MyValidMap extends Map<Foo, Set<Bar>> {}

public class Application {
    public final HashMap<Foo, HashSet<Bar>> good = null;
    public final Map<Foo, Set<Bar>> better = null;
    public final String notAMap = null;
    public final Map<String, Set<Bar>> badKey = null;
    public final Map<Foo, List<String>> badValue = null;
    public final Map<Foo, Set<String>> badSetElems = null;
    public final MyValidMap noTypeParamMap = null;

    public static void main(String[] args) throws Exception {
        for (Field field : Application.class.getFields()) {
            System.out.println(field.getName() + " - " + fieldMatches(field));
        }
    }

    private static String fieldMatches(Field mapField) throws Exception {
        if (!Map.class.isAssignableFrom(mapField.getType())) {
            return "Field is not a Map";
        }

        if (!(mapField.getGenericType() instanceof ParameterizedType)) {
            // We know it's a map, but it doesn't have type params. Probably something
            // like this: class MyStringMap implements Map<String, String>. You can do
            // something with getGenericInterfaces() but this seems so unlikely that
            // it could just be ignored.
            return "TODO";
        }

        final ParameterizedType mapType = (ParameterizedType) mapField.getGenericType();
        final Type keyType = mapType.getActualTypeArguments()[0];
        final Type valueType = mapType.getActualTypeArguments()[1];
        if (Foo.class != keyType) {
            return "Map's key type is not Foo";
        }

        if (!(valueType instanceof ParameterizedType)) {
            // Same problem as above. May be a Set without type params
            return "Map's value is (probably) not a Set";
        }

        final ParameterizedType pValueType = (ParameterizedType) valueType;
        final Class<?> valueClass = pValueType.getRawType() instanceof Class ?
            ((Class<?>) pValueType.getRawType()) :
            Application.class.getClassLoader().loadClass(
                pValueType.getRawType().getTypeName()
            );

        if (!Set.class.isAssignableFrom(valueClass)) {
            return "Map's value is not a Set";
        }

        final Type setElemType = pValueType.getActualTypeArguments()[0];
        if (setElemType != Bar.class) {
            return "Set's elements are not Bars";
        }
        return "Looks good";
    }
}

Output:

good - Looks good
better - Looks good
notAMap - Field is not a Map
badKey - Map's key type is not Foo
badValue - Map's value is (probably) not a Set
badSetElems - Set's elements are not Bars
noTypeParamMap - TODO