通常不可能，因为List<String>和List<Integer>共享相同的运行时类。

不过，您可能能够反映包含列表的字段的声明类型(如果声明的类型本身并不引用您不知道其值的类型参数)。

扩展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;
        retval=foo;
    }
    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);
   }
}

简单的回答是:不。

这可能是复制品，现在找不到合适的。

Java使用类型擦除，这意味着在运行时两个对象是等价的。编译器知道列表包含整数或字符串，因此可以维护类型安全的环境。这些信息在运行时丢失(以对象实例为基础)，并且列表只包含“对象”。

你可以找到一些关于类的信息，它可能被参数化的类型，但通常这只是任何扩展“对象”的东西，即任何东西。如果将类型定义为

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

class将只包含参数A受MyClass限制的事实，但除此之外，没有办法告诉它。

正如其他人所说，唯一正确的答案是否定的，该类型已被删除。

如果列表的元素数目非零，则可以研究第一个元素的类型(例如，使用它的getClass方法)。这不会告诉您列表的泛型类型，但可以合理地假设泛型类型是列表中类型的某个超类。

我不提倡这种方法，但在遇到困难时，它可能会有用。

集合的泛型类型应该只在它实际上有对象时才重要，对吗?所以这样做不是更简单吗:

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

在运行时没有泛型类型这样的东西，但运行时内部的对象保证与声明的泛型是相同的类型，因此在处理它之前测试项的类非常容易。

您可以做的另一件事是简单地处理列表以获得正确类型的成员，忽略其他成员(或以不同的方式处理它们)。

Map<Class<?>, List<Object>> classObjectMap = myCollection.stream()
    .filter(Objects::nonNull)
    .collect(Collectors.groupingBy(Object::getClass));

// Process the list of the correct class, and/or handle objects of incorrect
// class (throw exceptions, etc). You may need to group subclasses by
// filtering the keys. For instance:

List<Number> numbers = classObjectMap.entrySet().stream()
        .filter(e->Number.class.isAssignableFrom(e.getKey()))
        .flatMap(e->e.getValue().stream())
        .map(Number.class::cast)
        .collect(Collectors.toList());

这将为您提供一个所有项目的列表，这些项目的类都是Number的子类，然后您可以根据需要对其进行处理。其余的项目被过滤到其他列表中。因为它们在地图中，所以您可以根据需要处理它们，或者忽略它们。

如果你想完全忽略其他类的项目，它会变得简单得多:

List<Number> numbers = myCollection.stream()
    .filter(Number.class::isInstance)
    .map(Number.class::cast)
    .collect(Collectors.toList());

你甚至可以创建一个实用工具方法来确保列表只包含那些匹配特定类的项:

public <V> List<V> getTypeSafeItemList(Collection<Object> input, Class<V> cls) {
    return input.stream()
            .filter(cls::isInstance)
            .map(cls::cast)
            .collect(Collectors.toList());
}

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

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