【设计模式】迭代器模式(Iterator)

概述

迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问

适用性

1. 访问一个聚合对象的内容而无需暴露它的内部表示。
2. 支持对聚合对象的多种遍历。
3. 为遍历不同的聚合结构提供一个统一的接口(即,支持多态迭代)。

案例

    public interface Iterator {
        Object next();
        void first();
        void last();
        boolean hasNext();
    }

    public class IteratorImpl implements Iterator {
        private List list;
        private int index;
        public IteratorImpl(List list) {
            index = 0;
            this.list = list;
        }
        public void first() {
            index = 0;
        }
        public void last() {
            index = list.getSize();
        }
        public Object next() {
            Object obj = list.get(index);
            index++;
            return obj;
        }
        public boolean hasNext() {
            return index < list.getSize();
        }
    }

    public interface List {
        Iterator iterator();
        Object get(int index);
        int getSize();
        void add(Object obj);
    }

    public class ListImpl implements List {
		private Object[] list;
		private int index;
		private int size;
		public ListImpl() {
			index = 0;
			size = 0;
			list = new Object[100];
		}
		public Iterator iterator() {
			return new IteratorImpl(this);
		}
		public Object get(int index) {
			return list[index];
		}
		public int getSize() {
			return this.size;
		}
		public void add(Object obj) {
			list[index++] = obj;
			size++;
		}
	}

	public class Test {
		public static void main(String[] args) {
			List list = new ListImpl();
			list.add("a");
			list.add("b");
			list.add("c");
			// 第一种迭代方式
			Iterator it = list.iterator();
			while (it.hasNext()) {
				System.out.println(it.next());
			}		
			System.out.println("=====");
			// 第二种迭代方式
			for (int i = 0; i < list.getSize(); i++) {
				System.out.println(list.get(i));
			}
		}
    }
    
	// result 
	// a
	// b
	// c
	// =====
	// a
	// b
    // c