通常情况下，我看到人们使用这样的类文字：
Class<Foo> cls = Foo.class;
但是如果类型是通用的，例如名单？这工作正常，但有一个警告，因为List应该参数化：
Class<List> cls = List.class
那为什么不添加<?>？好吧，这会导致类型不匹配错误：
Class<List<?>> cls = List.class
我认为这样的东西会起作用，但这只是一个简单的语法错误：
Class<List<Foo>> cls = List<Foo>.class
如何静态获取Class<List<Foo>>，例如使用类文字吗？
我可以使用@SuppressWarnings("unchecked")来摆脱第一个示例Class<List> cls = List.class中非参数化使用List引起的警告，但我不想
有什么建议吗？
答案 0 :(得分：143)
你不能归因于type erasure。
Java泛型仅仅是Object强制转换的语法糖。为了证明：
List<Integer> list1 = new ArrayList<Integer>();
List<String> list2 = (List<String>)list1;
list2.add("foo"); // perfectly legal
如果通过反射询问类的成员，那么在运行时保留泛型类型信息的唯一实例是Field.getGenericType()。
所有这些都是Object.getClass()有这个签名的原因：
public final native Class<?> getClass();
重要的部分是Class<?>。
换句话说，来自Java Generics FAQ：
为什么没有具体参数化类型的类文字？
因为参数化类型没有确切的运行时类型表示。
一个文字表示
Class表示给定类型的对象。 例如，类文字String.class表示Class表示类型的对象String与...相同 {。1}}时返回的对象 方法Class在a上调用getClass对象。一个类文字可以 用于运行时类型检查和 反思。参数化类型会丢失其类型 它们被翻译成时的参数 编译期间的字节代码 过程称为类型擦除。作为一个 所有类型擦除的副作用 泛型类型共享的实例化 相同的运行时表示， 即相应的原始 类型。换句话说，参数化 类型没有类型表示 他们自己的。因此，有 形成阶级文字没有意义 例如
String，List<String>.class和List<Long>.class，因为不存在这样的List<?>.class个对象。 只有原始类型Class才有List表示其运行时的对象 类型。它被称为Class。
答案 1 :(得分：52)
参数化类型没有类文字，但有些对象可以正确定义这些类型。
请参阅java.lang.reflect.ParameterizedType - http://java.sun.com/j2se/1.5.0/docs/api/java/lang/reflect/ParameterizedType.html
Google的Gson库定义了一个TypeToken类，它允许简单地生成参数化类型，并使用它以通用友好的方式指定具有复杂参数化类型的json对象。在您的示例中，您将使用：
Type typeOfListOfFoo = new TypeToken<List<Foo>>(){}.getType()
我打算发布指向TypeToken和Gson类javadoc的链接，但Stack Overflow不允许我发布多个链接，因为我是新用户，您可以使用Google搜索轻松找到它们
答案 2 :(得分：45)
您可以使用双重演员管理它：
@SuppressWarnings("unchecked")
Class<List<Foo>> cls = (Class<List<Foo>>)(Object)List.class
答案 3 :(得分：6)
为了阐述cletus的答案，在运行时删除了泛型类型的所有记录。泛型仅在编译器中处理，用于提供额外的类型安全性。它们实际上只是简写，允许编译器在适当的位置插入类型转换。例如，以前您必须执行以下操作：
List x = new ArrayList();
x.add(new SomeClass());
Iterator i = x.iterator();
SomeClass z = (SomeClass) i.next();
变为
List<SomeClass> x = new ArrayList<SomeClass>();
x.add(new SomeClass());
Iterator<SomeClass> i = x.iterator();
SomeClass z = i.next();
这允许编译器在编译时检查你的代码，但在运行时它仍然看起来像第一个例子。
答案 4 :(得分：2)
我们都知道它会被删除。但是在类层次结构中明确提到类型的某些情况下可以知道它：
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;
public abstract class CaptureType<T> {
/**
* {@link java.lang.reflect.Type} object of the corresponding generic type. This method is useful to obtain every kind of information (including annotations) of the generic type.
*
* @return Type object. null if type could not be obtained (This happens in case of generic type whose information cant be obtained using Reflection). Please refer documentation of {@link com.types.CaptureType}
*/
public Type getTypeParam() {
Class<?> bottom = getClass();
Map<TypeVariable<?>, Type> reifyMap = new LinkedHashMap<>();
for (; ; ) {
Type genericSuper = bottom.getGenericSuperclass();
if (!(genericSuper instanceof Class)) {
ParameterizedType generic = (ParameterizedType) genericSuper;
Class<?> actualClaz = (Class<?>) generic.getRawType();
TypeVariable<? extends Class<?>>[] typeParameters = actualClaz.getTypeParameters();
Type[] reified = generic.getActualTypeArguments();
assert (typeParameters.length != 0);
for (int i = 0; i < typeParameters.length; i++) {
reifyMap.put(typeParameters[i], reified[i]);
}
}
if (bottom.getSuperclass().equals(CaptureType.class)) {
bottom = bottom.getSuperclass();
break;
}
bottom = bottom.getSuperclass();
}
TypeVariable<?> var = bottom.getTypeParameters()[0];
while (true) {
Type type = reifyMap.get(var);
if (type instanceof TypeVariable) {
var = (TypeVariable<?>) type;
} else {
return type;
}
}
}
/**
* Returns the raw type of the generic type.
* <p>For example in case of {@code CaptureType<String>}, it would return {@code Class<String>}</p>
* For more comprehensive examples, go through javadocs of {@link com.types.CaptureType}
*
* @return Class object
* @throws java.lang.RuntimeException If the type information cant be obtained. Refer documentation of {@link com.types.CaptureType}
* @see com.types.CaptureType
*/
public Class<T> getRawType() {
Type typeParam = getTypeParam();
if (typeParam != null)
return getClass(typeParam);
else throw new RuntimeException("Could not obtain type information");
}
/**
* Gets the {@link java.lang.Class} object of the argument type.
* <p>If the type is an {@link java.lang.reflect.ParameterizedType}, then it returns its {@link java.lang.reflect.ParameterizedType#getRawType()}</p>
*
* @param type The type
* @param <A> type of class object expected
* @return The Class<A> object of the type
* @throws java.lang.RuntimeException If the type is a {@link java.lang.reflect.TypeVariable}. In such cases, it is impossible to obtain the Class object
*/
public static <A> Class<A> getClass(Type type) {
if (type instanceof GenericArrayType) {
Type componentType = ((GenericArrayType) type).getGenericComponentType();
Class<?> componentClass = getClass(componentType);
if (componentClass != null) {
return (Class<A>) Array.newInstance(componentClass, 0).getClass();
} else throw new UnsupportedOperationException("Unknown class: " + type.getClass());
} else if (type instanceof Class) {
Class claz = (Class) type;
return claz;
} else if (type instanceof ParameterizedType) {
return getClass(((ParameterizedType) type).getRawType());
} else if (type instanceof TypeVariable) {
throw new RuntimeException("The type signature is erased. The type class cant be known by using reflection");
} else throw new UnsupportedOperationException("Unknown class: " + type.getClass());
}
/**
* This method is the preferred method of usage in case of complex generic types.
* <p>It returns {@link com.types.TypeADT} object which contains nested information of the type parameters</p>
*
* @return TypeADT object
* @throws java.lang.RuntimeException If the type information cant be obtained. Refer documentation of {@link com.types.CaptureType}
*/
public TypeADT getParamADT() {
return recursiveADT(getTypeParam());
}
private TypeADT recursiveADT(Type type) {
if (type instanceof Class) {
return new TypeADT((Class<?>) type, null);
} else if (type instanceof ParameterizedType) {
ArrayList<TypeADT> generic = new ArrayList<>();
ParameterizedType type1 = (ParameterizedType) type;
return new TypeADT((Class<?>) type1.getRawType(),
Arrays.stream(type1.getActualTypeArguments()).map(x -> recursiveADT(x)).collect(Collectors.toList()));
} else throw new UnsupportedOperationException();
}
}
public class TypeADT {
private final Class<?> reify;
private final List<TypeADT> parametrized;
TypeADT(Class<?> reify, List<TypeADT> parametrized) {
this.reify = reify;
this.parametrized = parametrized;
}
public Class<?> getRawType() {
return reify;
}
public List<TypeADT> getParameters() {
return parametrized;
}
}
现在你可以做以下事情：
static void test1() {
CaptureType<String> t1 = new CaptureType<String>() {
};
equals(t1.getRawType(), String.class);
}
static void test2() {
CaptureType<List<String>> t1 = new CaptureType<List<String>>() {
};
equals(t1.getRawType(), List.class);
equals(t1.getParamADT().getParameters().get(0).getRawType(), String.class);
}
private static void test3() {
CaptureType<List<List<String>>> t1 = new CaptureType<List<List<String>>>() {
};
equals(t1.getParamADT().getRawType(), List.class);
equals(t1.getParamADT().getParameters().get(0).getRawType(), List.class);
}
static class Test4 extends CaptureType<List<String>> {
}
static void test4() {
Test4 test4 = new Test4();
equals(test4.getParamADT().getRawType(), List.class);
}
static class PreTest5<S> extends CaptureType<Integer> {
}
static class Test5 extends PreTest5<Integer> {
}
static void test5() {
Test5 test5 = new Test5();
equals(test5.getTypeParam(), Integer.class);
}
static class PreTest6<S> extends CaptureType<S> {
}
static class Test6 extends PreTest6<Integer> {
}
static void test6() {
Test6 test6 = new Test6();
equals(test6.getTypeParam(), Integer.class);
}
class X<T> extends CaptureType<T> {
}
class Y<A, B> extends X<B> {
}
class Z<Q> extends Y<Q, Map<Integer, List<List<List<Integer>>>>> {
}
void test7(){
Z<String> z = new Z<>();
TypeADT param = z.getParamADT();
equals(param.getRawType(), Map.class);
List<TypeADT> parameters = param.getParameters();
equals(parameters.get(0).getRawType(), Integer.class);
equals(parameters.get(1).getRawType(), List.class);
equals(parameters.get(1).getParameters().get(0).getRawType(), List.class);
equals(parameters.get(1).getParameters().get(0).getParameters().get(0).getRawType(), List.class);
equals(parameters.get(1).getParameters().get(0).getParameters().get(0).getParameters().get(0).getRawType(), Integer.class);
}
static void test8() throws IllegalAccessException, InstantiationException {
CaptureType<int[]> type = new CaptureType<int[]>() {
};
equals(type.getRawType(), int[].class);
}
static void test9(){
CaptureType<String[]> type = new CaptureType<String[]>() {
};
equals(type.getRawType(), String[].class);
}
static class SomeClass<T> extends CaptureType<T>{}
static void test10(){
SomeClass<String> claz = new SomeClass<>();
try{
claz.getRawType();
throw new RuntimeException("Shouldnt come here");
}catch (RuntimeException ex){
}
}
static void equals(Object a, Object b) {
if (!a.equals(b)) {
throw new RuntimeException("Test failed. " + a + " != " + b);
}
}
更多信息here。但同样，几乎不可能找回：
class SomeClass<T> extends CaptureType<T>{}
SomeClass<String> claz = new SomeClass<>();
它被删除的地方。
答案 5 :(得分：1)
由于暴露的事实，类文字没有泛型类型信息，我认为你应该假设不可能摆脱所有的警告。在某种程度上，使用Class<Something>与使用集合而不指定泛型类型相同。我能得到的最好的是：
private <C extends A<C>> List<C> getList(Class<C> cls) {
List<C> res = new ArrayList<C>();
// "snip"... some stuff happening in here, using cls
return res;
}
public <C extends A<C>> List<A<C>> getList() {
return getList(A.class);
}
答案 6 :(得分：0)
您可以使用辅助方法来摆脱整个班级的@SuppressWarnings("unchecked")。
@SuppressWarnings("unchecked")
private static <T> Class<T> generify(Class<?> cls) {
return (Class<T>)cls;
}
然后你可以写
Class<List<Foo>> cls = generify(List.class);
其他用法示例
Class<Map<String, Integer>> cls;
cls = generify(Map.class);
cls = TheClass.<Map<String, Integer>>generify(Map.class);
funWithTypeParam(generify(Map.class));
public void funWithTypeParam(Class<Map<String, Integer>> cls) {
}
但是，由于它很少真正有用，并且该方法的使用会使编译器的类型检查失败，我不建议在公共可访问的地方实现它。
答案 7 :(得分：0)
Java Generics FAQ以及大叔的answer听起来好像没有任何意义Class<List<T>>，但是真正的问题在于这非常危险：
@SuppressWarnings("unchecked")
Class<List<String>> stringListClass = (Class<List<String>>) (Class<?>) List.class;
List<Integer> intList = new ArrayList<>();
intList.add(1);
List<String> stringList = stringListClass.cast(intList);
// Surprise!
String firstElement = stringList.get(0);
cast()使其看起来像是安全的，但实际上根本不安全。
尽管我不知道哪里没有List<?>.class = Class<List<?>>，因为当您有一种基于{{ 1}}参数。
对于Class，有JDK-6184881请求切换为使用通配符，但是由于它与以前的代码不兼容，因此看起来（很快）将不会执行此更改（请参见{{ 3}}）。