设计模式之迭代器模式

迭代器模式

其他模式

迭代器模式是一种行为设计模式， 让你能在不暴露集合底层表现形式 （列表、 栈和树等） 的情况下遍历集合中所有的元素。

迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。

概括： 定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。

模式结构

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

类图

优缺点

优点：

• 访问一个聚合对象的内容而无须暴露它的内部表示。遍历任务交由迭代器完成，这简化了聚合类。
• 单一职责原则。 通过将体积庞大的遍历算法代码抽取为独立的类， 你可对客户端代码和集合进行整理。
• 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
  增加新的聚合类和迭代器类都很方便，无须修改原有代码。
• 开闭原则。 你可实现新型的集合和迭代器并将其传递给现有代码， 无需修改现有代码。

缺点 ：

• 增加了类的个数，这在一定程度上增加了系统的复杂性。
• 对于某些特殊集合， 使用迭代器可能比直接遍历的效率低。

Arraylist中的迭代器模式

内部类Itr 充当具体实现迭代器Iterator 的类， 作为ArrayList 内部类

• List 就是充当了聚合接口，含有一个iterator() 方法，返回一个迭代器对象
• ArrayList 是实现聚合接口List 的子类，实现了iterator()
• Iterator 接口系统提供
• 迭代器模式解决了 不同集合(ArrayList ,LinkedList) 统一遍历问题

应用场景

• 当集合背后为复杂的数据结构， 且你希望对客户端隐藏其复杂性时 （出于使用便利性或安全性的考虑）， 可以使用迭代器模式。
• 当需要为聚合对象提供多种遍历方式时
• 当需要为遍历不同的聚合结构提供一个统一的接口时
• 遍历不同的甚至是无法预知的数据结构可以使用迭代器模式处理

示例代码

public interface Aggregate {

    Iterator<Object> createIterator();

    void   add(Object o);
    void   remove(Object o);

    void  print();
}
public class ConcreteAggregateA<T>  implements  Aggregate{

    private final T[] elementA;

    private  int index = 0;

    public ConcreteAggregateA(int num) {
        elementA = (T[]) new Object[num];
    }

    @Override
    public Iterator<Object> createIterator() {
        return   new ConcreteIteratorA(elementA);
    }

    @Override
    public void add( Object o) {
        elementA[index++] = (T)o;
    }

    @Override
    public void remove( Object o) {

        int removeIndex = -1;

       for(int j = elementA.length-1;j>=0;j--){

            if (elementA[j] == o) {

                removeIndex = j;
                break;
            }
       }

        if (removeIndex > -1) {
            int currentIndex;
            if ((currentIndex = elementA.length - 1) > removeIndex)
                System.arraycopy(elementA, removeIndex+1, elementA, removeIndex,elementA.length - currentIndex);
             elementA[index = currentIndex] = null;

        }
    }

    public void print() {
        Iterator<Object> iterator = this.createIterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next.toString());
        }
    }

}

public class ConcreteAggregateB implements  Aggregate {

    private final List<Object> aggregateB;

    public  ConcreteAggregateB(){
        aggregateB = new ArrayList<>();
    }


    @Override
    public Iterator<Object> createIterator() {
        return new ConcreteIteratorB(aggregateB);
    }

    @Override
    public void add(Object o) {
        aggregateB.add(o);
    }

    @Override
    public void remove(Object o) {
      aggregateB.remove(o);
    }
    @Override
    public void print() {
        Iterator<Object> iterator = this.createIterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next.toString());
        }
    }
}
public class ConcreteIteratorA implements Iterator<Object> {

    private final Object[] elements;

    int index = 0;

    public ConcreteIteratorA(Object[] elementA) {
        elements = elementA;
    }

    @Override
    public boolean hasNext() {

        return elements != null  && index <= elements.length - 1 && elements[index] != null ;
    }

    @Override
    public Object next() {

        return elements[index++];
    }

    @Override
    public void remove() {
        Iterator.super.remove();
    }
}
public class ConcreteIteratorB implements Iterator<Object> {

    private final List<Object> objectList;

    private  int index = -1;

    public  ConcreteIteratorB(List<Object> aggregateB){
        objectList = aggregateB;
    }

    @Override
    public boolean hasNext() {

        return    index < objectList.size() - 1 ;
    }

    @Override
    public Object next() {

        return objectList.get(++index);
    }

    @Override
    public void remove() {

    }
}
public class IteratorPattern {
    public static void main(String[] args) {

       ConcreteAggregateA<String> concreteAggregateA = new ConcreteAggregateA<String>(5);
       concreteAggregateA.add("kobe");
       concreteAggregateA.add("leo");
       concreteAggregateA.add("bens");
       concreteAggregateA.add("jack");
       concreteAggregateA.add("jim");
        concreteAggregateA.print();

       concreteAggregateA.remove("leo");
        System.out.println("*****************");
        concreteAggregateA.print();
        System.out.println("*****************");
        ConcreteAggregateB concreteAggregateB= new ConcreteAggregateB();

        concreteAggregateB.add(11);
        concreteAggregateB.add(3);
        concreteAggregateB.add(4);
        concreteAggregateB.add(5);

        concreteAggregateB.print();
        System.out.println("*****************");
        concreteAggregateB.remove(11);
        concreteAggregateB.print();
        System.out.println("*****************");
    }
}