Obtener el tipo genérico de java.útil.Lista

También puede hacer lo mismo para los parámetros del método:

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

Respuesta corta: no.

Esto es probablemente un duplicado, no se puede encontrar uno apropiado en este momento.

Java usa algo llamado type erasure, lo que significa que en tiempo de ejecución ambos objetos son equivalentes. El compilador sabe que las listas contienen enteros o cadenas, y como tal puede mantener un entorno seguro de tipos. Esta información se pierde (en base a una instancia de objeto) en tiempo de ejecución, y la lista solo contiene 'Objetos'.

Puede averiguar un poco sobre la clase, qué tipos podría ser parametrizado por, pero normalmente esto es cualquier cosa que se extiende "Objeto", es decir, cualquier cosa. Si define un tipo como

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

AClass.class solo contendrá el hecho de que el parámetro A está limitado por MyClass, pero más que eso, no hay forma de saberlo.

Si necesita obtener el tipo genérico de un tipo devuelto, utilicé este enfoque cuando necesitaba encontrar métodos en una clase que devolviera un Collection y luego acceder a sus tipos genéricos:

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.List;

public class Test {

    public List<String> test() {
        return null;
    }

    public static void main(String[] args) throws Exception {

        for (Method method : Test.class.getMethods()) {
            Class returnClass = method.getReturnType();
            if (Collection.class.isAssignableFrom(returnClass)) {
                Type returnType = method.getGenericReturnType();
                if (returnType instanceof ParameterizedType) {
                    ParameterizedType paramType = (ParameterizedType) returnType;
                    Type[] argTypes = paramType.getActualTypeArguments();
                    if (argTypes.length > 0) {
                        System.out.println("Generic type is " + argTypes[0]);
                    }
                }
            }
        }

    }

}

Esto produce:

El tipo genérico es la clase java.lang.String

El tipo genérico de una colección solo debe importar si realmente tiene objetos en ella, ¿verdad? Así que no es más fácil simplemente hacer:

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

No hay tal cosa como un tipo genérico en tiempo de ejecución, pero los objetos dentro en tiempo de ejecución están garantizados para ser el mismo tipo que el genérico declarado, por lo que es bastante fácil probar la clase del elemento antes de procesarlo.

Para encontrar el tipo genérico de un campo:

((Class)((ParameterizedType)field.getGenericType()).getActualTypeArguments()[0]).getSimpleName()

Ampliando la respuesta de Steve K:

/** 
* Performs a forced cast.  
* Returns null if the collection type does not match the items in the list.
* @param data The list to cast.
* @param listType The type of list to cast to.
*/
static <T> List<? super T> castListSafe(List<?> data, Class<T> listType){
    List<T> retval = null;
    //This test could be skipped if you trust the callers, but it wouldn't be safe then.
    if(data!=null && !data.isEmpty() && listType.isInstance(data.iterator().next().getClass())) {
        @SuppressWarnings("unchecked")//It's OK, we know List<T> contains the expected type.
        List<T> foo = (List<T>)data;
        return retval;
    }
    return retval;
}
Usage:

protected WhateverClass add(List<?> data) {//For fluant useage
    if(data==null) || data.isEmpty(){
       throw new IllegalArgumentException("add() " + data==null?"null":"empty" 
       + " collection");
    }
    Class<?> colType = data.iterator().next().getClass();//Something
    aMethod(castListSafe(data, colType));
}

aMethod(List<Foo> foo){
   for(Foo foo: List){
      System.out.println(Foo);
   }
}

aMethod(List<Bar> bar){
   for(Bar bar: List){
      System.out.println(Bar);
   }
}

En tiempo de ejecución, no, no puedes.

Sin embargo, mediante reflexión, los parámetros de tipo son accesibles. Try

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

El método getGenericType() devuelve un objeto de Tipo. En este caso, será una instancia de ParametrizedType, que a su vez tiene métodos getRawType() (que contendrá List.class, en este caso) y getActualTypeArguments(), que devolverá un array (en este caso, de longitud uno, conteniendo String.class o Integer.class).

Generalmente imposible, porque List<String> y List<Integer> comparten la misma clase de tiempo de ejecución.

Sin embargo, es posible que pueda reflejar el tipo declarado del campo que contiene la lista (si el tipo declarado no se refiere a un parámetro de tipo cuyo valor no conoce).

Como otros han dicho, la única respuesta correcta es no, el tipo ha sido borrado.

Si la lista tiene un número distinto de cero de elementos, podría investigar el tipo del primer elemento ( usando su método getClass, por ejemplo ). Eso no le dirá el tipo genérico de la lista, pero sería razonable asumir que el tipo genérico fue alguna superclase de los tipos en la lista.

No abogaría por el enfoque, pero en un aprieto podría ser útil.

Tenía el mismo problema, pero usé instanceof en su lugar. Lo hizo de esta manera:

List<Object> listCheck = (List<Object>)(Object) stringList;
    if (!listCheck.isEmpty()) {
       if (listCheck.get(0) instanceof String) {
           System.out.println("List type is String");
       }
       if (listCheck.get(0) instanceof Integer) {
           System.out.println("List type is Integer");
       }
    }
}

Esto implica el uso de moldes sin marcar, así que solo haga esto cuando sepa que es una lista y de qué tipo puede ser.

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();
    }
}

El tipo se borra, por lo que no podrá hacerlo. Ver http://en.wikipedia.org/wiki/Type_erasure y http://en.wikipedia.org/wiki/Generics_in_Java#Type_erasure

Use Reflexión para obtener el Field para estos, entonces puede hacer: field.genericType para obtener el tipo que contiene la información sobre genérico también.