对JAVA集合进行遍历删除时务必要用迭代器

0.情景引出

对新手来说，遍历一个集合时难免会碰到删除操作，直接删除的话，肯定是要抛异常的

public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(String.valueOf(i));
        }
        System.out.println(list.toString());
        System.out.println("----------------------");
        for (String str:list){
            if(str.equals("5"))
                list.remove(str);
        }
         //会抛出异常java.util.ConcurrentModificationException

    }

异常的文档说明：

所以呢，聪明的你，大概可以找解决方案了，我以前呢倒是会建一个临时的集合C2和需要删减的集合C1一致，一个循环，一个删减，对于迭代器好像都是敬而远之！！

1.问题解决

咳咳，这里呢，就是为了让自己明白点

public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(String.valueOf(i));
        }
        System.out.println(list.toString());

        System.out.println("----------------------");

        Iterator iter = list.iterator();
        while (iter.hasNext()){
            String str = (String) iter.next();
            if(str.equals("5"))
                iter.remove();
                //错误的写法，list.remove(str);,这种类似于上面的
        }

        System.out.println(list);

    }

文章到此应该结束了。下面只是补充下，我自己对Iterator的理解

2.扩展Iterator

　　2.1 我们先来看一下Iterator的api解释：

这个移除元素的特点看来是与生俱来的吧，

2.2 我们再看一下ArrayList中的Iterator实现:

private class Itr implements Iterator<E> {
   /**
    * Index of element to be returned by subsequent call to next.
    */
   int cursor = 0;
   /**
    * Index of element returned by most recent call to next or
    * previous.  Reset to -1 if this element is deleted by a call
    * to remove.
    */
   int lastRet = -1;
   /**
    * The modCount value that the iterator believes that the backing
    * List should have.  If this expectation is violated, the iterator
    * has detected concurrent modification.
    */
   int expectedModCount = modCount;
   public boolean hasNext() {
           return cursor != size();
   }
   public E next() {
           checkForComodification();
       try {
       E next = get(cursor);
       lastRet = cursor++;
       return next;
       } catch (IndexOutOfBoundsException e) {
       checkForComodification();
       throw new NoSuchElementException();
       }
   }
   public void remove() {
       if (lastRet == -1)
       throw new IllegalStateException();
           checkForComodification();
       try {
       AbstractList.this.remove(lastRet);
       if (lastRet < cursor)
           cursor--;
       lastRet = -1;
       expectedModCount = modCount;
       } catch (IndexOutOfBoundsException e) {
       throw new ConcurrentModificationException();
       }
   }
   final void checkForComodification() {
       if (modCount != expectedModCount)
       throw new ConcurrentModificationException();
   }
   }

Iterator采用cursor来来维护自已的状态，而上ArrayList采用size属性来维护自已的状态

当size出现变化时，cursor并不一定能够得到同步，除非这种变化是Iterator主动导致的。

从上面的代码可以看到当Iterator.remove方法导致ArrayList列表发生变化时，他会更新cursor来同步这一变化。但其他方式导致的ArrayList变化，Iterator是无法感知的。ArrayList自然也不会主动通知Iterator们，那将是一个繁重的工作。Iterator到底还是做了努力：为了防止状态不一致可能引发的无法设想的后果，Iterator会经常做checkForComodification检查，以防有变。如果有变，则以异常抛出，所以就出现了上面的异常。