迭代器模式

定义

提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示

结构

• Iterator 迭代器接口

  迭代器接口负责定义、访问和遍历元素的接口

• Concrete Iterator 具体迭代器类

实现迭代器接口，并且记录遍历的当前位置

• Aggregate 容器接口

提供创建具体迭代器角色的接口

• Concrete Aggregate 具体容器类

具体迭代器角色与该容器关联

• Client 客户类

简单实现

public interface Television {

    TVIterator createIterator();
}

抽象聚合类

public interface TVIterator {

    void setChannel(int i);

    void next();

    void previous();

    boolean isLast();

    boolean isFirst();

    Object currentChannel();

}

抽象迭代器类

public class SkyworthTelevision implements Television {
    private Object[] objects = {"CCTV-1", "CCTV-2", "CCTV-3", "CCTV-4", "CCTV-5", "CCTV-6", "CCTV-7"};

    @Override
    public TVIterator createIterator() {
        return new SkyworthIterator();
    }


    private class SkyworthIterator implements TVIterator {

        private int currentIndex = 0;

        @Override
        public void setChannel(int i) {
            currentIndex = i;
        }

        @Override
        public void next() {
            if (currentIndex < objects.length) {
                currentIndex++;
            }
        }

        @Override
        public void previous() {
            if (currentIndex > 0) {
                currentIndex--;
            }
        }

        @Override
        public boolean isLast() {
            return currentIndex == objects.length;
        }

        @Override
        public boolean isFirst() {
            return currentIndex == 0;
        }

        @Override
        public Object currentChannel() {
            return objects[currentIndex];
        }
    }
}

创维电视机

public class TclTelevision implements Television {
    @Override
    public TVIterator createIterator() {
        return new TCLIterator();
    }

    private class TCLIterator implements TVIterator {

        private Object[] objects = {"湖南卫视", "北京卫视", "浙江卫视", "上海卫视", "江苏卫视", "安徽卫视", "湖北卫视"};


        private int currentIndex = 0;


        boolean isFirst = true;
        boolean isLast = true;
        

        @Override
        public void setChannel(int i) {
            currentIndex = i;
        }

        @Override
        public void next() {
            if (currentIndex < objects.length) {
                currentIndex++;
            }
        }

        @Override
        public void previous() {
            if (currentIndex > 0) {
                currentIndex--;
            }
        }

        @Override
        public boolean isLast() {
            if (currentIndex == objects.length) {
                if (isLast) {
                    currentIndex = 0;
                    isLast = false;
                    return false;
                }
                return true;
            }
            return false;
        }

        @Override
        public boolean isFirst() {
            if (currentIndex == 0) {
                if (isFirst) {
                    currentIndex = objects.length-1;
                    isFirst = false;
                    return false;
                }
                return true;
            }
            return false;
        }

        @Override
        public Object currentChannel() {
            return objects[currentIndex];
        }
    }

}

Tcl电视机 可以循环一次

public class Test {

    public static void main(String[] args) {

        Television tv = new SkyworthTelevision();

        TVIterator iterator = tv.createIterator();
        display(iterator);
        iterator.setChannel(5);
        reverseDisplay(iterator);

        System.out.println("\n-------------------\n");
        
        Television tv2 = new TclTelevision();
        TVIterator iterator2 = tv2.createIterator();
        display(iterator2);
        iterator2.setChannel(5);
        reverseDisplay(iterator2);
    }


    private static void display(TVIterator iterator) {
        System.out.println("电视机频道");
        while (!iterator.isLast()) {
            System.out.println(iterator.currentChannel().toString());
            iterator.next();
        }
    }


    private static void reverseDisplay(TVIterator iterator) {

        System.out.println("逆向遍历电视机频道");
        while (!iterator.isFirst()) {
            System.out.println(iterator.currentChannel().toString());
            iterator.previous();
        }
    }

}

电视机频道
CCTV-1
CCTV-2
CCTV-3
CCTV-4
CCTV-5
CCTV-6
CCTV-7
逆向遍历电视机频道
CCTV-6
CCTV-5
CCTV-4
CCTV-3
CCTV-2

-------------------

电视机频道
湖南卫视
北京卫视
浙江卫视
上海卫视
江苏卫视
安徽卫视
湖北卫视
湖南卫视
北京卫视
浙江卫视
上海卫视
江苏卫视
安徽卫视
湖北卫视
逆向遍历电视机频道
安徽卫视
江苏卫视
上海卫视
浙江卫视
北京卫视
湖北卫视
安徽卫视
江苏卫视
上海卫视
浙江卫视
北京卫视

小结

迭代器最大的优势是能够为聚合对象提供多种遍历方式，并且提供了一个统一的接口。将集合对象的访问与内部数据的存储分离，使得访问聚合对象时无需了解其内部细节

迭代器这个模式对开发者来说基本不会自己去实现一个迭代器，JDK提供的集合已经实现了各种迭代器方法

ArrayList的for循环遍历与forEach实现差异了解一下