设计模式之旅22--迭代器模式

1. 定义

迭代器模式：提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。

迭代器是为容器服务的。迭代器模式提供了遍历容器的方便性，容器只要管理增减元素就可以了，需要遍历时交由迭代器进行。

迭代器模式

2. 使用场景

• 需要遍历一个容器对象的时候。
• 由于Java API已经提供了java.util.Iterator接口，并且基本的容器类已经实现了这个接口。换句话说，Java已经把迭代器模式融入到基本的API中，因此开发者不需要手写迭代器模式。

3. 实现

迭代器：

/**
 * 抽象迭代器：抽象迭代器负责定义访问和遍历元素的接口
 */
public interface Iterator {
    //遍历到下一个元素
    Object next();
    //是否已经遍历到尾部
    boolean hasNext();
    //删除当前指向的元素
    boolean remove();
}

/**
 * 具体迭代器
 */
public class ConcreteIterator implements Iterator {

    private Vector mVector;
    //定义当前游标
    private int mCursor = 0;

    public ConcreteIterator(Vector vector) {
        this.mVector = vector;
    }

    @Override
    public Object next() {
        if (this.hasNext()) {
            return this.mVector.get(this.mCursor++);
        } else {
            return null;
        }
    }

    @Override
    public boolean hasNext() {
        if (this.mCursor == this.mVector.size()) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public boolean remove() {
        this.mVector.remove(this.mCursor);
        return true;
    }
}

容器：

/**
 * 抽象容器：容器角色负责提供容器的基本操作、创建具体迭代器角色的接口，在Java中一般是iterator()方法。
 */
public interface Aggregate {
    void add(Object o);
    void remove(Object o);
    Iterator iterator();
}

/**
 * 具体容器
 */
public class ConcreteAggregate implements Aggregate {

    private Vector mVector = new Vector();

    @Override
    public void add(Object o) {
        this.mVector.add(o);
    }

    @Override
    public void remove(Object o) {
        this.mVector.remove(o);
    }

    @Override
    public Iterator iterator() {
        return new ConcreteIterator(this.mVector);
    }
}

场景类：

public class Client {

    public static void main(String[] args) {
        Aggregate agg = new ConcreteAggregate();
        agg.add("a");
        agg.add("b");
        agg.add("c");

        Iterator iterator = agg.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

4. 优点

• 支持以不同的方式去遍历一个容器对象，也可以有多个遍历。
• 弱化了容器类与遍历算法之间的关系。

5. 缺点

• 类文件增加。