Obtenir le type générique de java.util.List

Question

J'ai;

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

est-il un moyen (facile) pour récupérer le type générique de la liste?

Answer 1

Si ceux-ci sont en fait des champs d'une certaine classe, alors vous pouvez les obtenir avec un peu d'aide de la réflexion:

package test; 

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

public class Test { 

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

    public static void main(String... args) throws Exception { 
     Field stringListField = Test.class.getDeclaredField("stringList"); 
     ParameterizedType stringListType = (ParameterizedType) stringListField.getGenericType(); 
     Class<?> stringListClass = (Class<?>) stringListType.getActualTypeArguments()[0]; 
     System.out.println(stringListClass); // class java.lang.String. 

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

Vous pouvez aussi le faire pour les types de paramètres et retourner type de méthodes. Mais s'ils sont dans la même portée de la classe/méthode que vous avez besoin de connaître, alors il est inutile de les connaître, parce que vous les avez déjà déclarés.

Answer 2

Réponse courte: non.

Ceci est probablement un doublon, ne peut pas trouver un approprié en ce moment.

Java utilise quelque chose appelé effacement de type, ce qui signifie qu'à l'exécution les deux objets sont équivalents. Le compilateur sait que les listes contiennent des entiers ou des chaînes, et en tant que tel peut maintenir un environnement de type sécurisé. Cette information est perdue (sur une base d'instance d'objet) lors de l'exécution, et la liste contient uniquement des 'objets'.

Vous pouvez en savoir un peu plus sur la classe, de quels types elle peut être paramétrée par, mais normalement c'est juste quelque chose qui étend "Object", c'est-à-dire n'importe quoi. Si vous définissez un type comme

class <A extends MyClass> AClass {....} 

AClass.class ne contiendra que le fait que le paramètre A est limité par MyClass, mais plus que cela, il n'y a aucun moyen de dire.

Answer 3

Le type est effacé de sorte que vous ne pourrez pas. Voir http://en.wikipedia.org/wiki/Type_erasure et http://en.wikipedia.org/wiki/Generics_in_Java#Type_erasure

Answer 4

Comme d'autres l'ont dit, la seule réponse est non, le type a été effacé.

Si la liste contient un nombre d'éléments différent de zéro, vous pouvez étudier le type du premier élément (en utilisant sa méthode getClass, par exemple). Cela ne vous dira pas le type générique de la liste, mais il serait raisonnable de supposer que le type générique était une superclasse des types dans la liste.

Je ne préconiserais pas l'approche, mais dans un lien il pourrait être utile.

Answer 5

Généralement impossible, car List<String> et List<Integer> partagent la même classe d'exécution.

Vous pourriez peut-être réfléchir sur le type déclaré du champ contenant la liste (si le type déclaré ne fait pas référence lui-même à un paramètre de type dont vous ne connaissez pas la valeur).

Answer 6

Lors de l'exécution, non, vous ne pouvez pas.

Cependant, par réflexion, les paramètres de type sont accessibles. Essayez

for(Field field : this.getDeclaredFields()) { 
    System.out.println(field.getGenericType()) 
} 

La méthode getGenericType() retourne un objet de type.Dans ce cas, ce sera une instance de ParametrizedType, qui à son tour a les méthodes getRawType() (qui contiendra List.class, dans ce cas) et getActualTypeArguments(), qui renverra un tableau (dans ce cas, de longueur 1, contenant String.class ou Integer.class).

Answer 7

Vous pouvez faire la même chose pour les paramètres de la méthode ainsi:

Type[] types = method.getGenericParameterTypes(); 
//Now assuming that the first parameter to the method is of type List<Integer> 
ParameterizedType pType = (ParameterizedType) types[0]; 
Class<?> clazz = (Class<?>) pType.getActualTypeArguments()[0]; 
System.out.println(clazz); //prints out java.lang.Integer 

Answer 8

import org.junit.Assert; 
import org.junit.Test; 

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

public class GenericTypeOfCollectionTest { 
    public class FormBean { 
    } 

    public class MyClazz { 
     private List<FormBean> list = new ArrayList<FormBean>(); 
    } 

    @Test 
    public void testName() throws Exception { 
     Field[] fields = MyClazz.class.getFields(); 
     for (Field field : fields) { 
      //1. Check if field is of Collection Type 
      if (Collection.class.isAssignableFrom(field.getType())) { 
       //2. Get Generic type of your field 
       Class fieldGenericType = getFieldGenericType(field); 
       //3. Compare with <FromBean> 
       Assert.assertTrue("List<FormBean>", 
        FormBean.class.isAssignableFrom(getFieldGenericTypefieldGenericType)); 
      } 
     } 
    } 

    //Returns generic type of any field 
    public Class getFieldGenericType(Field field) { 
     if (ParameterizedType.class.isAssignableFrom(field.getGenericType().getClass())) { 
      ParameterizedType genericType = 
      (ParameterizedType) field.getGenericType(); 
      return ((Class) 
       (genericType.getActualTypeArguments()[0])).getSuperclass(); 
     } 
     //Returns dummy Boolean Class to compare with ValueObject & FormBean 
     return new Boolean(false).getClass(); 
    } 
} 

Answer 9

Le type générique d'une collection ne devrait affaire si elle a fait des objets en elle, non? Alors, est-il pas plus facile de le faire:

Collection<?> myCollection = getUnknownCollectionFromSomewhere(); 
Class genericClass = null; 
Iterator it = myCollection.iterator(); 
if (it.hasNext()){ 
    genericClass = it.next().getClass(); 
} 
if (genericClass != null) { //do whatever we needed to know the type for 

Il n'y a pas une telle chose comme un type générique dans l'exécution, mais les objets à l'intérieur à l'exécution sont garantis d'être le même type que déclaré générique, il est donc assez facile juste pour tester la classe de l'élément avant de le traiter.