设计模式之迭代器模式

java > 设计模式设计模式

发布时间 : 2022-12-08 07:50

阅读 :

评论:

简单梳理迭代器模式
1. 迭代器模式实现
联系作者
1. 微信公众号
2. QQ群

简单梳理迭代器模式

迭代器模式实现

现实生活中，我们经常会遇到遍历一个集合的场景，
比如说乘坐公交的时候，售票员需要遍历每个人，检查是否买票了。
那针对这种场景，就非常适合迭代器模式了。

首先我们定义基本类，抽象基类。

//抽象聚集类
public abstract class Aggregate {
    public abstract Iterator CreateIterator();
}

定义抽象的迭代器类

//迭代器抽象类
public abstract class Iterator {
    public abstract Object First();
    public abstract Object Next();
    public abstract boolean IsDone();
    public abstract Object CurrentItem();
}

定义具体的实现类

public class ConcreteAggregate extends Aggregate {
    private List<Object> items = new ArrayList();

    @Override
    public Iterator CreateIterator() {
        return new ConcreteIterator(this);
    }

    public int Count(){
        return items.size();
    }

    public Object getItems(int index){
        return items.get(index);
    }

    public void setItems(Object item){
        items.add(item);
    }

}

//具体迭代类
public class ConcreteIterator extends Iterator {
    private ConcreteAggregate aggregate;
    private int current = 0;

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

    @Override
    public Object First() {
        return aggregate.getItems(0);
    }

    @Override
    public Object Next() {
        Object ret = null;
        current++;
        if(current<aggregate.Count()){
            ret=aggregate.getItems(current);
        }
        return ret;
    }

    @Override
    public boolean IsDone() {
        return current>=aggregate.Count()?true:false;
    }

    @Override
    public Object CurrentItem() {
        return aggregate.getItems(current);
    }
}

这样我们前期的定义就算做完了,
然后我们看具体应用中的使用。

定义业务方法

看在具体业务逻辑中如何使用

public class IteratorTest {
    public static void main(String[] args) {
        //迭代器模式
        func1();
    }

    public static void func1(){
        ConcreteAggregate a = new ConcreteAggregate();

        a.setItems("大鸟");
        a.setItems("小菜");
        a.setItems("行李");
        a.setItems("老外");
        a.setItems("公交内部员工");
        a.setItems("小偷");

        Iterator i = new ConcreteIterator(a);

        Object item = i.First();
        while(!i.IsDone()){
            System.out.println(i.CurrentItem()+",请买车票!");
            i.Next();
        }
    }
}

执行结果

大鸟,请买车票!
小菜,请买车票!
行李,请买车票!
老外,请买车票!
公交内部员工,请买车票!
小偷,请买车票!

结果分析

迭代器模式，提供一种方法顺序访问一个聚合对象中的各个元素，而不暴漏该对象的内部表示。

那什么场景可以考虑迭代器模式呢？
当你需要访问一个聚集对象，而且不管这些对象是什么，都需要遍历的时候，就可以考虑使用迭代器模式了。

联系作者

微信公众号

xiaomingxiaola
（BossLiu）

QQ群

58726094

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 384276224@qq.com