for foreach Iterator

List<String> strs=new ArrayList<>();

strs.add("a");

strs.add("b");

for(int i=0;i<strs.size();i++){

  System.out.println("for----"+strs.get(i));

  strs.remove(i);

  i--;

}

//上述代码可以简化为

//        for(int i=0;i<strs.size(); ) {
//            System.out.println("for2----"+strs.get(i));
//            strs.remove(i);
//        }

strs.add("a");

strs.add("b");

Iterator<String> iterator = strs.iterator();

while(iterator.hasNext()){

  String s = iterator.next();

  System.out.println("iterator----"+s);

  strs.remove(s);

}

strs.add("a");

strs.add("b");

//strs={"b","a","b"}

for(String s : strs){

  System.out.println("foreach----"+s);

  strs.remove(s);

}

执行结果：

for----a

for----b

iterator----a

foreach----b

Exception in thread "main" java.util.ConcurrentModificationException

    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)

    at java.util.ArrayList$Itr.next(ArrayList.java:831)

    at basicExercises.exercise.func2(exercise.java:38)

    at basicExercises.exercise.main(exercise.java:12)

总结：

1.如果需要在循环时动态操作对象，需要使用FOR，不能使用foreach和Iterator

Iterator会少操作数据，foreach会引起异常

2.Iterator会少操作数据的原因：

int cursor; // index of next element to return

int lastRet = -1; // index of last element returned; -1 if no such

int expectedModCount = modCount;

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];

}

List长度为2，操作完第一个元素后cursor=1，size=1，hasNext()返回结果为false,系统停止进行，所以会少操作数据。

假设执行到本段代码出List的长度大于2，则会引发异常。引发异常原因和后边的foreach引起异常原因相同。

3.foreach会引起异常的原因：foreach也不是总是引发异常，有时候不引发异常但是会少操作数据（列表长度为2时）。

foreach 内部使用Iterator实现，实现原理为

Iterator<String> iterator = strs.iterator();

while(iterator.hasNext()){

  String s = iterator.next();

  System.out.println("iterator----"+s);

  strs.remove(s);

}

上述代码运行到foreach处时strs={"b","a","b"}

系统初始化的int expectedModCount = modCount;

当代码执行到这一行时expectedModCount =modCount =6

但是每次执行remove操作时最终调用fastRemove ：

private void fastRemove(int index) {

  modCount++;

  int numMoved = size - index - 1;

  if (numMoved > 0)

  System.arraycopy(elementData, index+1, elementData, index,

  numMoved);

  elementData[--size] = null; // clear to let GC do its work

}

执行结束modCount执行了增加，expectedModCount未执行增加。

下一次调用iterator.next()时，执行验证引发异常。

final void checkForComodification() {

  if (modCount != expectedModCount)

  throw new ConcurrentModificationException();

}

3.为什么迭代器中需要记录初始的对象修改次数，每次取出对象时验证修改次数是否发生了变化，如果发生变化则抛出异常。

1）迭代器用于遍历读取数据，如果读取的数据容器已经被其他线程修改，则抛出异常。这也是非线程安全的原因。

2）当数据容器进行了增加、删除、修改时都会引起修改次数的变化，都会引起异常。

3）数据容器进行了增加、删除会引起数据容器的长度发生变化，发生变化时迭代器去读取数据可能会产生超出索引的异常，所以不允许其进行修改。

所以，可以使用迭代器去读取数据而不是操作数据。

for的写法之一：

//代码片段：

ArrayList<Integer> list=new ArrayList<Integer>(Arrays.asList(1,6,2,3,4,5));

Iterator<Integer> itr=list.iterator();

Integer num;

for (int i=0;i<list.size();i++){

  num=itr.next();

  System.out.println(num);

  itr.remove();

}

//运行结果：1 6 2

//代码片段2:

ArrayList<Integer> list=new ArrayList<Integer>(Arrays.asList(1,6,2,3,4,5));

ArrayList<Integer> list2=new ArrayList<Integer>(list);

Iterator<Integer> itr=list.iterator();

Integer num;

for (int i=0;i<list2.size();i++){

  num=itr.next();

  System.out.println(num);

  itr.remove();

}

//运行结果：1 6 2  3 4 5

//代码片段3：

ArrayList<Integer> list=new ArrayList<Integer>(Arrays.asList(1,6,2,3,4,5));

int listLength=list.size();

Iterator<Integer> itr=list.iterator();

Integer num;

for (int i=0;i<listLength;i++){

  num=itr.next();

  System.out.println(num);

  itr.remove();

}

//运行结果：1 6 2  3 4 5