在Arrays.asList()引发的问题中进一步学习集合与…

2018-06-18 03:11:40来源：未知阅读 ()

　　前言

　　最近在网上看到一个问题，情况类似如下（记为问题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，但是第二输出还没到就已经报错，完整运行结果如下：

　　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】？

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

　　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);

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