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

谁借莪１个温暖的怀抱￠ 2023-10-02 12:30 100阅读 0赞

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);
            }
        }
    }

画图理解如下：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16][]

注：

集合元素的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
        }
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/a53cc8ed5b3d43ef810c49b0c15f4bef.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_20,color_FFFFFF,t_70,g_se,x_16