通用列表属性，获取通用类型

Question

I have a class that has a propery List<String> or List<SomeObject> .

I get the type of the property as this:

propertyClass = PropertyUtils.getPropertyType(currentObject, property);

What I want to do is check that the propertyClass is a List<SomeType> and get the class object for the type in the list. After this I will want to create an ArrayList of the given type and fill it with object of that type (all created dynamically, I will use this to dynamically load some data from a file).

Is there I way I can do this using reflection?

Answer 1

Generics are erased after compilation (due to type erasure ). So you can't use them at runtime.

Answer 2

I have a similar problem and I actually found a solution that works for me!

This can be done but it might be unreliable (ie it doesn't work in all situations). First you need to get the "Field" (via reflections). Then get the "GenericType". Then try to cast this to "ParameterizedType". This is possible if it actually has a parameter. Then get "ActualTypeArguments". Usually those are "Class"es, so you can cast them (if not you could try Class.forName(...)) and then you already have the type of the elements in the list.

However, this doesnt work if I do this:

class MyList extends List<String> {... }

And then later:

MyList list = new MyList(); // This would be List<String>

You'd actually need to inspect the type to see if it is a List and if it has a type declared in any class or interface. But there could be more than one and the type could be bound to many interfaces, not just one class. of course you could just ignore properties that aren't "List" and maybe throw a compiler error if there is one (I'll probably do just that).

Then there is the problem with wildcards: List list = ... All you can do is substitute it with "Object", but that isn't safe if you want to add elements to the list! (again, you could check that at compile time and throw an error if there are wildcards)

Another solution is to use a checked List (see Collections.checkedList(List, Class)) and try to get that type at runtime (you probably need reflection for that). This would work much better and would be much more robust than just generics.

Answer 3

I have found another answer by Bob Lee, Sven Mawson, and Jesse Wilson:

[public class TypeToken:] Represents a generic type T. Java doesn't yet provide a way to represent generic types, so this class does. Forces clients to create a subclass of this class which enables retrieval the type information even at runtime.

Source: http://google-gson.googlecode.com/svn/trunk/gson/docs/javadocs/com/google/gson/reflect/TypeToken.html

There even is an example using List<String> and it really works. The TypeToken will have a rawType of java.util.List and typeArguments is set to [java.lang.String] . There is no type erasure here! However it does also not work for wildcards such as List<? extends Foo> List<? extends Foo> .

Note that this is a bit different from the other solution I explained in my other answer. Here you don't analyze a property on a java bean to get the type information. Here you actually create a field that stores the type information. I can't find any public constructor or factory method to create a TypeToken from type information that you got some other way. So I guess it really can only be used as an empty anonymous inner class.