Iterator模式

向右看齐 2021-12-15 17:15 238阅读 0赞

一、Iterator

我们在程序中常见的如：

public static void main(String[] args) {
            Integer[] arr = new Integer[10];
            for(int i = 0;i< 10;i++){
                System.out.println(arr[i]);
            }
    
        }

在for循环里面我们的变量i随着循环次数的增加而递增，我们可以通过i的值**顺序遍历数组或者有序集合元素**。

这就是**Iterator模式**，Iterator模式用于在数据集合中按照顺序遍历集合（反复做某件事情，也叫迭代器）。如果我们需要使用这个模式：那我们首先需要又一个Iterator接口（含有 next()方法、hasNext()方法），有了Iterator接口那我们自然需要一个Iterator接口的实现类IteratorImpl，比如我们想遍历一个List，那我们需要有一个List（根据泛型List<Integer、String、等等>）类，我们还需要有一个类这个类既实现Iterator接口又含有我们需要遍历的List，在类里面我们实现具体的hasNext和next方法然后对我们的List进行遍历。

下面我们拿Jdk源码说一下：

这个是***Iterator***接口的源码：

package java.util;
    
    import java.util.function.Consumer;
    
    public interface Iterator<E> {
        //如果仍有元素可以迭代，则返回true。
        boolean hasNext();
    
        //返回迭代的下一个元素
        E next();
    
        //从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
        default void remove() {
            throw new UnsupportedOperationException("remove");
        }
    
        //jdk1.8引入对剩余元素执行action的操作
        default void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (hasNext())
                action.accept(next());
        }
    }

***ListIterator***源码：

package java.util;
    //系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。、、ListIterator 没有当前元素；它的光标位置 
    //始终位于调用 previous() 所返回的元素和调用 next() 所返回的元素之间。长度为 n 的列表的迭代器有 n+1 个可能的指针位置
    
    public interface ListIterator<E> extends Iterator<E> {
        // Query Operations
    
        //以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
        boolean hasNext();
    
        //返回列表中的下一个元素。
        E next();
    
        //如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
        boolean hasPrevious();
    
        //返回列表中的前一个元素。
        E previous();
    
        //返回对 next 的后续调用所返回元素的索引。
        int nextIndex();
    
        返回对 previous 的后续调用所返回元素的索引。
        int previousIndex();
    
    
        // Modification Operations
    
        //从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
        void remove();
    
        用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
        void set(E e);
    
        将指定的元素插入列表（可选操作）。
        void add(E e);
    }

上面的ListIterator（实现了Iterator）就可以理解为我说的Iterator接口，在JDK的ArrayList中因为ArrayList实现了Iterator接口所以我们也有了实现Iterator接口的实现类，ArrayList本身就是我们需要迭代的集合类，那么我们现在还差一个打通ArrayList和Iterator的类，在这里因为ArrayList实现了Iterator接口，所以ArrayList本身就可以做到将自身的元素在实现Iterator的内部类中就行迭代。代码如下：

private class Itr implements Iterator<E> {
           
            int cursor = 0;
    
           
            int lastRet = -1;
    
           
            int expectedModCount = modCount;
    
            public boolean hasNext() {
                return cursor != size();
            }
    
            public E next() {
                checkForComodification();
                try {
                    int i = cursor;
                    E next = get(i);
                    lastRet = i;
                    cursor = i + 1;
                    return next;
                } catch (IndexOutOfBoundsException e) {
                    checkForComodification();
                    throw new NoSuchElementException();
                }
            }
    
            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                try {
                    AbstractList.this.remove(lastRet);
                    if (lastRet < cursor)
                        cursor--;
                    lastRet = -1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException e) {
                    throw new ConcurrentModificationException();
                }
            }
    
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }

private class ListItr extends Itr implements ListIterator<E> {
            ListItr(int index) {
                cursor = index;
            }
    
            public boolean hasPrevious() {
                return cursor != 0;
            }
    
            public E previous() {
                checkForComodification();
                try {
                    int i = cursor - 1;
                    E previous = get(i);
                    lastRet = cursor = i;
                    return previous;
                } catch (IndexOutOfBoundsException e) {
                    checkForComodification();
                    throw new NoSuchElementException();
                }
            }
    
            public int nextIndex() {
                return cursor;
            }
    
            public int previousIndex() {
                return cursor-1;
            }
    
            public void set(E e) {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                try {
                    AbstractList.this.set(lastRet, e);
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    
            public void add(E e) {
                checkForComodification();
    
                try {
                    int i = cursor;
                    AbstractList.this.add(i, e);
                    lastRet = -1;
                    cursor = i + 1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
        }

这样就实现了Iterator模式。

Iterator模式的好处是可以将遍历和实现分离开，其实就是一个Iterator遍历的接口，一个需要遍历的集合接口，不论集合里面是数组集合还是其他集合，我们只需要将集合的具体事例传递给Iterator的实现中进行遍历即可。