迭代器模式

迭代器模式是一种行为型设计模式，它可以使我们更容易地访问集合中的元素，并且无需了解底层数据结构。

意图

迭代器模式主要解决了在不暴露集合底层实现的情况下遍历集合中的元素的问题，同时也能够提供遍历不同类型集合的共同接口。

结构

迭代器模式由以下组成部分:

• 迭代器 (Iterator): 定义在遍历集合时访问元素的方式。迭代器通常具有 hasNext() 和 next() 两个方法，其中 hasNext() 方法用于检查是否还有元素可以遍历，next() 方法返回下一个元素。
• 具体迭代器 (ConcreteIterator): 实现迭代器接口，并提供集合元素的遍历方法。
• 集合 (Aggregate): 定义创建迭代器的接口，或者提供一个方法来返回一个已存在的迭代器。
• 具体集合 (ConcreteAggregate): 实现集合接口，并返回具体的迭代器实例。

下面是一个简单的迭代器模式的 UML 类图:

classDiagram
  Iterator <|.. ConcreteIterator
  Aggregate <|.. ConcreteAggregate
  ConcreteAggregate ..> ConcreteIterator : creates
  Iterator <|.. MenuIterator
  Aggregate <|.. Menu
  Menu -- Iterator
  Client -- Iterator
  Client --> ConcreteIterator
  Client --> ConcreteAggregate
  ConcreteAggregate -> Menus : <<use>>
  
  class Iterator {
    +hasNext(): boolean
    +next(): object
  }
  
  class ConcreteIterator {
    +hasNext(): boolean
    +next(): object
  }
  
  class Aggregate {
    +createIterator(): iterator
  }
  
  class ConcreteAggregate {
    -items: array
    +createIterator(): iterator
  }
  
  class Menu {
    -items: array
    +createIterator(): iterator
  }
  
  class MenuIterator {
    -position: int
    -items: array
    +hasNext(): boolean
    +next(): object
  }
  
  class Client {
    +main(): void
  }

示例

以下是一个简单的菜单应用程序，迭代器模式被用于遍历菜单中的所有项:

// 迭代器接口
interface Iterator {
    boolean hasNext();
    Object next();
}

// 具体迭代器
class MenuIterator implements Iterator {
    private int position = 0;
    private MenuItem[] items;
    
    public MenuIterator(MenuItem[] items) {
        this.items = items;
    }
    
    public boolean hasNext() {
        return position < items.length && items[position] != null;
    }
    
    public MenuItem next() {
        MenuItem item = items[position];
        position++;
        return item;
    }
}

// 集合接口
interface Menu {
    Iterator createIterator();
}

// 具体集合
class Menus implements Menu {
    private MenuItem[] items;
    
    public Menus(int size) {
        items = new MenuItem[size];
    }
    
    public Iterator createIterator() {
        return new MenuIterator(items);
    }
    
    public void addItem(int index, MenuItem item) {
        items[index] = item;
    }
}

// 具体集合项
class MenuItem {
    private String name;
    private String description;
    private double price;
    
    public MenuItem(String name, String description, double price) {
        this.name = name;
        this.description = description;
        this.price = price;
    }
    
    public String getName() {
        return name;
    }
    
    public String getDescription() {
        return description;
    }
    
    public double getPrice() {
        return price;
    }
}

// 客户端
class Client {
    public static void main(String[] args) {
        Menus menus = new Menus(3);
        menus.addItem(0, new MenuItem("Soup of the day", "Delicious soup of the day", 2.99));
        menus.addItem(1, new MenuItem("Steak", "Grilled to perfection", 15.99));
        menus.addItem(2, new MenuItem("Salad", "Fresh greens and veggies", 6.99));
        
        Iterator iterator = menus.createIterator();
        while (iterator.hasNext()) {
            MenuItem item = (MenuItem) iterator.next();
            System.out.println(item.getName() + " (" + item.getPrice() + "): " + item.getDescription());
        }
    }
}

优缺点

优点：

• 分离接口和实现，增加代码复用性。
• 简化了遍历不同类型集合的方式。

缺点：

• 可能会增加代码复杂性。
• 在某些情况下，调用 next() 方法可能会导致性能损失。

适用性

使用迭代器模式当：

• 需要按特定顺序遍历集合元素时。
• 需要对集合操作的代码与集合本身解耦时。
• 需要在不暴露底层集合实现细节的情况下遍历集合。

总结

迭代器模式是一种非常有用的模式，它可以简化集合遍历的操作，提高代码的可读性和可维护性。在实际开发中，它可以帮助我们更好地进行数据的管理和操作。