在Arrays.asList()引发的问题中进一步学习集合与泛型等内容

　　前言

　　最近在网上看到一个问题，情况类似如下（记为问题1）：

    public class Demo {

        public static void main(String[] args) {
            System.out.println(testInteger(1));
            System.out.println(testInt(1));
        }

        public static boolean testInteger (Integer num) {
            Integer[] nums = new Integer[]{1, 2, 3, 4, 5, 6};
            boolean flag = Arrays.asList(nums).contains(num);
            return flag;
        }

        public static boolean testInt (int num) {
            int[] nums = new int[]{1, 2, 3, 4, 5, 6};
            boolean flag = Arrays.asList(nums).contains(num);
            return flag;
        }
    }

结果第一个输出为true，提问者觉得很正常，第二个输出却为false了，很奇怪。如果没有深入使用过该集合，或是理解泛型，在我的第一眼看来，也是有疑惑。按理来说，Java中本身针对基本类型与对应包装类型，就有自动装箱拆箱功能，你Integer能行，我int按理来说应该也能行。于是我大致在网上搜寻了类似的问题，发现除了上面的问题，还有类似如下的情况(记为问题2)

    public class Demo2 {

        public static void main(String[] args) {
            Integer[] nums1 = new Integer[]{1, 2, 3, 4, 5, 6};
            List list1 = Arrays.asList(nums1);
            list1.set(0, 888);
            System.out.println(list1);

            int[] nums2 = new int[]{1, 2, 3, 4, 5, 6};
            List list2 = Arrays.asList(nums2);
            list2.set(0, 888);
            System.out.println(list2);
        }

    }

　　第一个输出正常，集合list1中第一个元素修改为888，但是第二输出还没到就已经报错，完整运行结果如下：

aaarticlea/png;base64,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" alt="" />

　　java.lang.ArrayStoreException：数组存储异常。下面具体就集合方法与泛型探究上面的问题。

　　过程

　　Integer[] nums = new Integer[]{1, 2, 3, 4, 5, 6};
　　Arrays.asList(nums);进入这个方法，源代码如下：

    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

短短的两行代码，内容却并不简单
    1.方法的参数比较特殊：参数是泛型类的，并且是可变参数。一个泛型，一个可变参数，说实话，初学者或者开发中不敢说都没用过，但要是说有多常用，显然也不符合。所以其实上面的内容在这一步就已经出问题了，下面会具体分析。    
    2.方法的返回值是一个ArrayList,这里又是一个大坑，这个ArrayList并不是我们以前学习或者平时常用到的有序集合ArrayList，而是数组工具类Arrays类的一个静态内部类，继承了AbstractList，如下所示：

    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) {
            //上面调用的构造方法内容即为这里，调用requireNonNull方法，对象array为空的话会报空指针异常，不为空则将其赋值给成员a。
            a = Objects.requireNonNull(array);
        }

        //赋值后此时a就代表了array数组的内容，所以后面的方法基本上都围绕a展开。

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }
        ......

    }

　　requireNonNull方法内容：

    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

　　完整的过完了这一遍流程后，我们要思考的是，通过Arrays.asList（nums）方法，我们得到的到底是一个什么。从上面的内容，我们首先可以确定是一个集合。在问题1中，包装类Integer情况下，调用Arrays.asList(nums)，基于可变参数的定义，这里我们相当于传入可变参数的长度为5。
　　在public static <T> List<T> asList(T... a)方法中，此时相当于泛型T指定为Integer类型。然后private final E[] a; 此时的数组a的泛型E也相应为Integer。此时a的内容相当于 new Integer[]{1,2,3,4,5,6}; 即一个Integer类型的一维数组，集合也随之为List<Integer>

最后获取的是一个Arrays的一个静态内部类ArrayList对象，在内部类中重写了contains方法：

    @Override
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

　　所以在问题1中的第一种情况传入1时会自动转为对象Object类型，即上面的o，此时显然成立，所以返回true。
　　那么第二种情况输出false，问题出在哪里？
　　在基本类型int情况时，同样基于可变参数的定义，同时基于java的自动转换类型，跟上面一样传入可变参数的长度还是相当于5吗？其实不是，根本原因在于这里除了可变参数的定义，还有泛型的定义，但是别忘了泛型也有一些限制,首先第一点就是：
　　泛型的类型参数只能是类类型（包括自定义类），不能是简单类型！
　　所以这里其实就已经有分歧了，所以这里我们相当于传入了一个对象，对象类型为数组类型，可变参数的长度是1，而不是5。此时a相当于一个二维数组，在上面的情况中，即a数组的元素类型为数组，元素个数为1，而不是上面的Integer,此时集合为List<int[]>。
　　最后得到的集合是这样子：List<int[]>形式,集合长度为1，包含了一个数组对象，而不是误以为的List<Intger>。
　　接着调用contains方法，集合中就一个数组类型对象，显然不包含1。所以问题1中int情况下输出false
　　同样的，在问题2的int情况下，list2.set(0,888);即相当于将集合索引为0的元素（即第1个，这里集合中就一个数组元素）赋值为一个888自动转型的Integer类，给1个数组Array类型对象赋值Intger对象，所以才报错了上面的数组存储异常。

　　梳理与验证

　　为了更好的理清上面的内容，做如下扩展。

　　首先是Integer对象类型。

Integer[] nums = new Integer[]{1, 2, 3, 4, 5, 888};
List<Integer> list2 = Arrays.asList(nums);
System.out.println(list2.get(5));//输出888

　　这里我们顺利的通过一次索引拿到在这个888。

　　接着是int基本类型，前面提到了既然是可变参数，我们传了一个数组，一个数组也是一个对象，那我们可以传入多个数组看看，如下所示。

int[] nums1 = new int[]{1, 2, 3, 4, 5, 666};
int[] nums2 = new int[]{1, 2, 3, 4, 5, 777};
int[] nums3 = new int[]{1, 2, 3, 4, 5, 888};
List<int[]> list1 = Arrays.asList(nums1,nums2,nums3);
System.out.println(list1.get(2)[5]);//输出888

　　这里的get方法我们点进去查看源代码：

        @Override
        public E get(int index) {
            return a[index];
        }    

　　所以这里我们输出其实就是a[2][5],拿到888，这也印证了前面为什么说本质上就是一个二维数组的原因，同时加深了我们对集合与数组关系的理解。

　　更多的陷阱

　　前面重点提到这里我们通过Arrays.asList()方法得到的"ArrayList"，并不是我们平时常用的那个ArrayList，既然强调了，当然是为了要区分，那么不区分会有什么问题呢，下面以简单的Integer情况为例：

Integer[] nums = new Integer[]{1, 2, 3, 4, 5};
List<Integer> list = Arrays.asList(nums);
list.add(888);
System.out.println(list);

　　集合后面加个888，觉得会打印出来什么？【1, 2, 3, 4, 5，888】？

　　然后事实是还没到打印就已经抛出异常了，如下所示：

aaarticlea/png;base64,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" alt="" />

　　java.lang.UnsupportedOperationException：不支持的操作异常。为什么会不支持，我们以前一直add，remove等等都没问题。深究到底查看源代码。

　　首先java.util包下的ArrayList即我们熟知的，它的add方法实现如下：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

　　这也是我们一直以来操作没毛病的原因。

　　再来看这个"ArrayLitst",它在继承抽象类AbstractList的时候，并未实现（或者准确来说叫做重写）add方法，所以这里在调用add方法的时候，实际上是调用的抽象类AbstractList中已经实现的add方法，我们来看其方法内容：

    public boolean add(E e) {
        add(size(), e);
        return true;
    }

　　通过add(size(), e);这个传入2个参数的方法我们继续查看内容：

    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

　　真相大白！throw new UnsupportedOperationException();这个异常从哪来的一目了然。这个"ArrayLitst"根本没有实现add方法，所以才会报错。回到初始，还能想起集合与数组的种种关联，数组本身长度就是不可变的，而这里本质上我们就是在操作数组，所以没有add方法不是很正常吗。仔细查看其类的源码，会发现例如remove删除等方法，也是没有实现的，所以同样也会报错。

　　继续探讨，那么这里增也不行，删也不行，那我改总行吧，就数组而言，按理来说应该是支持的，而实际情况也的确如此。在"ArrayLitst"内部类中，其重写了set方法，方法能将指定索引处的元素修改为指定值，同时将旧元素的值作为返回值返回。

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

　　但是这里还要注意一点，如果我们在这里针对集合修改了某处元素值，那么原来数组的内容也会相应改变！即通过Arrays.asList()方法，得到的集合与原数组就已经关联起来，反之，如果我们修改了数组内容，那么集合获取到的内容也会随之改变。实践检验一下：

        Integer[] nums = new Integer[]{1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(nums);
        list.set(0, 888);//修改集合内容
        nums[1] = 999;//修改数组内容
        for(Integer i:nums) {
            System.out.println(i);
        }
        System.out.println(list);

　　运行后，控制台输出如下：

aaarticlea/png;base64,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" alt="" />

　　我们发现，不论是修改数组，还是修改集合，另一方都会相应改变。

　　小结

　　一开始以为是一个小问题，渐渐的发现，其中内容不少，集合是我们开发中算是很常用类库了，良好的熟悉程度能对我们的开发优化不少。而泛型关联到反射等等核心内容，如果想深入学习，也需要认真下功夫，在问题的探究中往往能有更深刻的印象。