JAVA中循环删除(remove掉)list中元素的方法总结

1.首先说下有几种循环：
            1> for循环遍历list:
                 for(int i=0;i<list.size();i++){
                    
                    
                  }
            2> 增强for循环
                 for(String x:list){
  


                 } 
            3> iterator遍历(迭代)
                Iterator<String> it = list.iterator();
                while(it.hasNext()){
                      
                    String x = it.next();
                   

                 }   

2.  3种循环在遍历集合时,对集合本身操作的注意点:

----for循环遍历list时,对集合进行add或remove操作

for(int i=0;i<list.size();i++){
    if(list.get(i).equals("del"))
        list.remove(i);
}


--会报java.util.ConcurrentModificationException 异常


  这种方式的问题在于，删除某个元素后，list的大小也发生了变化，而你的索引也在改变，所以会导致
你在遍历的时候漏掉某些元素。比如当你删除第1个元素后，继续根据索引访问第2个元素时，因为删除的关系
后面的元素都往前移动了一位，所以实际上访问的是第3个。因此，这种方式可以用在删除特定的一个元素时
使用，但不适合循环删除多个元素的使用。


--解决方案:
      1>  倒过来遍历list
          for(int i=list.size()-1;i>=0;i--){


            list.remove(i);
            
          }
      2> 每移除一个元素以后再把i移过来
         for(int i=0;i<list.size();i++){
            
            list.remove(i)
            i--;
         }

 ----增强for循环和iterator遍历时,对集合进行add或remove操作

for(String x:list){
    
        list.remove(x);//list.add(x);
}
--iterator(迭代)遍历
 Iterator<String> it = list.iterator();
      while(it.hasNext()){
        String x = it.next();
        if(x.equals("del")){
          list.remove();//应该用iterator自己的remove方法
        }
     }




--会报java.util.ConcurrentModificationException //这是一个并发修改异常报错
     at java.util.AbstractList$Itr.checkForComodification(Unknown Source)
     at java.util.AbstractList$Itr.next(Unknown Source)
     异常
   
  1>在遍历集合过程中，增强for循环不能对集合本身进行增删操作！


  2>该list每当删除一个元素时，集合的size方法的值都会减小1，这将直接导致集合中元素的索引重新排序,
    进一步说，就是剩余所有元素的索引值都减1，而for循环语句的局部变量i仍在递增，这将导致删除操作
    发生跳跃。从而导致上述代码的删除出现问题。所以不要在增强for循环里进行元素的remove/add操作！


  3>这种方式的问题在于，删除元素后继续循环会报错,因为元素在使用时发生了并发的修改，导致异常抛出。
    但是删除完毕马上使用break跳出，则不会触发报错。
     for(String x:list){
        if(x.equals("del")){
         list.remove(x);
         break;
        }
     }
  
  4>在遍历集合时，增强for的遍历是封装了迭代器的试遍历方式！(如下)


  5>在AbstractList$Itr这个类中实现了iterator接口，当使用增强的for循环时，应该是使用迭代器
    进行迭代了，如果你在这期间使用了add或remove方法的话,在ArrayList类中执行了这样的代码:
        public boolean add(E e) {
            ensureCapacity(size + 1);  // Increments(增长) modCount!! 
            elementData[size++] = e;
            return true;
        }


     --add中的ensureCapacity(size + 1);的调用代码:
       public void ensureCapacity(int minCapacity) {
        modCount++;//modCount是AbstractList类中的一个成员变量,该值表示对List的修改次数!
        int oldCapacity = elementData.length;
        if (minCapacity > oldCapacity) {
            Object oldData[] = elementData;
            int newCapacity = (oldCapacity * 3)/2 + 1;
                if (newCapacity < minCapacity)
                newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }


    --这里的modCount增加了，但是迭代器中的next方法时,
       public E next() {
            checkForComodification();
            try {
                E next = get(cursor);//cursor：表示下一个要访问的元素的索引
                lastRet = cursor++;//　lastRet：表示上一个访问的元素的索引
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }
    
    --先checkForComodification();
       final void checkForComodification() {
            if (modCount != expectedModCount)//expectedModCount：表示对ArrayList修改次数的期望值，它的初始值为modCount为0。
                throw new ConcurrentModificationException();
        }
     }
    --因此抛出了异常。。。
  ----通俗点讲: 
         迭代器内部的每次遍历都会记录List内部的modcount当做预期值，然后在每次循环中用预期值与List
      的成员变量modCount作比较，但是普通list.remove调用的是List的remove，这时modcount++，
      但是iterator内记录的预期值=并没有变化，所以会报错，
    --但是如果在iterator中调用remove，这时会同步List的modCount到iterator中，故不再报错。
      Iterator<String> it = list.iterator();
      while(it.hasNext()){
        String x = it.next();
        if(x.equals("del")){
          it.remove();
        }
     }
   ---再简单点说:
        调用list.remove()方法导致modCount和expectedModCount的值不一致而报异常