设计模式-迭代器模式

设计模式-迭代器模式

概念

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

优点

1、它支持以不同的方式遍历一个聚合对象。 

2、迭代器简化了聚合类。 

3、在同一个聚合上可以有多个遍历。 

4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点

1、如果不采用泛型方式，那么增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

角色

Iterator（迭代器）：迭代器定义访问和遍历元素的接口
ConcreteIterator （具体迭代器）：具体迭代器实现迭代器接口，对该聚合遍历时跟踪当前位置
Aggregate （聚合）：聚合定义创建相应迭代器对象的接口
ConcreteAggregate （具体聚合）

使用场景

1、访问一个聚合对象的内容而无须暴露它的内部表示。 

2、需要为聚合对象提供多种遍历方式。 

3、为遍历不同的聚合结构提供一个统一的接口。

案例描述

类似JAVA java.util.Iterator迭代器

UML类图

代码解析UML类图

/**
 * 设计模式-迭代器模式-迭代抽象类
 *
 * Created by laizhiyuan on 2017/6/13.
 */
public abstract class AbstractIterator<T> {

    protected int pointer = 0;

    public abstract T first();

    public abstract boolean hasNext();

    public abstract T last();

    public abstract T next();

    public abstract boolean isDone();

    public abstract T currentItem();
}

/**
 * 设计模式-迭代器模式-迭代具体类
 *
 * Created by laizhiyuan on 2017/6/13.
 */
public class ConcreteIterator<T> extends AbstractIterator<T>{

    private AbstractAggregate<T> aggregate;


    public ConcreteIterator(AbstractAggregate aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public T first() {
        return aggregate.get(0);
    }

    @Override
    public boolean hasNext() {

        if (pointer < aggregate.count()){
            return true;
        }
        return false;
    }

    @Override
    public T last() {
        return aggregate.get(aggregate.count() -1);
    }

    @Override
    public T next() {

        if (pointer < aggregate.count()){

            T t = aggregate.get(pointer);
            pointer++;
            return t;
        }else{

            throw new RuntimeException("Index Bound Exception");
        }

    }

    @Override
    public boolean isDone() {

        if (pointer == aggregate.count() -1){
            return true;
        }
        return false;
    }

    @Override
    public T currentItem() {
        return aggregate.get(pointer);
    }
}

/**
 * 设计模式-迭代器模式-聚集抽象类
 *
 * Created by laizhiyuan on 2017/6/13.
 */
public abstract class AbstractAggregate<T> {

    protected int pointer = 0;

    public abstract AbstractIterator integer();

    public abstract T get(int index);

    public abstract T set(int index, T t);

    public abstract AbstractAggregate add(T t);

    public abstract int count();
}

/**
 * 设计模式-迭代器模式-聚集具体类
 *
 * Created by laizhiyuan on 2017/6/13.
 */
public class ConreteAggregate<T> extends AbstractAggregate<T> {

    private List<T> items = new ArrayList<T>();

    @Override
    public AbstractIterator integer() {
        return new ConcreteIterator<T>(this);
    }

    @Override
    public T get(int index) {
        return items.get(index);
    }

    @Override
    public T set(int index, T t) {
        return items.set(index, t);
    }

    @Override
    public ConreteAggregate add(T t) {
        items.add(pointer, t);
        pointer++;
        return this;
    }

    @Override
    public int count() {
        return items.size();
    }
}

/**
 * Created by laizhiyuan on 2017/6/13.
 */
public class Model {

    private String name;

    private String address;

    private int gender;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Model{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", gender=" + gender +
                '}';
    }
}

测试

控制台输出