針對for、foreach以及迭代器的總結（針對集合刪除元素）

前言

　　針對for、foreach、迭代器的區別，這里不再詳細敘述。只做簡單的介紹，本篇針對循環刪除集合的元素時會發生什么。

簡單介紹區別

　　直接上代碼：

　  public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("dabin");
        list.add("xiaobin");
        list.add("datoubin");
        list.add("dabin");
        list.add("dabin");

　　　　System.out.println("foreach寫法");
    　 for (String it : list) {
        System.out.println(it);
    　　}
   　　 System.out.println("for寫法");
    　　for (int i = 0; i < list.size(); i++) {
    　　    System.out.println(list.get(i));
    　　}
    　　System.out.println("迭代器寫法");
    　　Iterator<String> it = list.iterator();
   　　 while (it.hasNext()) {
       　　 System.out.println(it.next());
    　　}
　　}

　　輸出結果如圖：

              

 　　如此就看出使用的區別的，

　　然后就是這篇文章的重點了！！！！

循環打印集合刪除元素問題

　　　就比如我要在集合中刪除某些元素從三種方式去一一講解：

　　常見的for循環遍歷中刪除元素

　　　　直接上代碼：

public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("dabin");
        list.add("xiaobin");
        list.add("datoubin");
        list.add("dabin");
        list.add("dabin");
        for (int i = 0; i < list.size(); i++) {
            if ("dabin".equals(list.get(i))) {
                list.remove(i);
            }
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
}

 

　　　　這時候輸出：

　　　　

　　　　咦，我們就發現了，為什么還有一個dabin沒有被刪除呢？

　　　　這個就要從for語句刪除來講了，

　　　　這是因為在list通過for循環遍歷中刪除元素之后，后面的元素會上前替補前面元素的位置，這樣就有可能會導致元素遍歷過程中某些元素被漏掉，結果就出現了上面的那種結果。

　　　　顯然通過這種方式是不能精確地刪除集合中所有滿足條件的元素，剛才也說過是因為元素位置發生了變化導致了這種情況，那么我們可不可以換一種思路，倒序for循環遍歷呢？？將上面的代碼改為倒序遍歷，我們來試試康康：

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("dabin");
        list.add("xiaobin");
        list.add("datoubin");
        list.add("dabin");
        list.add("dabin");
        for (int i = list.size() - 1; i >= 0; i--) {
            if ("dabin".equals(list.get(i))) {
                list.remove(i);
            }
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

　　　　輸出結果如下：

　　　　咦，這時候就發現，成功了。good

 　　foreach循環遍歷中刪除元素

　　　　現在就來試試康foreach了：

   public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("dabin");
        list.add("xiaobin");
        list.add("datoubin");
        list.add("dabin");
        list.add("dabin");

        for (String it : list) {
            if ("dabin".equals(it)) {
                list.remove(it);
            }
        }
}

 

 

嗚呼，完蛋報錯了，直接拋出了一個ConcurrentModificationException異常，

我們來看看這個這個異常是因為什么：

其實Foreach遍歷是通過實現Iterable接口的類通過，那是因為foreach要依賴於Iterable接口返回的Iterator對象，所以從本質上來講，Foreach其實就是在使用迭代器，在使用foreach遍歷時對集合的結構進行修改，和在使用Iterator遍歷時對集合結構進行修改本質上是一樣的。所以同樣的也會拋出異常，執行快速失敗機制。

　　那這個問題先留着，我們來先看看用迭代器遍歷后能不能解決這個問題。

 

　迭代器遍歷中刪除元素

　　直接上代碼：

public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("dabin");
        list.add("xiaobin");
        list.add("datoubin");
        list.add("dabin");
        list.add("dabin");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String a = it.next();
            if ("dabin".equals(a)) {
                list.remove(a);
            }
        }
}

 

 

 　　　　拋出了相同的異常，現在就要去看看源碼，分析為什么拋出了

  private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

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

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

 

通過查看源碼發現原來檢查並拋出異常的是checkForComodification()方法。在ArrayList中modCount是當前集合的版本號，每次修改(增、刪)集合都會加1；expectedModCount是當前迭代器的版本號，在迭代器實例化時初始化為modCount。我們看到在checkForComodification()方法中就是在驗證modCount的值和expectedModCount的值是否相等，所以當你在調用了ArrayList.add()或者ArrayList.remove()時，只更新了modCount的狀態，而迭代器中的expectedModCount未同步，因此才會導致再次調用Iterator.next()方法時拋出異常。但是為什么使用Iterator.remove()就沒有問題呢？通過源碼的第34行發現，在Iterator的remove()中同步了expectedModCount的值，所以當你下次再調用next()的時候，檢查不會拋出異常。
使用該機制的主要目的是為了實現ArrayList中的快速失敗機制（fail-fast），在Java集合中較大一部分集合是存在快速失敗機制的。
快速失敗機制產生的條件:當多個線程對Collection進行操作時，若其中某一個線程通過Iterator遍歷集合時，該集合的內容被其他線程所改變，則會拋出ConcurrentModificationException異常。
所以要保證在使用Iterator遍歷集合的時候不出錯誤，就應該保證在遍歷集合的過程中不會對集合產生結構上的修改。

 

你以為現在就結束了嘛？不不不

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("dabin");
        list.add("xiaobin");
        list.add("datoubin");
        list.add("dabin");
        list.add("dabin");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String a = it.next();
            if ("dabin".equals(a)) {
                it.remove();
            }
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
}

有沒有人發現兩者有什么不同呢？

 沒錯啦，這里是通過iterator的remove()方法來進行刪除的，而不是通過list.remove()方法來刪除，如果還是用list.remove()，依舊會出現上面那種問題。

有興趣的同學可以去看看哦，

 

 所以現在總結一下，

通過遍歷刪除元素的話for和迭代器都是可以實現的,只有foreach不行，