设计模式之三：迭代器模式

1. 前言

       迭代器模式（Iterator）提供了一种方法，它可以顺序访问一个对象当中的各个元素，但是又不暴露这个聚合对象的内部标示。听起来和遍历很像，个人感觉就是遍历，即是，迭代器提供了一个方法，可以顺序对象内部的某个容器，而不用知道容器中存放的是什么类型．在java中，迭代器使用非常广泛，类似于，HashSet, HashMap,ArrayList,对于它们存储的内部元素,均可以用其内部的迭代器对象进行访问。
    以HashSet,写的简单的Demo,如下:

public class myClass {
    public static void main(String[] args){
        System.out.println("This is a good test!");
        Set<String> temp = new HashSet<>();
        temp.add("11");
        temp.add("22");
        temp.add("33");
        System.out.println(" temp ="+temp);
        Iterator<String> result = temp.iterator();
        while(result.hasNext()){
            System.out.println("temp ="+result.next());
        }
    }
}

输出:
 temp =[11, 22, 33]
 temp =11
 temp =22
 temp =33
 Process finished with exit code 0

这里我们可以认为，迭代器是是容器内部的一个工具，通过这个工具我们可以访问当前容器的内部元素．举一个生活中的例子，迭代器就像一辆老式公交车上的售票员，他会向每个乘客收费．

2.框架
                

                                                                                                  迭代器UML图

         一方面,Iterator为迭代器抽象基类,主要提供该迭代器的基本方法. ConcreteIterator 为迭代器实现类, 它内部包含了一个拥有它的对象, 通过内部方法访问对象的容器. 另外方面, Aggregate  为实体基类,内部拥有一个抽象获取的方法, ConcreteAggregate  为其实现内. 通过iterator  得到一个迭代器,以达到访问内部容器的目的.

         最后, 当用户得到一个ConcreteAggregate 的一个具体对象后,通过ConcreteAggregate.iterator() 获得迭代器,然后就可以其内部元素了, 这也是我们最终希望达到的目的.

3.案例实现

      自己写一个迭代器的案例:
3.1. 抽象的虚拟类

public abstract class Iterator {
    public abstract Object first();
    public abstract Object end();
    public abstract Object Next();
    public abstract Object previous();
    public abstract boolean isDone();
    public abstract boolean isDoneBackToPrevious();
    public abstract Object currentItem();
}

3.2. 抽象的实体类:

public abstract class Aggregate {
    public abstract Iterator iterator();
}

3.3.实体的迭代器类

public class ConcreteIterator extends Iterator {
    public ConcreteAggregate aggregate;
    public int current =0;
    public ConcreteIterator(ConcreteAggregate agr){
        aggregate = agr;
        current = 0/*aggregate.count()-1*/;
    }

    @Override
    public Object currentItem() {
        return aggregate.getObect(current);  }

    @Override
    public boolean isDone() {
        if (current> aggregate.count()-1) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean isDoneBackToPrevious(){
        if (current > 0) {
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        Object temp = null;
        current++;
        if (current < aggregate.count()) {
            temp = aggregate.getObect(current);
        }
        return temp;
    }

    @Override
    public Object previous() {
        Object temp = null;
        current--;
        if (current >-1){
            temp = aggregate.getObect(current);
        }
        return temp;
    }

    @Override
    public Object end() {
        return aggregate.getObect(aggregate.count()-1);
    }

    @Override
    public Object first() {
        return aggregate.getObect(0);
    }
}

3.4. 实体的对象类

这个类需要使用迭代器类

public class ConcreteAggregate extends Aggregate {
    private List temp = new ArrayList();

    @Override
    public Iterator iterator() {
        return new ConcreteIterator(this);
    }
    public int count(){
        if (temp == null) {
            return 0;
        } else {
            return temp.size();
        }
    }
    public Object getObect(int index){
        return  temp.get(index);
    }
    public void setObject(int index , Object value){
        temp.add(index, value);
    }
}

3.5. 主函数

主要的主要功能是new 对象类,然后使用其了内部的迭代器类进行实验. 这里使用倒序访问内部元素进行测试(删除部分代码,把注释的代码还原,就可以进行从正序访问)

public class myClass {
    public static void main(String[] args){
        ConcreteAggregate temp = new ConcreteAggregate();
        temp.setObject(0, "One");
        temp.setObject(1,"Two");
        temp.setObject(2, "Three");
        Iterator iterator = temp.iterator();
        if (iterator != null){
            while (!iterator.IsDone()){
                System.out.println("-------"+iterator.CurrentItem());
                iterator.Next();
            }
        }
    }
}

输出:

-------One
-------Two
-------Three

Process finished with exit code 0