从源码角度分析Arrays.asList返回的集合不能进行增删操作。

最新推荐文章于 2022-12-09 08:09:16 发布

zhuhai__yizhi

最新推荐文章于 2022-12-09 08:09:16 发布

阅读量674

点赞数

CC 4.0 BY-SA版权

分类专栏： Java学习

本文链接：https://blog.youkuaiyun.com/zhuhai__yizhi/article/details/50674437

Java学习专栏收录该内容

111 篇文章

订阅专栏

本文探讨了使用Java中Arrays.asList方法创建List时的行为特点，尤其是该方法返回的List对象限制了增删操作，但允许修改元素内容。文章通过具体示例展示了这种行为，并解析了底层实现原理。

public class Test{
    public static void main(String[] args) {
        String[] strArray = new String[]{"杭州", "南京", "上海", "广州", "北京"};
        List<String> list = Arrays.asList(strArray);
        list.clear();
    }
}

可以看到这里面Arrays调用如下：

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

看到了这里有一个ArrayList，其实这个并非java.util.ArrayList，而是java.util.Arrays.ArrayList，它其实是Arrays的一个静态内部类，定义如下：

    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) {
            if (array==null)
                throw new NullPointerException();
            a = array;
        }

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

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

        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

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

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

        public int indexOf(Object o) {
            if (o==null) {
                for (int i=0; i<a.length; i++)
                    if (a[i]==null)
                        return i;
            } else {
                for (int i=0; i<a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

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

从上述定义可以看出ArrayList并没有提供增删等函数，那么调用clear，add，remove方法，就是调用其父类的方法，

继续跟踪代码。

父类AbstractList的方法：

public void clear() {
        removeRange(0, size());
    }

protected void removeRange(int fromIndex, int toIndex) {
        ListIterator<E> it = listIterator(fromIndex);
        for (int i=0, n=toIndex-fromIndex; i<n; i++) {
            it.next();
            it.remove();
        }
    }

public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

上面的remove()方法里面调用了，AbstractList.this.remove(lastRet);这行语句如下：

public E remove(int index) {
        throw new UnsupportedOperationException();
    }

这里就抛出了java.lang.UnsupportedOperationException这个异常了。这里只需要跟踪调试一下就可以知道执行了的流程了。

也就是在使用Arrays.asList的时候要明白，它返回的是一个不可以增删的List集合，但是可以更改集合里面的内容。

如下：

public class Test{
    public static void main(String[] args) {
        String[] strArray = new String[]{"杭州", "南京", "上海", "广州", "北京"};
        List<String> list = Arrays.asList(strArray);
        list.set(0, "南昌");
        System.out.println(list.get(0));
    }
}