Java集合与泛型中的陷阱
List,List<Object>区别
List<Integer> t1 = new ArrayList<>();
// 编译通过
List t2 = t1;
//编译失败
List<Object> t3 = t1;
t1 可以赋给 t2, 但是 t1 不能赋给 t3，会抛出如下异常
Error:(16, 35) java: 不兼容的类型: java.util.List<java.lang.Integer>无法转换为java.util.List<java.lang.Object>
List<?>注意点
List<Object> t1 = new ArrayList<>();
List<?> t2 = t1;
// 编译通过
t2.remove(0);
t2.clear();
// 编译不通过
t2.add(new Object());
List<?> 是一个泛型，在没有赋值之前，是可以接受任何集合的赋值的，但是请注意，赋值之后就不能往里面添加元素了
提示如下错误：
Error:(18, 19) java: 对于add(java.lang.Object), 找不到合适的方法
方法 java.util.Collection.add(capture#1, 共 ?)不适用
(参数不匹配; java.lang.Object无法转换为capture#1, 共 ?)
方法 java.util.List.add(capture#1, 共 ?)不适用
(参数不匹配; java.lang.Object无法转换为capture#1, 共 ?)
所以 List<?> 一般用来作为参数来接受外部的集合，或者返回一个不知道具体元素的集合。
<? extends T> 与 <? super T>
<? extends T>
<? extends T> a，a 这个变量可以接受 T 及其 T 子类的集合，上界为 T，并且从 a 取出来的类型都会被强制转换为 T
class Animal{
}
class Cat extends Animal{
}
class RedCat extends Cat{
}
demo:
List<Animal> animals = new ArrayList<>();
List<Cat> cats = new ArrayList<>();
List<RedCat> redCats = new ArrayList<>();
// 可以通过编译
List<? extends Cat> extendsCat = redCats;
// 不能通过编译，因为只能接受 Cat 及其子类的集合
extendsCat = animals;
// 重点注意：下面三行都不能通过编译
extendsCat.add(new Animal());
extendsCat.add(new Cat());
extendsCat.add(new RedCat());
// 重点注意：可以通过编译
extendsCat.add(null);
<? extends T>最需要注意的是，就是不能向里面添加除null之外的其他所有元素，这个和 List<?> 有点类似
<? super T>
<? super T>，它和 <? extends T> 有点相反。**对于 <? super T> a**，a 这个变量可以接受 T 及其 T 父类的集合，下界为 T，并且从 a 取出来的类型都会被强制转换为 Object
demo:
List<Animal> animals = new ArrayList<>();
List<Cat> cats = new ArrayList<>();
List<RedCat> redCats = new ArrayList<>();
// 可以通过编译
List<? super Cat> superCat = animals;
// 不能通过编译，因为只能接受 Cat 及其父类的集合
superCat = redCats;
// 重点注意：不能通过编译,只能添加 Cat 及其 Cat 的子类
superCat.add(new Animal());
// 重点注意，可以通过编译
superCat.add(new Cat());
superCat.add(new RedCat());
superCat.add(null);
注意，<？ super T>最需要注意的是，在虽然可以接受 T 及其父类的赋值，但是只能向里面添加 T 及其 T 的子类。
总结
1、List<? extends T> a ,可以把 a 及其 a 的子类赋给 a，从 a 里取的元素都会被强制转换为 T 类型，不过需要注意的是，不能向 a 添加任何除 null 外是元素。
2、List<? super T> a ,可以把 a 及其 a 的父类赋给 a，从 a 里取的元素都会被强制转换为 Object 类型，不过需要注意的是，可以向 a 添加元素，但添加的只能是 T 及其子类元素。
List泛型与重载
你觉得下面这道题能够编译通过吗？
class GernerTypes {
public static void method(List<Integer> list) {
System.out.println("List<Integer> list");
}
public static void method(List<String> list) {
System.out.println("List<String> list");
}
}
不通过编译，错误信息：
Error:(20, 28) java: 名称冲突: method(java.util.List<java.lang.String>)和method(java.util.List<java.lang.Integer>)具有相同疑符
两个方法的参数不同，为什么会重载不通过呢？
实际上在 Java 的泛型中，泛型只存在于源码中，在编译后的字节码中，泛型已经被替换为原生类型了，并且在相应的地方插入了强制转换的代码。
所以上面的两个方法，看似参数不一样，但是经过编译擦出之后，他们的参数就是一样的了，所以编译不通过。
数组集合转换：
String[] arr = {"one", "two", "three"};
// 数组转换成集合
List<String> list = Arrays.asList(arr);
// 向集合添加元素：编译正常，但运行时抛出了异常
list.add("four");
运行时报错：
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at com.qhong.basic.list.test.main(test.java:16)
问题来了，向集合添加元素为啥会抛出异常呢？？
我们先来看一下 Arrays.asList(arr) 方法究竟返回了什么？
看源码：
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
/**
* @serial include
*/
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
。。。。
返回的List内部直接引用了原数组arr
原数组长度固定为3，所以不可以再add
下面的代码证明这一点
String[] arr = {"one", "two", "three"};
// 数组转换成集合
List<String> list = Arrays.asList(arr);
// 修改 arr
arr[0] = "0";
//打印看看
System.out.println(list.get(0));
打印：
0
建议大家这样转换比较安全
List<String> list = new ArrayList<>(Arrays.asList(arr));
