how to use java reflection to get element type of List ?

[Edward Chen]

how to get element type for a list ?

for example
java.util.List<data.People> peopleList;

how to use java refection to get a List element type: data.People ?

Thanks.

[marc weber]

I don't think this can be done, because generic types apply only at compile time. At runtime, a List is simply a List.

See Generics - Type Erasure...

For instance, Box<String> is translated [at compile time] to type Box, which is called the raw type -- a raw type is a generic class or interface name without any type arguments. This means that you can't find out what type of Object a generic class is using at runtime.

[ September 20, 2007: Message edited by: marc weber ]

[Jim Yingst]

Ermmm... actually this can be done. The class file contains info about the generic types of its member variables - that info is necessary if/when you try to compile another class using classes in a jar file, for example. That info is also accessible via reflection. But only generics-related info is only available for the class in general - not for specific instances of the class. To make a concrete example:

import java.lang.reflect.Type;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
 
public class GenericTypeInfo {
    java.util.List<? extends Foo> fooList = new ArrayList<Bar>();
 
    public static void main(String[] args) throws Exception {
        Field field = GenericTypeInfo.class.getDeclaredField("fooList");
 
        Type type = field.getGenericType();
        System.out.println("type: " + type);
        if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            System.out.println("raw type: " + pt.getRawType());
            System.out.println("owner type: " + pt.getOwnerType());
            System.out.println("actual type args:");
            for (Type t : pt.getActualTypeArguments()) {
                System.out.println("    " + t);
            }
        }
 
        System.out.println();
 
        Object obj = field.get(new GenericTypeInfo());
        System.out.println("obj: " + obj);
        System.out.println("obj class: " + obj.getClass());
    }
 
    static class Foo {}
 
    static class Bar extends Foo {}
}

As you see, you can get info about the declared type of instance variable fooList. You can learn that it's a List<? extends Foo>. However, if you try to examine an actual instance that is referenced by that variable, the most you can learn is that it's (in this case) an ArrayList. You can't find out whether it's an ArrayList<Foo> or an ArrayList<Bar> or an ArrayList<? extends Bar>. That specific info doesn't exist for runtime instances of a generic class. It exists for the declared type of a field, or of a method parameter or return value - but not for actual instances of the objects that are represented or referenced by those fields, parameters or return values.

[marc weber]

Thanks, Jim!

[shwetank singh]

well..may be i am digging something very old here...but i want an answer for something similar available for java 1.4..or does anything similar exist?..
as for this..what's the reason for null ownerType when the program is run?

type: java.util.List<? extends GenericTypeInfo$Foo>
raw type: interface java.util.List
owner type: null
actual type args:
? extends GenericTypeInfo$Foo

obj: []
obj class: class java.util.ArrayList

[Jesper de Jong]

shwetank singh wrote:but i want an answer for something similar available for java 1.4..or does anything similar exist?..

No, because generics did not exist at all in Java 1.4.

shwetank singh wrote:as for this..what's the reason for null ownerType when the program is run?

Because the class that's being examined doesn't have an owner type. Lookup the API documentation of java.lang.reflect.ParameterizedType.getOwnerType().

[Gopi Chella]

Jim Thanks a lot !!! the example is very useful.

[shwetank singh]

Thanks Jesper..and Jim..for wonderful insight!
perhaps i could seek your comments on something similar..

..using reflection (java.lang.reflect) in JDK1.4, am trying to create a generic function to create a hibernate Criteria {this is not going to be a hibernate question }..the task is so organized that i've to write a very generic function that anyone can call and use by passing a reference of class {please read "object reference"} whose criteria has to be created.
now the question, i've an object of type A that has a List..the List contains objects of type B, C..etc. i wish to find out their type (of B,C,etc..) (similar to OwnerType here) at runtime.

do we have any way to make that possible in java 1.4?..to add to this, i can't use instanceOf test as the component in which this utility goes has no other knowledge than the Object being passed to it.

..again, please let me know if this should be posted as a new topic..am posting here for some inquisitive minds who may be looking out for this solution in java 1.4

much thanks!

[Rob Spoor]

In Java 1.4 all you can do is make a guess. You loop through all the elements and find out a common super class (worst case this will be java.lang.Object) or a number of common interfaces (0 or more). The common super class for any two classes X and Y is easy:
- if X is a direct or indirect super class of Y then it's X
- if Y is a direct or indirect super class of X then it's Y
- otherwise it's the common super class of X.getSuperclass() and Y.getSuperclass()

For interfaces it's also not that hard. You need to collect all interfaces a class implements using Class.getInterfaces() (don't forget the super classes!). Collect these in a Set. Do this for all elements, each time using Collection.retainAll. In pseudo code:

Iterator i = list.iterator();
Object first = i.next();
Set interfaces = getInterfaces(first.getClass()); // assumption: no element is null
while (i.hasNext())
{
    Object o = i.next();
    Set set = getInterfaces(o.getClass()); // assumption: no element is null
    interfaces.retainAll(set);
}
// interfaces now contains all common interfaces

Of course you can get multiple results, so you would have to take a pick.

[Neha Sumungla]

The solutions provided are good. I could also suggest that instead trying to get it from the List itself, check the List for null and obtain the first element if that's not the case.

Then depending on the instance returned you can use

if (List.get(0) instanceof MyCustomClass)

OR

if (superclass.class.isAssignableFrom(List.get(0).getClass() ))

OR

if (XYZ.class.equals(List.get(0).getClass() ))

Good Luck....

[Campbell Ritchie]

Welcome to the Ranch Neha Sumungla

[Paul Clapham]

shwetank singh,
Your post was moved to a new topic.

[Chuck Zheng]

Maybe there are some magic with "Field", I cannot get it working for a local variable (or parameter). for this code:

		List<String> key = new ArrayList<String>();
		System.out.println("key = " + key);
		Class<?> clazz = key.getClass();
		System.out.println("clazz = " + clazz);
		ParameterizedType superclass = (ParameterizedType) clazz.getGenericSuperclass();
		Type[] types = superclass.getActualTypeArguments();
		Class<?> actualdataType = null;
		if(types != null && types.length >0 && (types[0] instanceof Class<?>) ) {
			actualdataType = (Class<?>) (Class<?>) types[0];
		}
		System.out.println("actualdataType = " + actualdataType);

I get:

key = []
clazz = class java.util.ArrayList
actualdataType = null

see the "class" it has already erased info about String.

Does anyone know another solution or I did something wrong?

Thanks
Chuck

Jim Yingst wrote:Ermmm... actually this can be done. The class file contains info about the generic types of its member variables - that info is necessary if/when you try to compile another class using classes in a jar file, for example. That info is also accessible via reflection. But only generics-related info is only available for the class in general - not for specific instances of the class. To make a concrete example:

import java.lang.reflect.Type;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
 
public class GenericTypeInfo {
    java.util.List<? extends Foo> fooList = new ArrayList<Bar>();
 
    public static void main(String[] args) throws Exception {
        Field field = GenericTypeInfo.class.getDeclaredField("fooList");
 
        Type type = field.getGenericType();
        System.out.println("type: " + type);
        if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            System.out.println("raw type: " + pt.getRawType());
            System.out.println("owner type: " + pt.getOwnerType());
            System.out.println("actual type args:");
            for (Type t : pt.getActualTypeArguments()) {
                System.out.println("    " + t);
            }
        }
 
        System.out.println();
 
        Object obj = field.get(new GenericTypeInfo());
        System.out.println("obj: " + obj);
        System.out.println("obj class: " + obj.getClass());
    }
 
    static class Foo {}
 
    static class Bar extends Foo {}
}

As you see, you can get info about the declared type of instance variable fooList. You can learn that it's a List<? extends Foo>. However, if you try to examine an actual instance that is referenced by that variable, the most you can learn is that it's (in this case) an ArrayList. You can't find out whether it's an ArrayList<Foo> or an ArrayList<Bar> or an ArrayList<? extends Bar>. That specific info doesn't exist for runtime instances of a generic class. It exists for the declared type of a field, or of a method parameter or return value - but not for actual instances of the objects that are represented or referenced by those fields, parameters or return values.