设计模式之迭代器模式

模式定义：

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而不是暴露其内部的表示

迭代器模式把在元素之间游走的责任交给迭代器，而不是聚合对象

模式结构：

模式实现：

public class IteratorMode {
    /**
     * 测试类
     */
    @Test
    public void iteratorTest() {
        //存储 容器 的集合
        List<ICreateIterator> createIterators = new ArrayList<>();
        //创建一个容器，并加入到集合中
        BookArray bookArray = new BookArray(100);
        bookArray.addBook("array a");
        bookArray.addBook("array b");
        createIterators.add(bookArray);
        //创建另一个容器，并加入到集合中
        BookList bookList = new BookList();
        bookList.addBook("list a");
        bookList.addBook("list b");
        createIterators.add(bookList);
        //把集合中 每个容器的 每一个item打印出来
        for (ICreateIterator iCreateIterator : createIterators) {
            IIterator iIterator = iCreateIterator.createIterator();
            while (iIterator.hasNext()) {
                System.out.println(iIterator.next());
            }
        }
    }

    /**
     * 容器接口
     */
    interface ICreateIterator<T> {
        IIterator<T> createIterator();
    }

    /**
     * 数组实现的books
     */
    class BookArray implements ICreateIterator<String> {
        String[] books;
        int position = 0;

        public BookArray(int size) {
            books = new String[size];
        }

        public void addBook(String name) {
            books[position++] = name;
        }

        @Override
        public IIterator<String> createIterator() {
            return new BookArrayIterator(books);
        }
    }

    /**
     * list实现的books
     */
    class BookList implements ICreateIterator<String> {
        List<String> books;

        public BookList() {
            books = new ArrayList<>();
        }

        public void addBook(String name) {
            books.add(name);
        }

        @Override
        public IIterator<String> createIterator() {
            return new BookListIterator(books);
        }
    }

    /**
     * 仿照Iterator写的接口，迭代器接口
     *
     * @param <T>
     */
    interface IIterator<T> {
        boolean hasNext();

        T next();

        void remove();
    }

    /**
     * array books的迭代器
     */
    class BookArrayIterator implements IIterator<String> {
        String[] books;
        int position = 0;

        public BookArrayIterator(String[] books) {
            this.books = books;
        }

        @Override
        public boolean hasNext() {
            if (position > books.length - 1 || books[position] == null) {
                return false;
            }
            return true;
        }

        @Override
        public String next() {
            return books[position++];
        }

        @Override
        public void remove() {
            if (position < 1) {
                throw new IllegalStateException("you can't remove an item util you have done at least one next()");
            }
            for (int i = position - 1; i < books.length - 1; i++) {
                books[i] = books[i + 1];
            }
            books[books.length - 1] = null;
        }
    }

    /**
     * lsit books的迭代器
     */
    class BookListIterator implements IIterator<String> {

        List<String> books;
        Iterator<String> iterator;

        public BookListIterator(List<String> books) {
            this.books = books;
            iterator = books.iterator();
        }

        @Override
        public boolean hasNext() {
            return iterator.hasNext();
        }

        @Override
        public String next() {
            return iterator.next();
        }

        @Override
        public void remove() {
            iterator.remove();
        }
    }
}

模式优点：

1、它支持以不同的方式遍历一个聚合对象。

2、迭代器简化了聚合类

3、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码

模式缺点：

1、由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性

适用场景：

1、访问一个聚合对象的内容而无须暴露它的内部表示

2、需要为聚合对象提供多种遍历方式

3、为遍历不同的聚合结构提供一个统一的接口

注意点：

1、java.util.Iterator中的remove()方法，移除的是next()方法得到的那个值。