How to Retrieve the Generic Type of a Java `List` Using Reflection?

Retrieving the Generic Type of a Java.util.List

In Java, a generic type parameter allows a class or interface to operate on data of different types. For example, a List can store elements of any type. To access the generic type of a List, one can utilize Java Reflection.

Using Reflection to Obtain the Generic Type

The getGenericType() method of the Field class returns the generic type of the field. For a List field, this is a ParameterizedType. To extract the actual generic type, cast the ParameterizedType to the type of the list.

The following code demonstrates how to retrieve the generic type of a List using reflection:

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

public class GetGenericType {

    List<String> stringList = new ArrayList<>();
    List<Integer> integerList = new ArrayList<>();

    public static void main(String[] args) throws Exception {
        Class<GetGenericType> clazz = GetGenericType.class;

        Field stringListField = clazz.getDeclaredField("stringList");
        ParameterizedType stringListType = (ParameterizedType) stringListField.getGenericType();
        Class<?> stringListClass = stringListType.getActualTypeArguments()[0];
        System.out.println(stringListClass); // class java.lang.String

        Field integerListField = clazz.getDeclaredField("integerList");
        ParameterizedType integerListType = (ParameterizedType) integerListField.getGenericType();
        Class<?> integerListClass = integerListType.getActualTypeArguments()[0];
        System.out.println(integerListClass); // class java.lang.Integer
    }
}

In this example, the getGenericType() method is used to retrieve the generic type of the stringList and integerList fields, which are instances of ParameterizedType. Accessing the getActualTypeArguments() method of these types returns the actual generic types, which are printed as String and Integer respectively.

It's important to note that reflection can be expensive and should only be used when necessary. In the context of your code, if the generic types of stringList and integerList are already known or can be inferred in the current scope, using reflection is unnecessary. However, reflection can be useful when working with generic types that are dynamically created or unknown at compile time.

The above is the detailed content of How to Retrieve the Generic Type of a Java `List` Using Reflection?. For more information, please follow other related articles on the PHP Chinese website!