java.lang.UnsupportedOperationException异常分析

实验代码如下

public static void main(String[] args) {
    //得到List集合
    List<Integer> coll = Arrays.asList(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9});
    
    //获取相应迭代器，并对集合进行遍历
    Iterator iterator = coll.iterator();
    while (iterator.hasNext()) {
        System.out.print(iterator.next() + " ");
    }
    System.out.println();

    //删除迭代器中的元素"5"
    iterator = coll.iterator();
    while (iterator.hasNext()) {
        int num = (int) iterator.next();
        if (num == 5) {
            iterator.remove();
        }
    }

    //重新遍历，应该没有元素"5"
    iterator = coll.iterator();
    while (iterator.hasNext()) {
        System.out.print(iterator.next() + " ");
    }
    System.out.println();

    //集合中依然有元素"5"：iterator的remove()只是删除迭代器中的元素，不同于collection的remove()方法
    System.out.println(coll);
}

上述代码本意是想检验：Iterator 的 remove() 只是删除迭代器中的元素，不同于 Collection 的 remove() 方法

然而编译错误，报出异常如下

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.remove(AbstractList.java:161)
	at java.util.AbstractList$Itr.remove(AbstractList.java:374)
	at collection.Test.main(Test.java:20)

 Iterator 接口中的 remove() 方法是一个默认方法，如果该接口的实现类重写了该方法，将因为多态性调用重写的方法，若没有重写则调用接口中的方法体。

default void remove() {
    throw new UnsupportedOperationException("remove");
}

查看源码后发现：使用 Arrays.asList(arr) 转换得到的是 Arrays$ArrayList（Arrays 的内部类ArrayList）而不是 ArrayList（List接口的实现类）。

Arrays$ArrayList 是 Arrays 的私有静态内部类，源码如下。

Arrays$ArrayList 和 ArrayList 都继承了 AbstractList，但是 AbstractList 中的 add 方法和 remove 方法都是直接抛出 UnsupportedOperationException，并没有直接实现。

Arrays$ArrayList 继承了 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) {
        a = Objects.requireNonNull(array);
    }

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

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

    @Override
    @SuppressWarnings("unchecked")
    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;
    }

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

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

    @Override
    public int indexOf(Object o) {
        E[] a = this.a;
        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;
    }

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

    @Override
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(a, Spliterator.ORDERED);
    }

    @Override
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        for (E e : a) {
            action.accept(e);
        }
    }

    @Override
    public void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        E[] a = this.a;
        for (int i = 0; i < a.length; i++) {
            a[i] = operator.apply(a[i]);
        }
    }

    @Override
    public void sort(Comparator<? super E> c) {
        Arrays.sort(a, c);
    }
}

ArrayList 并不能进行 add() 和 remove() 操作，相关源码如下

本实验中，只需改变获得集合的方式如下

//得到List集合
ArrayList coll = new ArrayList();
for (int i = 0; i < 10; i++) {
    coll.add(i);
}

实验结果为

0 1 2 3 4 5 6 7 8 9 //第一次迭代结果
0 1 2 3 4 6 7 8 9   //删除元素"5"后的迭代结果，没有元素"5"
[0, 1, 2, 3, 4, 6, 7, 8, 9] //直接打印集合，元素"5"依然存在