迭代器模式

深碍√TFBOYSˉ_ 2021-10-15 09:33 463阅读 0赞

在软件开发中，可以存储多个成员对象的类称为**聚合类（Aggregate Classes）**，对应的对象称为聚合对象。迭代器模式可以让客户端在无须了解聚合对象的内部结构的情况下，即可实现对聚合对象中的成员的遍历

**迭代器模式（Iterator Pattern）：**提供一种方法访问聚合对象，而不用暴露该对象的内部实现。别名为**游标（Cursor）**。是一种对象行为型模式

完成迭代器模式至少要4个角色

抽象迭代器（Iterator）：定义访问和遍历元素的接口，声明用于遍历数据元素的方法

具体迭代器（ConcreteIterator）：实现了抽象迭代器

抽象聚合类（Aggregate）：存储和管理元素对象，声明一个创建迭代器对象得方法

具体聚合类（ConcreteAggregate）：实现了抽象迭代器

下面代码演示迭代器模式

这里以遍历书籍为例

定义书籍实体类

package com.design.behavioral.iterator;
    
    public class Book {
    
        private String name;
    
        public Book(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }

定义抽象迭代器

package com.design.behavioral.iterator;
    
    public interface BookIterator {
    
        Book nextBook();
    
        boolean isLastBook();
    }

定义具体迭代器

package com.design.behavioral.iterator;
    
    import java.util.List;
    
    public class BookIteratorImpl implements BookIterator{
    
        private List list;
    
        private int position;
    
        public BookIteratorImpl(List list) {
            this.list = list;
        }
    
        @Override
        public Book nextBook() {
            System.out.println("书籍的位置是:" + position);
            Book book = (Book) list.get(position);
            position++;
            return book;
        }
    
        @Override
        public boolean isLastBook() {
            if (position < list.size()){
                return false;
            }
            return true;
        }
    }

定义抽象聚合类

package com.design.behavioral.iterator;
    
    public interface BookAggregate {
    
        void addBook(Book book);
    
        void removeBook(Book book);
    
        BookIterator getBookIterator();
    }

定义具体聚合类

package com.design.behavioral.iterator;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class BookAggregateImpl implements BookAggregate{
    
        private List<Book> list;
    
        public BookAggregateImpl() {
            this.list = new ArrayList<Book>();
        }
    
        @Override
        public void addBook(Book book) {
            this.list.add(book);
        }
    
        @Override
        public void removeBook(Book book) {
            this.list.remove(book);
        }
    
        @Override
        public BookIterator getBookIterator() {
            return new BookIteratorImpl(list);
        }
    }

类图如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dzanp6Y2Jx_size_16_color_FFFFFF_t_70][]

测试调用

package com.design.behavioral.iterator;
    
    public class TestMain {
    
        public static void main(String[] args) {
            Book book1 = new Book("红楼梦");
            Book book2 = new Book("三国演义");
            Book book3 = new Book("水浒传");
            Book book4 = new Book("西游记");
            Book book5 = new Book("聊斋志异");
    
            BookAggregate bookAggregate = new BookAggregateImpl();
            bookAggregate.addBook(book1);
            bookAggregate.addBook(book2);
            bookAggregate.addBook(book3);
            bookAggregate.addBook(book4);
            bookAggregate.addBook(book5);
    
            BookIterator bookIterator = bookAggregate.getBookIterator();
            while (!bookIterator.isLastBook()){
                Book book = bookIterator.nextBook();
                System.out.println(book.getName());
            }
        }
    }

调用结果

![20190813181743312.png][]

**迭代器模式总结**

优点：简化了聚合类；分离了聚合对象的遍历行为；符合开闭原则

缺点：类的个数成对增加；增加了系统的复杂性；抽象迭代器设计难度较大

适用场景：访问一个聚合对象而无需暴露它的内部表示；为遍历不同的集合结构提供一个统一接口；为一个聚合对象提供多种遍历方式

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dzanp6Y2Jx_size_16_color_FFFFFF_t_70]: /images/20211015/f9dc5401b8304dd9a55bfe29b5014ad5.png
[20190813181743312.png]: /images/20211015/8e6f8bcc29a84cf6929ab617a5720491.png