Java--迭代器（Iterator）迭代原理

Java中迭代器（Iterator）是一个接口，通过构造方法iterator()可以获取迭代器

public interface Iterable {
    /**
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    Iterator iterator();
}

Collection继承自 Iterable

public interface Iterator {
    /**
     * Returns {@code true} if the iteration has more elements.
     * (In other words, returns {@code true} if {@link #next} would
     * return an element rather than throwing an exception.)
     *
     * @return {@code true} if the iteration has more elements
     */
    boolean hasNext();

    /**
     * Returns the next element in the iteration.
     *
     * @return the next element in the iteration
     * @throws NoSuchElementException if the iteration has no more elements
     */
    E next();
}

1、Collection接口是其子接口，他是所有单一元素集合的父类接口 

集合中不能直接存储基本数据类型，也不能存 java对象，只是存储java对象的内存地址

（1）没有使用“泛型”之前，Collection中可以存储Object的所有子类型

（2）使用了“泛型”之后，Collection中只能存储某个具体的类型。Collection中什么都能存， 只要是Object的子类型就行

2、Collection中的常用方法

（1）boolean add(Object e)   向集合中添加元素

（2）int size()         获取集合中元素的个数

（3）void clear()     清空集合

（4）boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false

（5）boolean remove(Object o) 删除集合中的某个元素

（6）boolean isEmpty()          判断该集合中元素的个数是否为0

（7）Object[] toArray()           把集合转换成数组

public interface Collection extends Iterable {
    // Query Operations

    int size();

    boolean isEmpty();

    Iterator iterator();

    Object[] toArray();

     T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection c);

    boolean addAll(Collection c);

    boolean removeAll(Collection c);

    void clear();

    boolean equals(Object o);

    int hashCode();
}

我们主要看一下迭代器的遍历/迭代原理，如下代码，在集合中添加元素，然后进行遍历

1、获取集合对象的迭代器对象it
        Iterator it = c.iterator();

2、通过迭代器对象迭代/遍历

public class CollectionTest {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        c.add("abc");
        c.add(3.14);
        c.add(100);
        c.add(true);
        c.add(new Object());

        /**
         * 对集合Collection进行遍历/迭代
         *
         * boolean hasNaext() 集合中元素是否可以迭代，可以返回true
         * Object next() 返回下一个元素
         * */
        //1、获取集合对象的迭代器对象it
        Iterator it = c.iterator();

        //2、通过迭代器对象迭代/遍历
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

画图理解如下：

注：

集合元素的remove

（1）当集合的结构发生改变时，迭代器必须重新获取，如果还是用以前老的迭代器，会出现 异常：java.util.ConcurrentModificationException

（2）在迭代集合元素的过程中，不能调用集合对象collection的remove方法，删除元素： collection.remove(o); 否则会出现异常：java.util.ConcurrentModificationException

（3）在迭代元素的过程当中，一定要使用迭代器Iterator的remove方法，删除元素， 不要使用集合自带的remove方法删除元素。

public class CollectionTest06 {
    public static void main(String[] args) {
        // 创建集合
        Collection c = new ArrayList();

        // 注：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。
        // 集合结构只要发生改变，迭代器必须重新获取。
        // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：会出现异常；java.util.ConcurrentModificationException
        Iterator it = c.iterator();

        // 添加元素
        c.add(1); // Integer类型

        // 获取迭代器
        //Iterator it = c.iterator();
        /*while(it.hasNext()){
            // 编写代码时next()方法返回值类型必须是Object。
            // Integer i = it.next();
            Object obj = it.next();
            System.out.println(obj);
        }*/

        Collection c2 = new ArrayList();
        c2.add("abc");
        c2.add("def");
        c2.add("xyz");

        Iterator it2 = c2.iterator();
        while(it2.hasNext()){
            Object o = it2.next();
            // 删除元素
            // 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器
            // 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java.util.ConcurrentModificationException
            // 出异常根本原因是：集合中元素删除了，没有更新迭代器（迭代器不知道集合变化了）
            //c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同。）

            // 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。
            it2.remove(); // 删除的一定是迭代器指向的当前元素。
            System.out.println(o);
        }

        System.out.println(c2.size()); //0
    }
}