迭代器模式Iterator
提供一种方法顺序访问一个聚合对象中各个元素,而又不需要暴露该对的内部表示
Iterator:抽象迭代类,提供遍历所需的开始,下一个,当前是哪个,是否结束等统一接口
ConcreteIterator :具体迭代类具体实现方法
Aggregate :抽象聚集类,有创造Iterator的接口
ConcreteAggregate:时间接口,持有一个聚集元素集合
分离了聚集对象的遍历,由一个迭代器来负责,既不用暴露集合的内部结构,又可让外部代码透明底访问聚集内部数据
使用场景
1一个聚集对象(接口或抽象类集合),不管对象是那种子类都要对其进行遍历时,可考虑使用迭代器模式
2.需要对一个聚集有多种方式遍历时(遍历算法与聚集对象分离,两者可相互改变而不影响可为聚集对象添加多种聚集方式)
JaVA聚集对象即是实现了java.util.Collection接口的对象
实例
Aggregate:
有创建迭代器的窗口
public interface Aggregate {
MyIterator createIterator();
}
ConcreteAggregate:
内部持有聚集对象,使用对象自身创造具体迭代器
public class ConcreteAggregate implements Aggregate{
private List<? extends Object> list;
public ConcreteAggregate(List<? extends Object> list ){
this.list = list;
}
@Override
public MyIterator createIterator() {
return new ConcreteMyIterator(this);// 创建具体迭代器
}
public int count(){
return this.list.size();
}
public Object getElement(int index){
return list.get(index);
}
}
Iterator:
有第一个,下一个,当前是哪个,是否结束等接口
public abstract class MyIterator {
public abstract Object first();
public abstract boolean isLast();
public abstract void next();
public abstract Object CurrentElement();
}
ConcreteMyIterator:
实现上述接口
public class ConcreteMyIterator extends MyIterator{
protected ConcreteAggregate aggregate;
private int index = 0;
private int size=0;
public ConcreteMyIterator(ConcreteAggregate aggregate) {
this.aggregate = aggregate;
this.size = aggregate.count();
}
@Override
public Object first() {
return aggregate.getElement(0);
}
@Override
public boolean isLast() {
if (index < size){
return true;
}else {
return false;
}
}
@Override
public void next() {
if (isLast()) {
index++;
}
}
@Override
public Object CurrentElement() {
return aggregate.getElement(index);
}
}
测试:
public class Test {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(6);
list.add(7);
list.add(5);
ConcreteAggregate ca = new ConcreteAggregate(list);
MyIterator iterator = ca.createIterator();
while (iterator.isLast()){
System.out.println(iterator.CurrentElement());
iterator.next();
}
}
}
输出