设计模式之迭代器模式

设计模式之迭代器模式

迭代器模式的简单介绍

谈到迭代器，相信很多人都比较熟悉，尤其是Java语言的使用者，经常使用迭代器来遍历容器，如list、set、map等，这些其实就是迭代器模式的直接应用。所谓的迭代器模式，可以简单地理解为，遍历容器的一种方式，只是这种方式比较特殊，它适用于所有的容器，也就是说，迭代器模式屏蔽了底层访问的细节，而提供统一的访问接口，更加便于适用。

迭代器模式的简单实现

这里，我们通过遍历数组以及List来模拟实现一个简单的迭代器，屏蔽这两者不同的访问方式

/**
 * 通过List实现简单的容器,注意这里List本身已经有iterator了，这里是
 * 为了演示作用而将其再进行封装，并且实现自定义的MyIterator接口
 */
class ListContainer{
    private List<Integer> data;
    private int index;

    public ListContainer() {
        data = new ArrayList<>();
    }

    public void add(int number){
        data.add(number);
    }

    public MyIterator getIterator(){
        index = 0;
        return new MyIterator() {
            @Override
            public boolean hasNext() {
                return index < data.size();
            }

            @Override
            public int next() {
                return data.get(index++);
            }

            @Override
            public int getFirst() {
                return data.get(0);
            }

            @Override
            public int getLast() {
                return data.get(data.size() - 1);
            }
        };
    }
}


/**
 * 通过数组实现简单的容器
 */
class ArrayContainer{

    private static int[] data;
    private int index;
    private int findex;
    public ArrayContainer(int size) {
        data = new int[size];
        index = 0;
    }

    public void add(int number){
        if (index < data.length){
            data[index++] = number;
        }
    }

    public MyIterator getIterator(){
        findex = 0;
        return new MyIterator() {
            @Override
            public boolean hasNext() {
                return findex < index;
            }

            @Override
            public int next() {
                return data[findex++];
            }

            @Override
            public int getFirst() {
                return data[0];
            }

            @Override
            public int getLast() {
                return data[index - 1];
            }
        };
    }
}

//需要注意的是，上面的实现方式是存在bug的，这里仅仅是演示作用，所以没有做过多的校验，检查

//测试类
public class Client {

    public static void main(String[] args) {

        // 测试ArrayContainer
        ArrayContainer arrayContainer = new ArrayContainer(10);
        arrayContainer.add(10);
        arrayContainer.add(20);
        arrayContainer.add(30);
        MyIterator iterator = arrayContainer.getIterator();
        while (iterator.hasNext()){
            System.out.printf("Data : %d\n", iterator.next());
        }
        System.out.printf("first %d\n", iterator.getFirst());
        System.out.printf("last %d\n", iterator.getLast());

        //测试ListContainer
        ListContainer listContainer = new ListContainer();
        listContainer.add(10);
        listContainer.add(20);
        listContainer.add(30);

        MyIterator iterator1 = listContainer.getIterator();
        while (iterator1.hasNext()){
            System.out.printf("data : %d\n", iterator1.next());
        }
        System.out.printf("first %d\n", iterator1.getFirst());
        System.out.printf("last %d\n", iterator1.getLast());
    }
}

从上面的测试类中可以看到，现在如果要变量自定义的这两个实现不同的容器，只需要通过容易的MyIterator接口即可，而不再需要考虑其底层的实现从而采用不同的实现方式

总结

迭代器模式是比较经常见到的一种模式，不过具体需要自己的实现的情况并不常见，主要用于自己实现容器的封装等，并且提供统一的遍历访问接口，从而屏蔽了底层的实现，使得使用者可以不用过多的考虑不同实现所带来的不同的遍历方式，简化了操作。