为什么在运行时创建泛型 List 不绑定正确的数据类型？

Question

I am trying to create a generic method that returns a generic list with a given data type.

I have passed Integer as data type and I filled with String with no issue at runtime.

My question why I didn't receive ClassCastException during the Runtime?

    public static void main(String[] args) {
        List<Integer> list = (List<Integer>) generic(Integer.class);
        System.out.println(list);
    }

    private static <T> List<?> generic(T clazz) {
        List<T> list = new ArrayList<>();
        list.add((T) Arrays.asList("create", "generic"));
        list.add((T) Arrays.asList("create", "generic2"));
        return list;
    }

, output

[[create, generic], [create, generic2]]

Answer 1

Due to type erasure , not every violation of the generic type system is identified at runtime. This situation is also called heap pollution . But you should have received “unchecked” warnings from the compiler.

But your assumption that you create a List<Integer> is wrong anyway. You are passing Integer.class as argument for the T clazz parameter, hence, T is not Integer but Class<Integer> .

A correct generic declaration would be:

public static void main(String[] args) {
    List<Integer> list = generic(Integer.class);
    System.out.println(list);
}

private static <T> List<T> generic(Class<T> clazz) {
    List<T> list = new ArrayList<>();
    return list;
}

Now that the program is free of “unchecked” warnings, you can be sure that no heap pollution will occur at runtime. If you want more guarantees, you can use

public static void main(String[] args) {
    List<Integer> list = generic(Integer.class);
    System.out.println(list);
}

private static <T> List<T> generic(Class<T> clazz) {
    List<T> list = Collections.checkedList(new ArrayList<>(), clazz);
    list.add((T) Arrays.asList("create", "generic")); // will fail at runtime
    list.add((T) Arrays.asList("create", "generic2"));
    return list;
}

However, when you listen and respond to the compiler warnings, you don't need the additional runtime checks.

Answer 2

As you have declared T as <T> the runtime type-checking of (T) is against Object . Therefore, the cast from a List is fine.

List is declared as List<E> , so there can be no additional internal runtime type-checking from List.add . Likewise for List.toString .

You will, however, get warnings (so long as the lint option is enabled in your compiler). Don't ignore the warnings.

You can use clazz.cast in place of T , though T cannot usefully be a parameterised type.

Answer 3

Generics provide type checks at compile time and are erased by the compiler during the Type Erasure . So after the type erasure your method will look something like this:

private static List generic(Object clazz) {
    List list = new ArrayList();
    list.add((Object) Arrays.asList("create", "generic"));
    list.add((Object) Arrays.asList("create", "generic2"));
    return list;
}

And your main method will look as follows:

List list = (List) generic(Integer.class);
System.out.println(list);

So there's no reason for a ClassCastException to be thrown, because you are not trying to do any Integer specific actions to the elements of your list. But you will get it as soon as you do, for example:

list.forEach(integer -> System.out.println(integer.intValue()));

because here it will try to cast ArrayList to Integer to call intValue() .

Conclusion: using generics along with unchecked casting is quite useless.