(行为型模式)迭代器模式

74 阅读2分钟

简介

迭代器模式,常见的就是我们日常使用的iterator遍历。如果我们的集合元素是用不同的方式实现的,有数组,还有java的集合类,或者还有其他方式,当客户端要遍历这些集合元素的时候就要使用多种遍历方式,而且还会暴露元素的内部结构,可以考虑使用迭代器模式解决。

角色

  • 抽象聚合(Aggregate)角色:定义了存储、添加、删除聚合对象以及创建迭代对象的接口
  • 具体聚合(ConcreteAggregate)角色:实现抽象聚合类,返回一个具体迭代器的实例
  • 抽象迭代器(Iterator)角色:定义访问和遍历和聚合元素接口,通常包含 hasNext()、next()等方法
  • 具体迭代器(ConcreteIterator)角色:实现抽象迭代器接口中所定义的方法,完成对聚合对象的遍历,记录遍历的当前位置

示例

抽象迭代器

public interface Interator {
    
    boolean hasNext();
    
    Object next();
    
}

抽象聚合

public abstract class Collection {
    
    public abstract int size();
    
    public abstract Object get(int index);
    
    public abstract void add(Object ele);
    
    public abstract Iterator iterator();
}

具体迭代器

public class ConcerteInterator implements Iterator  {

    private Collection collection;
    int index = 0;

    public ConcerteInterator(Collection collection){
        this.collection = collection;
    }

    @Override
    public boolean hasNext() {
        return index!=collection.size();
    }

    @Override
    public Object next() {
        return collection.get(index++);
    }
}

具体聚合

public class ConcreteCollection extends Collection{

    Object[] elements;
    private static final int COLLECTION_SIZE = 1<<10;
    int index;

    public ConcreteCollection(){
        index = 0;
        elements = new Object[COLLECTION_SIZE];
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public Object get(int index) {
        return elements[index];
    }

    @Override
    public void add(Object ele) {
        elements[index++] = ele;
    }

    @Override
    public Iterator iterator() {
        return new ConcerteInterator(this);
    }
}

使用

public class Demo {

    public static void main(String[] args) {
        Collection collection = new ConcreteCollection();
        collection.add("1");
        collection.add("2");
        collection.add("3");
        collection.add("4");
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

输出

S4xmoYXkdg.jpg

优缺点

优点

  • 访问一个聚合对象的内容而无须暴露它的内部表示。
  • 遍历任务交由迭代器完成,这简化了聚合类。
  • 增加新的聚合类和迭代器类都很方便,无需修改原有代码

缺点

增加了类的个数,这在一定程度上增加了系统的复杂性