Class c1 = new ArrayList<Integer>().getClass();  
Class c2 = new ArrayList<String>().getClass();   
System.out.println(c1 == c2);  
  
/* Output 
true 
*/  

List<Integer> list = new ArrayList<Integer>();  
Map<Integer, String> map = new HashMap<Integer, String>();  
System.out.println(Arrays.toString(list.getClass().getTypeParameters()));  
System.out.println(Arrays.toString(map.getClass().getTypeParameters()));  
  
/* Output 
[E] 
[K, V] 
*/  

class A<T extends Number> {
}

Signature: #18 // <T:Ljava/lang/Number;>Ljava/lang/Object;

//一下代碼中，當(dāng)把一個帶泛型信息的a的實例賦值給一個不帶泛型信息的的b的時候，
//a中所有的泛型信息都會發(fā)生丟失，也就是說T是Integer的這一信息會丟失，b只知道
//T的類型是Number而已
package ErasureAndConversion;
 
 
import UseIt.A1;
 
class Apple<T extends  Number>{
    T size;
    public Apple(){
 
    }
    public Apple(T size){
        this.size = size;
    }
    public void setSize(T size){
        this.size = size;
    }
    public T getSize(){
        return this.size;
    }
}
 
 
public class Erasure {
    public static void main(String args[]){
        Apple<Integer> a = new Apple<>(6);
//        a指向的實例是帶有泛型信息的
 
        Integer as = a.getSize();
//        實例a中的T是Integer類型的，所以賦值給as沒有任何問題
        Apple b  = a;
//        這一句就是說明問題的關(guān)鍵了，b是不帶泛型信息的，所以a中的泛型信息
//        也就會被擦除，所以，a中的T的類型就只是Number而已了
 
        Number size1 = b.getSize();
//        b中的T類型是Number，所以賦值給Number類型的值沒有任何問題
 
 
//        Integer size2 = b.getSize();
//        但是，b中的T并不是Integer的了，因為泛型信息已經(jīng)被擦除了，所以這一句會
//        報錯。
        Integer size3 = a.getSize();
//       最后這一句并不會報錯，b會發(fā)生泛型信息丟失但是a并不會受影響
    }
}

//java允許把一個List賦值給一個List<Type>所以在下面 List<String> ls = list;
//這一句僅僅只會發(fā)生警告而已。
package ErasureAndConversion;
 
import java.util.ArrayList;
import java.util.List;
 
public class Erasure2 {
    public static void main(String args[]){
        List<Integer> li = new ArrayList<>();
        li.add(6);
        li.add(5);
        List list = li;
        List<String> ls = list;
//        一樣的道理，List沒有泛型信息，所以li的泛型信息就丟失了，所以賦值給ls
//        是沒有問題的
 
//        System.out.println(ls.get(0));
//        但是當(dāng)訪問ls中的元素的時候，就會發(fā)生類型不匹配的問題
    }
}

//這個例子和上面的例子是一模一樣的
package ErasureAndConversion;
 
import java.util.ArrayList;
import java.util.List;
 
public class Erasure3 {
    public static void main(String args[]){
        List list = new ArrayList();
        ((ArrayList) list).add(5);
        ((ArrayList) list).add(4);
//        System.out.println((String)list.get(0));
    }
}

class A<T, ID> {  
}  
  
class B extends A<String, Integer> {  
}  
  
public class Generic {  
    public static void main(String[] args) {  
        ParameterizedType parameterizedType = (ParameterizedType) B.class.getGenericSuperclass();  
        
		Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();  
		for(Type actualTypeArgument: actualTypeArguments) {  
		    System.out.println(actualTypeArgument);  
		}  
		
		Class clazz = (Class) parameterizedType.getActualTypeArguments()[0];
        System.out.println(clazz);
    }  
}  

interface A<T, ID> {  
}  
  
class B implements A<String, Integer> {  
}  

public class Generic {  
    public static void main(String[] args) {  
        ParameterizedType parameterizedType = (ParameterizedType) B.class.getGenericInterfaces();  
        
		Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();  
		for (Type actualTypeArgument : actualTypeArguments) {  
		    System.out.println(actualTypeArgument);  
		}  
		
		Class clazz = (Class) parameterizedType.getActualTypeArguments()[0];
        System.out.println(clazz);
    }  
}

[{  
    "name": "Stark",  
    "nickName": "Iron Man"  
},  
{  
    "name": "Rogers",  
    "nickName": "Captain America"  
}]  

Map<String, Integer> map = new HashMap<String, Integer>() {};  
Type type = map.getClass().getGenericSuperclass();  
ParameterizedType parameterizedType = ParameterizedType.class.cast(type);  
//ParameterizedType parameterizedType = (ParameterizedType)map.getClass().getGenericSuperclass();
for (Type typeArgument : parameterizedType.getActualTypeArguments()) {  
    System.out.println(typeArgument.getTypeName());  
}  
  
/* Output 
java.lang.String 
java.lang.Integer 
*/  

Map<Integer, String> map = new HashMap<Integer, String>();  

Map<String, Integer> map = new HashMap<String, Integer>() {};  

//這里的ParameterizedTypeReference是一個抽象類，因此約束了必須創(chuàng)建ParameterizedTypeReference的子類，由此成功獲取到泛型的實際類型
ResponseEntity<ResponseDTO<UserKeyDTO>> result = restTemplate.exchange(url, null, new ParameterizedTypeReference<ResponseDTO<UserKeyDTO>>(){});

//通過創(chuàng)建TypeReference的匿名內(nèi)部類的方式來保留反省信息，以便json反序列化時能反射獲取到泛型實際類型
ResponseDTO<SysCryptDTO> responseDTO = JSONObject.parseObject(jsonString, new TypeReference<ResponseDTO<SysCryptDTO>>() {});