JAVA-设计模式-迭代器模式

后端 · 2020-11-16 ·

在现实生活以及程序设计中,经常要访问一个聚合对象中的各个元素,如“数据结构”中的链表遍历,通常的做法是将链表的创建和遍历放到同一个类中,但这种方法不利于程序的扩展,如果需要更换遍历的方法就必须修改程序的源码,这违背了“开闭原则”。

定义

提供一个对象来顺序访问聚合对象的一系列数据,而不暴露聚合对象的内部表示。

角色


迭代器模式模式的主要角色如下:

  1. 抽象聚合角色:定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
  2. 具体聚合角色:实现抽象聚合类,返回一个具体迭代器的实例。
  3. 抽象迭代器角色:定义访问和遍历聚合元素的结构,通常包含hasNext()、first()、next()等方法。
  4. 具体迭代器角色:实现抽象迭代器接口中所定义的方法,完成对聚合对象的遍历。

代码

package xin.mla.iterator;

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

public class IteratorTest {

    public static void main(String[] args) {
        Aggregate ags = new ConcreteAggregate();
        ags.add("子鼠");
        ags.add("丑牛");
        ags.add("寅虎");
        ags.add("卯兔");
        Itetator it = ags.getItetator();
        while (it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj.toString() + "\t");
        }
        System.out.println("###########################");
        ags.remove("卯兔");

        Itetator it2 = ags.getItetator();
        while (it2.hasNext()) {
            Object obj = it2.next();
            System.out.println(obj.toString() + "\t");
        }
    }

}

// 抽象聚合
interface Aggregate {
    public void add(Object obj);

    public void remove(Object obj);

    public Itetator getItetator();
}

// 具体聚合
class ConcreteAggregate implements Aggregate {
    private List<Object> lists = new ArrayList<>();

    @Override
    public void add(Object obj) {
        lists.add(obj);
    }

    @Override
    public void remove(Object obj) {
        lists.remove(obj);
    }

    @Override
    public Itetator getItetator() {
        return (new ConcreteItetator(lists));
    }

}

// 抽象迭代器
interface Itetator {
    Object first();

    Object next();

    boolean hasNext();
}

// 具体迭代器
class ConcreteItetator implements Itetator {

    private List<Object> lists = null;
    private int index = -1;

    public ConcreteItetator(List<Object> lists) {
        this.lists = lists;
    }

    @Override
    public Object first() {
        index = 0;
        Object obj = lists.get(index);
        return obj;
    }

    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = lists.get(++index);
        }
        return obj;
    }

    @Override
    public boolean hasNext() {
        if (index < lists.size() - 1) {
            return true;
        }
        return false;
    }

}

优点

  1. 简化了聚合类,遍历任务由迭代器完成。
  2. 增加新的聚合类和迭代器很方便,无需修改源码。
  3. 封装性好,为遍历不同的聚合结构提供一个统一的接口。

缺点

  1. 增加了类的个数。
%