迭代器模式( Iterator Design Pattern)

19-06-11 jdon
              

目的

它属于  行为设计模式 目录。

提供按顺序访问聚合对象的元素而不暴露其内部表示的方法。

迭代器模式的优点

  • 它支持集合遍历中的变化。

  • 它简化了到集合的接口。

结构

参与者

1.迭代器 Iterator

  • 定义用于访问和遍历元素的接口。

2. ConcreteIterator

  •  实现Iterator接口。 
  •  跟踪聚合遍历中的当前位置。

3.聚合 Aggregate

  • 定义用于创建Iterator对象的接口。

4. ConcreteAggregate

  • 实现Iterator创建接口以返回适当的ConcreteIterator的实例。

合作

  •  ConcreteIterator跟踪聚合中的当前对象,并可以计算遍历中的后续对象。 

源代码

第1步:创建  Iterator  接口。

/**
 * 
 * ItemIterator interface.
 * 
 */
public interface ItemIterator {

  boolean hasNext();

  Item next();
}

第2步:创建Item类(迭代项列表)。

public class Item {

  private ItemType type;
  private String name;

  public Item(ItemType type, String name) {
    this.setType(type);
    this.name = name;
  }

  @Override
  public String toString() {
    return name;
  }

  public ItemType getType() {
    return type;
  }

  public final void setType(ItemType type) {
    this.type = type;
  }
}

第3步:为ItemTypes创建枚举

public enum ItemType {

  ANY, WEAPON, RING, POTION

}

第4步:创建  包含项集合的TreasureChest类。

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * TreasureChest, the collection class.
 * 
 */
public class TreasureChest {

  private List<Item> items;

  /**
   * Constructor
   */
  public TreasureChest() {
    items = new ArrayList<>();
    items.add(new Item(ItemType.POTION, "Potion of courage"));
    items.add(new Item(ItemType.RING, "Ring of shadows"));
    items.add(new Item(ItemType.POTION, "Potion of wisdom"));
    items.add(new Item(ItemType.POTION, "Potion of blood"));
    items.add(new Item(ItemType.WEAPON, "Sword of silver +1"));
    items.add(new Item(ItemType.POTION, "Potion of rust"));
    items.add(new Item(ItemType.POTION, "Potion of healing"));
    items.add(new Item(ItemType.RING, "Ring of armor"));
    items.add(new Item(ItemType.WEAPON, "Steel halberd"));
    items.add(new Item(ItemType.WEAPON, "Dagger of poison"));
  }

  ItemIterator iterator(ItemType itemType) {
    return new TreasureChestItemIterator(this, itemType);
  }

  /**
   * Get all items
   */
  public List<Item> getItems() {
    List<Item> list = new ArrayList<>();
    list.addAll(items);
    return list;
  }

}

第5步:让我们创建一个Iterator实现类TreasureChestItemIterator.java

import java.util.List;

/**
 * 
 * TreasureChestItemIterator
 *
 */
public class TreasureChestItemIterator implements ItemIterator {

  private TreasureChest chest;
  private int idx;
  private ItemType type;

  /**
   * Constructor
   */
  public TreasureChestItemIterator(TreasureChest chest, ItemType type) {
    this.chest = chest;
    this.type = type;
    this.idx = -1;
  }

  @Override
  public boolean hasNext() {
    return findNextIdx() != -1;
  }

  @Override
  public Item next() {
    idx = findNextIdx();
    if (idx != -1) {
      return chest.getItems().get(idx);
    }
    return null;
  }

  private int findNextIdx() {

    List<Item> items = chest.getItems();
    boolean found = false;
    int tempIdx = idx;
    while (!found) {
      tempIdx++;
      if (tempIdx >= items.size()) {
        tempIdx = -1;
        break;
      }
      if (type.equals(ItemType.ANY) || items.get(tempIdx).getType().equals(type)) {
        break;
      }
    }
    return tempIdx;
  }
}

第6步:创建App类以测试Iterator模式。

public class App {

  /**
   * Program entry point
   * 
   * @param args command line args
   */
  public static void main(String[] args) {
    TreasureChest chest = new TreasureChest();

    ItemIterator ringIterator = chest.iterator(ItemType.RING);
    while (ringIterator.hasNext()) {
      System.out.println(ringIterator.next());
    }

    System.out.println("----------");

    ItemIterator potionIterator = chest.iterator(ItemType.POTION);
    while (potionIterator.hasNext()) {
      System.out.println(potionIterator.next());
    }

    System.out.println("----------");

    ItemIterator weaponIterator = chest.iterator(ItemType.WEAPON);
    while (weaponIterator.hasNext()) {
      System.out.println(weaponIterator.next());
    }

    System.out.println("----------");

    ItemIterator it = chest.iterator(ItemType.ANY);
    while (it.hasNext()) {
      System.out.println(it.next());
    }
  }
}

适用性

  • 访问聚合对象的内容而不暴露其内部表示

  • 支持聚合对象的多次遍历

  • 为遍历不同的聚合结构提供统一的接口