重学设计模式-Iterator（迭代器模式）

Iterator迭代器模式

介绍：

迭代器模式是一种行为型设计模式，它允许你在不暴露集合底层表示（并不知道集合底层使用何种方式对数据尽心存储）的情况下遍历集合中的元素。

• 这种模式提供了一种方法，可以顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。
• 迭代器模式通常包括两个角色：迭代器和聚合对象。
  • 迭代器（Iterator,读取元素）
    • 负责定义访问和遍历元素的接口
    • 实现了该接口的类，拥有访问聚合对象中元素的能力
  • 聚合对象（Aggregate,存储元素）
    • 负责定义创建相应迭代器对象的接口，该接口返回一个适当的迭代器实例
    • 实现了该接口的类将成为一个可以保存多个元素的集合，就像数组一样

以下是一个简单的迭代器实例，演示了如何使用迭代器模式遍历一个集合：

1、抽象实例

创建迭代器接口：

/**
 * 迭代器接口
 *
 * @author supanpan
 * @date 2023/12/21
 */
public interface Iterator<T>{
  /**
   * 判断是否存在下一个元素
   * @return: 循环终止条件
   *  true：集合中存在下一个元素
   *  false：集合中不存在下一个元素
   */
  boolean hasNext();

  /**
   * 获取下一个元素，并且将迭代器指针位置移动到下一个元素
   */
  T next();
}

实现迭代器接口，具体迭代器实现：

/**
 * 具体迭代器实现
 *
 * @author supanpan
 * @date 2023/12/21
 */
public class ConcreteIterator<T> implements Iterator<T> {
  private List<T> list;// 存放元素的列表
  private int position;// 遍历元素的下标

  /**
   * 初始化迭代器
   *
   */
  public ConcreteIterator(List<T> list) {
    this.list = list;
    this.position = 0;
  }

  /**
   * 判断是否到集合的末尾
   *
   */
  @Override
  public boolean hasNext() {
    return position < list.size();
  }

  /**
   * 遍历（迭代）集合取出相应元素
   *
   */
  @Override
  public T next() {
    if (!hasNext()){
      throw new NoSuchElementException("没有元素了......");
    }
    T item = list.get(position);
    position++;
    return item;
  }
}

创建聚合对象：

/**
 * 聚合对象
 *
 * @author supanpan
 * @date 2023/12/21
 */
public interface Aggregate<T> {
    /**
     * 生成一个用于遍历集合的迭代器
     *
     */
    Iterator<T> createIterator();
}

实现聚合对象接口，创建具体聚合对象：

/**
 * 具体聚合对象
 *
 * @author supanpan
 * @date 2023/12/21
 */
public class ConcreteAggregate<T> implements Aggregate<T>{
    private List<T> items;

    public ConcreteAggregate() {
        this.items = new ArrayList<>();
    }

    /**
     * 向集合中添加元素
     * @param item 待添加元素
     */
    public void addItem(T item){
        items.add(item);
    }

    /**
     * 创建迭代器对象
     *
     * @return 具体的迭代器
     */
    @Override
    public Iterator<T> createIterator() {
//         items.sort(null);// 在创建迭代器之前对集合中的元素进行排序操作
        return new ConcreteIterator<>(items);// 将聚合对象中的集合传递给具体迭代器对象，以供访问
    }
}

测试Main:

public class Main {
    public static void main(String[] args) {
        // 创建聚合对象
        ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
        // 向聚合对象中添加元素
        aggregate.addItem("Item 1");
        aggregate.addItem("Item 3");
        aggregate.addItem("Item 2");
        aggregate.addItem("Item 4");

        // 获取迭代器对象
        Iterator<String> iterator = aggregate.createIterator();
        // 使用迭代器模式进行遍历
        while (iterator.hasNext()){
            // 获取迭代器中的元素
            String item = iterator.next();
            System.out.println(item);
        }
    }
}

2、书架实例

创建聚合对象，用于将具体实现类中的集合通过迭代器进行返回

public interface Aggregate<T> {
    Iterator<T> iterator();
}

创建迭代器对象，用于访问聚合对象中的数组数据

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

创建Book对象，Book对象用于获取书籍的名称

public class Book {
    private String name;// 书籍名称

    public Book(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

创建BookShelf对象，这个对象实现了Aggregate接口，拥有聚合元素的能力

public class BookShelf implements Aggregate{
    private ArrayList<Book> books;// 对比抽象实例中的数组，这里改成了存放书籍的列表

    /**
     * 初始化集合对象
     *
     * @param initialSize 集合大小
     */
    public BookShelf(int initialSize){
        this.books = new ArrayList<>(initialSize);
    }
    public Book getBookAt(int index) {
        return (Book) books.get(index);
    }
    public void appendBook(Book book) {
        books.add(book);
    }
    public int getLength() {
        return books.size();
    }

    /**
     * 将书籍数组返回给具体迭代器实现类，提供访问书籍数组的能力
     * 
     */
    public Iterator iterator() {
        return new BookShelfIterator(this);
    }
}

创建BookShelfIterator对象，这个对象实现了Iterator接口，拥有访问聚合对象中的数据能力

public class BookShelfIterator implements Iterator{
  private BookShelf bookShelf;
  private int index;

  /**
   * 初始化迭代器
   * @param bookShelf 聚合对象集合数据
   */
  public BookShelfIterator(BookShelf bookShelf) {
    this.bookShelf = bookShelf;
    this.index = 0;
  }

  @Override
  public boolean hasNext() {
    return index < bookShelf.getLength();
  }

  @Override
  public Object next() {
    Book item = bookShelf.getBookAt(index);
    index++;
    return item;
  }
}

测试类：

public class Main {
    public static void main(String[] args) {
        BookShelf bookShelf = new BookShelf(4);
        bookShelf.appendBook(new Book("时间简史"));
        bookShelf.appendBook(new Book("活着"));
        bookShelf.appendBook(new Book("百年孤独"));
        bookShelf.appendBook(new Book("1984"));
        bookShelf.appendBook(new Book("三体"));
        bookShelf.appendBook(new Book("围城"));
        bookShelf.appendBook(new Book("小王子"));
        bookShelf.appendBook(new Book("云边的小卖部"));

        Iterator it = bookShelf.iterator();
        while (it.hasNext()) {
            Book book = (Book)it.next();
            System.out.println(book.getName());
        }
    }
}

3、Iterator总结

通过以上两个实例，在每个实例中，都出现了相对重要的接口和实现类，这四个关键角色，分别是Iterator（迭代器）、ConcreteIterator（具体的迭代器）、Aggregate（聚合对象）和ConcreteAggregate（具体的聚合对象）。

1. Iterator（迭代器）：

• Iterator是一个接口，它定义了在集合对象上进行迭代的方法
  • hasNext()用于检查是否还有下一个元素
  • next()用于获取下一个元素。

2. ConcreteIterator（具体的迭代器）：

• ConcreteIterator是Iterator接口的具体实现，它持有对应的集合对象，并且在内部实现了迭代逻辑。
• 具体的迭代器类通常会包含一个指向当前元素的游标，并且实现了Iterator接口中定义的方法。

3. Aggregate（聚合对象）：

• Aggregate是一个接口，它定义了创建迭代器对象的方法，例如createIterator()
• 聚合对象是包含一组元素的对象，它通常会提供一种方式来获取迭代器对象，使得外部客户端可以通过迭代器遍历聚合对象中的元素。

4. ConcreteAggregate（具体的聚合对象）：

• ConcreteAggregate是Aggregate接口的具体实现，它实现了创建迭代器对象的方法，并且通常会包含一个内部集合来存储元素。
• 具体的聚合对象类会将迭代器对象的创建委托给具体的迭代器类。

下面是Iterator实现的类图：