Java中使用for循環刪除集合中元素需要注意的點

刪除集合中的元素，第一反應是遍歷集合，比較找到相應的元素然后刪除。遍歷集合最容易想到的是for循環。

刪除集合中為3的元素：

List<Integer> list = new ArrayList<Integer>();
        for(int i = 0;i<10;i++){
            list.add(i);
        }
        for(int i = 0;i<10;i++){
            list.add(i);
        }
        System.out.println("刪除前"+list);
        System.out.println("size:"+list.size());
        for(int i = 0;i<list.size();i++){
            if(list.get(i)==3){
                list.remove(i);
            }
        }
        System.out.println("刪除后"+list);
        System.out.println("size:"+list.size());

運行結果：

刪除前[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
size:20
刪除后[0, 1, 2, 4, 5, 6, 7, 8, 9, 0, 1, 2, 4, 5, 6, 7, 8, 9]
size:18

　看起來一點問題也沒有，那么我們把集合中元素的順序換一下。

List<Integer> list = new ArrayList<Integer>();
        for(int i = 0;i<10;i++){
            list.add(i);
            list.add(i);
        }
        System.out.println("刪除前"+list);
        System.out.println("size:"+list.size());
        for(int i = 0;i<list.size();i++){
            if(list.get(i)==3){
                list.remove(i);
            }
        }
        System.out.println("刪除后"+list);
        System.out.println("size:"+list.size());

運行結果：

刪除前[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
size:20
刪除后[0, 0, 1, 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
size:19

問題出現了，當刪除相鄰兩個重復元素的時候，只刪除一個，這是什么原因呢？

ArrayList的底層結構是數組類型，數組的特點是刪除某個元素時，后面所有元素的索引都會往前移，而此時for循環的指針是卻是向下移動的。

　

解決方案一：使用每次刪除元素的時候，將for循環指針回調一次

List<Integer> list = new ArrayList<Integer>();
        for(int i = 0;i<10;i++){
            list.add(i);
            list.add(i);
        }
        System.out.println("刪除前"+list);
        System.out.println("size:"+list.size());
        for(int i = 0;i<list.size();i++){
            if(list.get(i)==3){
                list.remove(i);
                i--;
            }
        }
        System.out.println("刪除后"+list);
        System.out.println("size:"+list.size());

運行結果：

刪除前[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
size:20
刪除后[0, 0, 1, 1, 2, 2, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
size:18

解決方案二：使用迭代器

    List<Integer> list = new ArrayList<Integer>();
        for(int i = 0;i<10;i++){
            list.add(i);
            list.add(i);
        }
        System.out.println("刪除前"+list);
        System.out.println("size:"+list.size());
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
            if(3==it.next()){
                it.remove();
            }
        }
        System.out.println("刪除后"+list);
        System.out.println("size:"+list.size());

運行結果：

刪除前[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
size:20
刪除后[0, 0, 1, 1, 2, 2, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
size:18

 為什么使用迭代器可以實現這樣的操作呢？下面將基於ArrayList的Iterator的實現分析Iterator的原理。

在ArrayList類中有個方法iterator()，此方法將返回一個iterator的實現，這里可以看出實現類叫Itr，通過其它源碼可知，此類是AarryList的內部類，即ArryList的Iterator實現在ArrayList內部

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

ArrayList中實現類Itr類的源碼：

private class Itr implements Iterator<E> {
        /**
         * 下一個返回的位置
         */
        int cursor = 0;

        /**
         * 當前操作的位置
         */
        int lastRet = -1;

        /**
         * 類似版本號，檢查List是否有更新
         */
        int expectedModCount = modCount;

        public boolean hasNext() {      // 判斷是否有下一個元素
            return cursor != size();
        }

        public E next() {  // 返回下一個元素
            checkForComodification();
            try {
                int i = cursor;     // cursor記錄的是下一個元素，所以調用next時將返回的是cursor對應的元素
                E next = get(i);    //  記錄需要返回的元素
                lastRet = i;        // 記錄當前元素
                cursor = i + 1;     // 記錄下一個元素
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {       // 移除元素
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();     //   檢查是否有更改，remove或者add

            try {
                AbstractList.this.remove(lastRet);   // 刪除當前元素  
                if (lastRet < cursor)                // 刪除了之后指標減1
                    cursor--;
                lastRet = -1;                    
                expectedModCount = modCount;         // 保持版本號一致
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {    // 如果有更改則拋出ConcurrentModificationException異常
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

在next()方法中可以看到，通過移動cursor游標來指向集合下一個元素。

再看remove()方法，代碼的43行，刪除當前元素后，游標前移了。

結論：這兩種方法，基本思想都是將指針回調。