java泛型中类型擦除的逻辑是什么？

Question

As far as I know, type generics happens in the following code:

public class Test {

    public void a(List<Object> list) {
    }

    public void a(List<String> list){
    }

    public void a(List<Integer> list){
    }

}

when the compiler compiles the code, the generic types will be erased so all the signatures are exactly same, which looks as follows:

public class Test {

    public void a(List list) {
    }

    public void a(List list){
    }

    public void a(List list){
    }

}

If this is the logic, then:

List<Object> objList = new ArrayList<>();
List<String> strList = new ArrayList<>();
objList = strList;  

is actually:

List objList = new ArrayList<>();
List strList = new ArrayList<>();
objList = strList; 

which is OK because both of the two lists are same type. However, In the above code, objList = strList will result an error.

Not quite sure what is the real logic. And what is more, the difference between List<?> , List(without any braces) and List< Object>

Answer 1

Generics are invariant: for any two distinct types U and V , List<U> is neither a subtype nor a supertype of List<V> . (Joshua Bloch, Effective Java)

You can't put any value except null into a List<?> .

Answer 2

The diff between List<?> and List is the former can take any type either an Object class or any other object. The latter can take only object

List<Object> list = new ArrayList<String> // compile error

List<?> list = new ArrayList<String>  //no error

List<?extends Comparator> (boundedd) will get converted to List after compile List Unbounded are converted to Object whereas for bounded the Java compiler replaces the bounded type parameter T with the first bound class.

For more details Generics

Answer 3

To complement @Giorgi Tsiklauri's answer ,

For the class below:

class Box<T> {
    T t;

    T getT() { return t; }

    void setT(T t) { this.t = t; }
}

because of type erasure, compiler compiles the class to:

class Box {
    Object t;

    Object getT() { return t; }

    void setT(Object t) { this.t = t; }
}

So, when you instantiate the Box<T> generic class with type argument Integer as follows:

Box<Integer> box = new Box<Integer>();
box.setT(10);
Integer t = box.getT();

the compiler knows that the Box<T> is instantiated with Integer because, at compile time, it sees that Box<Integer> . So, type casts are inserted by compiler. So the code above is compiled into:

Box box = new Box();
box.setT(10);
Integer t = (Integer) box.getT(); // compiler inserts type casts in lieu of us!

No matter how you instantiate the generic, the compiler doesn't create additional class files. If what actually happens at type erasure is replacement(replaces T with type argument such as Integer ), the compiler have to create additional classes for Box for Integer , Box for Double etc — But that's not what actually happens at type erasure:

Replace all type parameters in generic types with their bounds or Object if the type parameters are unbounded. — The Java™ Tutorials

Insert type casts if necessary to preserve type safety. — The Java™ Tutorials

Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead. — The Java™ Tutorials

Answer 4

If this is the logic, then..

No, that is not what happens.

Type erasure is a process that takes place during compilation, and for specific object allocations (objects, created using new ), compiler erases all the generic type parameters (eg Box<T> ) with corresponding generic type arguments (eg Box<Integer> ).

This means, that if you have defined your class:

class Box<T> {
}

and then invoked that type (instantiated), as:

Box<Integer> intBox = new Box<>();

in the compiled version, instantiation of intBox will allocate the object, on the heap, having swapped all the appearances of T with Integer .

Therefore, in your example:

public class Test {

    public void a(List<Object> list) {
    }

    public void a(List<String> list){
    }

    public void a(List<Integer> list){
    }

}

you are invoking a parametrized type (generic) and you declare method's local parameter with generic type argument .

For the object referenced by the variable of type List<String> , compiler have erased all the appearances of List 's E with String , and for List<Integer> - E will be replaced by Integer .

For the final part of your confusion, I'd suggest you read this .