Java设计模式16：迭代器模式（Iterator）

迭代器模式

意图

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示，其实这个我们就一直在使用List中的Iterator就是迭代器模式实现

适用性

1、访问一个聚合的对象的内容而又无绪暴露他的内部表示

2、支持对聚合对象的多种遍历

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

结构

Iterator

迭代器定义访问和遍历元素的接口

ConcreteIterator

具体迭代器实现迭代器的接口

对该聚合遍历时跟踪当前位置

Aggregate

聚合定义创建响应迭代器对象的接口

ConcreteAggregate

具体聚合实现创建相应迭代器的接口，该操作返回COncreteIterator的一个适当的实例

实现

实现我们就重新写一个简单的Iterator，

package iterator;

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

/**
 * @Author fitz.bai
 * @Date 2018/9/4 20:59
 */
public abstract class AbstractList {
    protected List<Object> objects = new ArrayList<>();

    public AbstractList(List<Object> objects) {
        this.objects = objects;
    }

    public void addObject(Object o) {
        this.objects.add(o);
    }

    public void removeObject(Object o) {
        this.objects.remove(o);
    }

    public List getObjects() {
        return this.objects;
    }

    public abstract AbstractIterator createIterator();
}

package iterator;

import java.util.List;

/**
 * @Author fitz.bai
 * @Date 2018/9/4 21:04
 */
public class ConcreteList extends AbstractList {
    public ConcreteList(List<Object> objects) {
        super(objects);
    }

    @Override
    public AbstractIterator createIterator() {
        return new ConcreteIterator(this);
    }
}

package iterator;

/**
 * @Author fitz.bai
 * @Date 2018/9/4 21:02
 */
public interface AbstractIterator {
    void next();

    boolean isLast();

    void previous();

    boolean isFirst();

    Object getNextItem();

    Object getPreviousItem();
}

package iterator;

import java.util.List;

/**
 * @Author fitz.bai
 * @Date 2018/9/4 21:05
 */
public class ConcreteIterator implements AbstractIterator {
    private ConcreteList concreteList;
    private List products;
    private int cursor1;
    private int cursor2;

    public ConcreteIterator(ConcreteList concreteList) {
        this.concreteList = concreteList;
        this.products = concreteList.getObjects();
        this.cursor1 = 0;
        this.cursor2 = products.size() - 1;
    }

    @Override
    public void next() {
        if (cursor1 < products.size()) {
            cursor1++;
        }
    }

    @Override
    public boolean isLast() {
        return (cursor1 == products.size());
    }

    @Override
    public void previous() {
        if (cursor2 > -1) {
            cursor2--;
        }
    }

    @Override
    public boolean isFirst() {
        return (cursor2 == -1);
    }

    @Override
    public Object getNextItem() {
        return products.get(cursor1);
    }

    @Override
    public Object getPreviousItem() {
        return products.get(cursor2);
    }

}

package iterator;

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

/**
 * @Author fitz.bai
 * @Date 2018/9/4 20:58
 */
public class Client {
    public static void main(String[] args) {
        List products = new ArrayList();
        products.add("0");
        products.add("1");
        products.add("2");
        products.add("3");
        products.add("4");

        AbstractList abstractList;
        AbstractIterator abstractIterator;

        abstractList = new ConcreteList(products);
        abstractIterator = abstractList.createIterator();

        while (!abstractIterator.isLast()) {
            System.out.print(abstractIterator.getNextItem() + ",");
            abstractIterator.next();
        }
    }
}

// 0,1,2,3,4,

迭代器模式是一种使用频率非常高的设计模式，通常我们只需要直接使用Java、C#等语言已定义好的迭代器即可

优点

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

2、在同一个聚合对象上可以定义多种遍历方式。

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

4、 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

1. 主要缺点

迭代器模式的主要缺点如下：

(1) 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性

(2) 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展