
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;    //初始化  expectedModCount 字段
 
    public E next() {
        //获取下个元素时 ， 会先对字段  expectedModCount == modCount  进行校验
        checkForComodification();
        ....
    }
 
    final void checkForComodification() {
        if (modCount != expectedModCount)    //  不相等，会报错
            throw new ConcurrentModificationException();
    }
}

Iterator迭代器

功能：

1，单向遍历

2，遍历过程中，不能增加和修改元素

3，遍历过程中，只能使用 Iterator提供的remove() 删除元素，不能使用Collection.remove() 删除元素

注意事项：

删除元素前，需要先调用next()，否则会报错

因为remove()中，更新 lastRet=-1，而要调用remove()，会先校验lastRet<0，抛异常

范例：


        Collection<Student> c = new ArrayList<Student>();
        Student s1 = new Student("zhang", 12);
        Student s2 = new Student("lsii", 23);
        Student s3 = new Student("wangwu", 24);
        Student s4 = new Student("zhoaliu", 24);
 
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
 
        Iterator<Student> itStu = c.iterator();
        while (itStu.hasNext()) {
            Student s = itStu.next();
            if (s.getName() == "lisi") {
//                c.remove(s1);       会报错
                itStu.remove();       //删除遍历得到的元素
            }
            System.out.println(s);
        }
        System.out.println(c);

方法：

hasNext() 是否还有下一个元素：通过cursor字段，判断是否到达集合边界

next() 先让游标后移一位，再返回索引元素

remove() 删除元素


        public E next() {
            checkForComodification();
            int i = cursor;
            ...
            Object[] elementData = ArrayList.this.elementData;
            ...
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
 
        //不能直接调用，remove前需要调用next（），因为本方法中    lastRet字段
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
 
            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;        //更新  lastRet
                expectedModCount = modCount;    //执行完 remove后，更新 expectedModCount 
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

ListIterator迭代器

描述：弥补了Iterator迭代过程中，不能增加元素

功能：

1，双向遍历

2，遍历过程中，可以使用迭代器方法，增删改集合元素

注意：

1，删除元素前，必须调用next()，否则会报错

因为remove()中，更新 lastRet=-1，而要调用remove()，会先校验lastRet<0，抛异常

2，下面代码中，如果没有调用next()，只是单纯的add()，会导致死循环，直到内存溢出，引发错误

解决方案：

add() 和 next() 一起使用

范例：


        ArrayList<Student> c = new ArrayList<Student>();
        Student s1 = new Student("zhang", 12);
        Student s2 = new Student("lsii", 23);
        Student s3 = new Student("wangwu", 24);
        Student s4 = new Student("zhoaliu", 24);
 
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
 
        ListIterator<Student> listIterator = c.listIterator();
        while(listIterator.hasNext()){
            listIterator.add(s3);
//            listIterator.remove();    //直接删除会报错，需要先获取，再删除，
                                        //因为remove()后，更新  lastRet=-1
            Student next = listIterator.next();
            System.out.println(next);
        }

方法：

hasNext() 是否还有下一个元素：通过cursor字段，判断是否到达集合边界

继承自Iterator

next() 返回下一个元素，继承自Iterator

hasPrevious 是否还有上一个元素

previous() 返回上一个元素

add (）增加元素

remove() 删除元素，继承自Iterator


    private class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            super();
            cursor = index;
        }
 
       public boolean hasPrevious() {
            return cursor != 0;
        }
 
        public E previous() {
            checkForComodification();
            int i = cursor - 1;
            ...
            Object[] elementData = ArrayList.this.elementData;
            ...
            cursor = i;
            return (E) elementData[lastRet = i];
        }
 
        public void add(E e) {
            checkForComodification();
 
            try {
                int i = cursor;
                ArrayList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;        //更新  lastRet
                expectedModCount = modCount;    //执行完add后，更新  expectedModCount 
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

方式2：增强for循环


        Collection<String> strC = new ArrayList<String>();
        strC.add("fa");
        strC.add("");
        strC.add("");
        strC.add("");
        strC.add("ffdasfa");
        for (String s : strC) {
            System.out.println(s);
        }