迭代器模式

定义

它提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节

代码

迭代器接口

1
2
3
4
5
public interface MyIterator {
    Object next();
    boolean hasNext();
    boolean remove();
}

迭代器实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class ConcreteIterator implements MyIterator {

    private Vector vector = new Vector();
    private int cursor = 0;

    public ConcreteIterator(Vector vector) {
        this.vector = vector;
    }

    @Override
    public Object next() {
        Object object ;
        if (this.hasNext()) {
            object = this.vector.get(cursor++);
        } else {
            object = null;
        }
        return object;
    }

    @Override
    public boolean hasNext() {
        if (this.cursor == this.vector.size()) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public boolean remove() {
        this.vector.remove(this.cursor);
        return true;
    }
}

需要迭代的接口

1
2
3
4
public interface Aggregate {
    void add(Object object);
    MyIterator myIterator();
}

需要迭代的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ConcreteAggregate implements Aggregate {

    private Vector vector = new Vector();

    @Override
    public void add(Object object) {
        this.vector.add(object);
    }


    @Override
    public MyIterator myIterator() {
        return new ConcreteIterator(this.vector);
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ConcreteAggregateTest {

    @Test
    public void testIterator(){
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("11");
        aggregate.add("22");
        aggregate.add("33");
        aggregate.add("44");
        MyIterator iterator = aggregate.myIterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

}