Iterator遍历器删除集合中元素抛异常

一、我们知道遍历集合的过程中，安全的移除集合中的元素，要使用遍历器Iterator以及其remove()方法。但是有的时候貌似并不好用

二、示例（这里只列举了一种，其他很多集合也存在同样的坑）

import java.util.*;

public class MyTest {
    public static void main(String [] args) {
        try {
            String str = "abc,def,hig";
            List<String> oTestList = Arrays.asList(str.split(","));
            Iterator<String> oIterator = oTestList.iterator();
            while (oIterator.hasNext()) {
                if ("def".equals(oIterator.next())) {
                    oIterator.remove();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

异常结果：
java.lang.UnsupportedOperationException
at java.util.AbstractList.remove(AbstractList.java:161)
at java.util.AbstractList$Itr.remove(AbstractList.java:374)
at com.glodon.gccs.test.MyTest.main(MyTest.java:18)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)

三、原因分析
1、每个集合调用iterator()生成的遍历器实际上都是在该集合中定义的一个Iterator的子类，执行remove()方法，也就是执行该子类中的remove()方法，下面从源码中分析，坑从何来？
2、源码跟踪
1）Arrays.asList()

@SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

注意：这个ArrayList并不是java.util中的，而是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) {
            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);
        }
    }

可以看到，该类继承了AbstractList，而自身并未实现任何遍历器相关的方法，所以在使用这个集合进行遍历器相关操作，实际上是调用AbstractList相关的遍历器操作。
2）AbstractList iterator()

public Iterator<E> iterator() {
        return new Itr();
    }

3）AbstractList iterator的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();
            }
        }

注意这行代码：AbstractList.this.remove(lastRet);
iterator的remove()实际是调用AbstractList自身的remove()方法
4）AbstractList remove()

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

是不是很坑？

四、总结：集合使用遍历器进行安全移除元素时，一定要确保：
1）该集合是否重写了遍历器，重写的遍历器是否支持移除操作；
2）若集合未重写遍历器，其基类的遍历器操作是否可正常使用
经验之谈：JDK源码中不推荐直接使用的基类，通常都会在相应方法中抛异常，促使开发人员使用相应子类进行开发