List 中正确的增删操作

这个为什么要单独说的原因是，在开发中的对数据库中的增删为最基本的，但是是不是写对了就尤为重要

先来看代码:

public void testLoopInList(){
        List<String> a = new ArrayList<String>();
        a.add("1");
        a.add("2");
        a.add("w");
        for (String string : a) {
            System.out.println(string);
        }
        
        for (String temp : a) {
            if("2".equals(temp)){
                a.remove(temp);
            }
        }
        
        for (String string : a) {
            System.out.println(string);
        }

输出：

1
2

java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
    at java.util.ArrayList$Itr.next(ArrayList.java:831)
    at test.Test_ForeachAndIterator.testLoopInList(Test_ForeachAndIterator.java:19)

出现错误了

原因：首先从错误中可以看出，是ArraList中的Iterator的checkForComodification()出现的错误，说明了foreach的实现原理其实就是实现了内部类I特Iterator来进行遍历的，其次为什么会出错呢？

因为在ArrayList和ArrayList的内部类的Iterator中的都会存在remove的方法，而ArrayList和Iterator中都各自有自己的维持长度的变量，前者是modCount，后者是expectModCount，但是源码中ArrayList的remove方法是会改变modCount的值，但却不会直接同步到expectModCount的值的，而Iterator中时刻都插入了checkForComodification()方法来监测modCount是否与expectModCount相等，所以就会很容易出现异常错误，当然下面的代码也是错的

    public void testLoopInList(){
        List<String> a = new ArrayList<String>();
        a.add("1");
        a.add("2");
        
        for (String string : a) {
            System.out.println(string);
        }
        
        Iterator<String> it = a.iterator();
        while(it.hasNext()){
            if("1".equals(it.next())){
                a.remove(it.next());
            }
        }
        
        for (String string : a) {
            System.out.println(string);
        }
    }

错误原因同上

所以在解决问题的关键就是要避免这个异常的出现，也就是时刻让modCount==expectModCount,所以就是使用iterator的remove方法，因为会有使两者相等的代码

即下面：

public void testLoopInList(){
        List<String> a = new ArrayList<String>();
        a.add("1");
        a.add("2");
        
        for (String string : a) {
            System.out.println(string);
        }
        
        Iterator<String> it = a.iterator();
        while(it.hasNext()){
            if("1".equals(it.next())){
                it.remove();
            }
        }
        
        for (String string : a) {
            System.out.println(string);
        }
    }

相关源码提上:

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();
   }

ArrayList中的remove

    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

当然你说我不用for增强，就用普通的for ，就不会有创建Iterator的操作，进而就不会有Iterator的实时监测维护值得操作，也行啊，但还是要注意有坑啊！ 比如我们来看下面的代码：

List list = new ArrayList();
        Collections.addAll(list, 1, 2, 3, 4, 5);
        for(int i = 0; i < list.size(); ++i){
            int val = (int) list.get(i);
            
            // 需求是删除 3 和 4 两个元素
            if(3 == val || 4 == val){
                list.remove(i);
            }
        }

这是我们非常常见的写法，结果 为 ：1 2 3 4

奇怪了，4为甚没有删除掉，其实仔细想想 还是能相同的 删除了3之后 i = 3 size = 4，这时候，list.get返回值为5， 会跳过4

所以 修改的话，两个 liter tips ： 要么自己维护索引，要么反向循环

        for(int i = list.size() - 1; i > 0; --i){
            int val = (int) list.get(i);
            
            // 需求是删除 3 和 4 两个元素
                        if(3 == val || 4 == val){
                            list.remove(i);
                        }
        }

for(int i = 0; i < list.size(); ++i){
            int val = (int) list.get(i);
            
            // 需求是删除 3 和 4 两个元素
            if(3 == val || 4 == val){
                list.remove(i);
                i --; // 删除后，索引也应该变化
            }
        }

ok, that's all ...