迭代器模式

在软件开发中，可以存储多个成员对象的类称为聚合类（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);
    }
}

 

类图如下

 

测试调用

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

调用结果

 

 

 

迭代器模式总结

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

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

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