重学设计模式-Iterator(迭代器模式)

Iterator迭代器模式

介绍:

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

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

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

1、抽象实例

创建迭代器接口:

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

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

实现迭代器接口,具体迭代器实现:

java 复制代码
/**
 * 具体迭代器实现
 *
 * @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;
  }
}

创建聚合对象:

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

实现聚合对象接口,创建具体聚合对象:

java 复制代码
/**
 * 具体聚合对象
 *
 * @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:

java 复制代码
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、书架实例

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

java 复制代码
public interface Aggregate<T> {
    Iterator<T> iterator();
}

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

java 复制代码
public interface Iterator<T> {
    boolean hasNext();
    T next();
}

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

java 复制代码
public class Book {
    private String name;// 书籍名称

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

    public String getName() {
        return name;
    }
}

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

java 复制代码
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接口,拥有访问聚合对象中的数据能力

java 复制代码
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;
  }
}

测试类:

java 复制代码
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()用于获取下一个元素。
  1. ConcreteIterator(具体的迭代器)
  • ConcreteIterator是Iterator接口的具体实现,它持有对应的集合对象,并且在内部实现了迭代逻辑。
  • 具体的迭代器类通常会包含一个指向当前元素的游标,并且实现了Iterator接口中定义的方法。
  1. Aggregate(聚合对象)
  • Aggregate是一个接口,它定义了创建迭代器对象的方法,例如createIterator()
  • 聚合对象是包含一组元素的对象,它通常会提供一种方式来获取迭代器对象,使得外部客户端可以通过迭代器遍历聚合对象中的元素。
  1. ConcreteAggregate(具体的聚合对象)
  • ConcreteAggregate是Aggregate接口的具体实现,它实现了创建迭代器对象的方法,并且通常会包含一个内部集合来存储元素。
  • 具体的聚合对象类会将迭代器对象的创建委托给具体的迭代器类。

下面是Iterator实现的类图:

相关推荐
databook8 小时前
Manim实现闪光轨迹特效
后端·python·动效
Juchecar9 小时前
解惑:NumPy 中 ndarray.ndim 到底是什么?
python
用户83562907805110 小时前
Python 删除 Excel 工作表中的空白行列
后端·python
Json_10 小时前
使用python-fastApi框架开发一个学校宿舍管理系统-前后端分离项目
后端·python·fastapi
晨米酱11 小时前
JavaScript 中"对象即函数"设计模式
前端·设计模式
数据智能老司机16 小时前
精通 Python 设计模式——分布式系统模式
python·设计模式·架构
数据智能老司机17 小时前
精通 Python 设计模式——并发与异步模式
python·设计模式·编程语言
数据智能老司机17 小时前
精通 Python 设计模式——测试模式
python·设计模式·架构
数据智能老司机17 小时前
精通 Python 设计模式——性能模式
python·设计模式·架构
c8i17 小时前
drf初步梳理
python·django