Java泛型与集合常见陷阱

下面我总结了集合，泛型，数组转集合等一些常见的陷阱

一、List ，List<?> 与 List 有区别吗？

1、我们先来看看 List 与 List

     1、很多可能觉得 List<Object>的用法与 List 是一样的，例如很多人认为：
       		List<Object> list;  与  List list;
        这两种定义方法是一模一样的，然而他们是不一样的。看下面一段代码

从这里可以是有区别的，List变量可以接收任何泛型的变量，而List则不可以.

2、我们在看看 Lis<?> 有什么需要注意的地方：

看下面一段代码

   List<?> 是一个泛型，在没有赋值之前，是可以接受任何集合的赋值的，
   我想这点大家都知道，但是请注意，赋值之后就不能往里面添加元素了，提示如上错误.
   所以 List<?> 一般用来作为参数来接受外部的集合，或者返回一个不知道具体元素的集合。
   List 与 List<?>, List<Object> 的区别知道了吧？

二、<? extends T> 与 <? super T>

我们知道泛型 List 只能放置一种类型，如果你采用 List 来放置多种类型，然后再进行类型强制转换的话，那会失去了泛型的初衷。为了能够放置多种类型，于是有了 <? extend T> 与 <? super T>，下面先说一些你可能原本就知道的知识：

1、对于 <? extends T> a，a 这个变量可以接受 T 及其 T 子类的集合，上界为 T，并且从 a 取出来的类型都会被强制转换为 T。重点看下面一个例子：

注意：我们先约定 Cat(猫) 继承自 Animal(动物)，RedCat(红猫) 继承自 Cat

<? extends T>最需要注意的是，就是不能向里面添加除null之外的其他所有元素，这个和 List<?> 有点类似。

2、现在说说 <? super T>，它和 <? extends T> 有点相反。

对于 <? super T> a，a 这个变量可以接受 T 及其 T 父类的集合，下界为 T，并且从 a 取出来的类型都会被强制转换为 Object。重点看下面一个例子：

<？ 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 及 其子类元素。

三、泛型与重载
你觉得下面代码能够编译通过吗？

public 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");
  }
 }

答是编译不通过。

两个方法的参数不同，为什么会重载不通过呢？

实际上在 Java 的泛型中，泛型只存在于源码中，在编译后的字节码中，泛型已经被替换为原生类型了，并且在相应的地方插入了强制转换的代码。为了方便理解，可以看下面的一段代码例子：

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    System.out.println(list.get(0));
}

编译之后泛型就不存在了，并且在相应的地方插入了强制转换的代码，编译之后，我们反编译的代码如下：

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(1);
    System.out.println((Integer)list.get(0));
}

这种 编译之后泛型就不存在了，并且在相应的地方插入了强制转换代码的机制我们也称之为擦除。

所以上面的两个方法，看似参数不一样，但是经过编译擦出之后，他们的参数就是一样的了，所以编译不通过

四、数组与集合相互转换时需要注意的点
1、数组转集合

public static void main(String[] args) {
    String[] arr = {"one", "two", "three"};
    // 数组转换成集合
    List<String> list = Arrays.asList(arr);
    // 向集合添加元素：编译正常，但运行时抛出了异常
    list.add("four");
}

向集合添加元素抛出了如下异常：

向集合添加元素为啥会抛出异常呢？？
我们先来看一下 Arrays.asList(arr) 方法究竟返回了什么？

源码如下：

返回的明明是 ArrayList 啊，为啥就不能添加元素呢？？实际上，此 ArrayList 非彼 ArrayList，这个返回的 ArrayList 实际上是 Arrays 的一个内部类。该内部类也是十分简单，和真实的那个 ArrayList 没得比，部分源码如下：

而且这个假的 ArrayList 是直接 引用原数组的，不然你看它的构造器(第二条画线)

也就是说，ArrayList 内部是直接引用 arr 数组，你对 arr 数组进行改变，也会同时改变到 list 集合。

下面的代码证明这一点

public static void main(String[] args) {
    String[] arr = {"one", "two", "three"};
    // 数组转换成集合
    List<String> list = Arrays.asList(arr);
    // 修改 arr
    arr[0] = "0";
    //打印看看
    System.out.println(list.get(0));
}

打印结果是 “0”。

所以，我们向 list 添加元素肯定失败，因为 arr 数组的长度了 3 ，本来就有 3 个元素了，你在向里面添加第四个元素，肯定是不行的。

所以，在把数组转换为集合的过程中，需要特别注意。

建议大家这样转换比较安全

List<String> list = new ArrayList<>(Arrays.asList(arr));

2、集合转数组

集合转换为数组相对比较不苛刻，我就不拉很多源码来进行分析了，我只简单说下几个需要注意的地方。例如对于下面这个转换：

// 集合大小为 size
List<String> list = new ArrayList<>();
// 长度为 n 的数组
String[] arr = new String[n];
// 进行转换
list.toArray(arr);

1、如果数组长度比集合小：由于 arr 的长度不够，所以集合里的元素不会赋给 arr，而且自己再重新创建一个新数组反回去。

2、如果数组长度不小于集合：此时 arr 的长度够了，所以集合里的元素直接复制给 arr 数组，不会重新创建一个新的元素。

一览源码：

public <T> T[] toArray(T[] a) {
if (a.length < size)
    // 重新创建一个数组来返回去
    return (T[]) Arrays.copyOf(elementData, size, a.getClass());
// 长度够的话直接复制给 a
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
    a[size] = null;
return a;
}