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

Posted 2022-02-24 MinggeQingchun

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

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

Collection继承自 Iterable

public interface Iterator<E> 
    /**
     * 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<E> extends Iterable<E> 
    // Query Operations

    int size();

    boolean isEmpty();

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> 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