目的
它属于 行为设计模式 目录。
提供按顺序访问聚合对象的元素而不暴露其内部表示的方法。
迭代器模式的优点
- 它支持集合遍历中的变化。
- 它简化了到集合的接口。
结构
参与者
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());
}
}
}
|
适用性
- 访问聚合对象的内容而不暴露其内部表示
- 支持聚合对象的多次遍历
- 为遍历不同的聚合结构提供统一的接口