GOF23设计模式之迭代器模式（iterator）

一、迭代器模式概述

　　提供一种可以遍历聚合对象的方式。又称为：游标（cursor）模式

　　结构：

　　　　（1）聚合对象：存储数据

　　　　（2）迭代器：遍历数据

二、迭代器模式示例代码

　　定义：正向遍历迭代器和逆向遍历迭代器

/**
 * 自定义迭代器接口
 * @author CL
 *
 */
public interface MyIterator {
    /**
     * 如果仍有元素可以迭代，则返回 true
     * @return
     */
    boolean hasNext();
    /**
     * 返回迭代的下一个元素
     * @return
     */
    Object next();
    /**
     * 从迭代器指向的集合中移除迭代器返回的最后一个元素
     */
    void remove();
    
}

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义聚合类
 * @author CL
 *
 */
public class ConcreteAggregate {
    private List<Object> list;

    public ConcreteAggregate() {
        list = new ArrayList<Object>();
    }
    
    public boolean addObject(Object obj) {
        return this.list.add(obj);
    }
    
    public boolean removeObject(Object obj) {
        return this.list.remove(obj);
    }
    
    /**
     * 获得正向遍历的迭代器对象
     * @return
     */
    public MyIterator creatIterator() {
        return new ConcreteIterator(0);
    }
    
    /**
     * 获得逆向遍历的迭代器对象
     * @return
     */
    public MyIterator creatConverseIterator() {
        return new ConcreteIterator(list.size()-1);
    }
    
    /**
     * 自定义迭代器内部类
     * @author CL
     *
     */
    private class ConcreteIterator implements MyIterator {
        
        private int cursor;
        
        private final int firstValue;
        
        public ConcreteIterator(int cursor) {
            this.cursor = cursor;
            this.firstValue = cursor;
        }

        @Override
        public boolean hasNext() {
            if (firstValue == 0) {    //正向遍历
                if (cursor < list.size()) {
                    return true;
                }
            } else if (firstValue == list.size()-1) {    //逆向遍历
                if (cursor >= 0) {
                    return true;
                }
            }
            return false;
        }

        @Override
        public Object next() {
            if (firstValue == 0) {    //正向遍历
                if (cursor < list.size()) {
                    return list.get(cursor++);
                }
            } else if (firstValue == list.size()-1) {    //逆向遍历
                if (cursor >= 0) {
                    return list.get(cursor--);
                }
            }
            return null;
        }

        @Override
        public void remove() {
            list.remove(cursor);
        }
    }
}

　　测试：

/**
 * 测试迭代器对象
 * @author CL
 *
 */
public class Client {

    public static void main(String[] args) {
        ConcreteAggregate ca = new ConcreteAggregate();
        ca.addObject("aa");
        ca.addObject("bb");
        ca.addObject("cc");
        ca.addObject("dd");
        
        System.out.println("正向遍历：");
        MyIterator it = ca.creatIterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        
        System.out.println("逆向遍历：");
        MyIterator it2 = ca.creatConverseIterator();
        while (it2.hasNext()) {
            System.out.println(it2.next());
        }
    }
}

　　控制台输出：

正向遍历：
aa
bb
cc
dd
逆向遍历：
dd
cc
bb
aa

三、迭代器模式常见开发应用场景

　　（1）JDK内置的迭代器（List / Set）

　　　　  List / Set 实现了 Collection 接口，Collection 实现了 Iterator 接口。

　　（2）…………