3. 行为型模式 (4) 迭代子模式

3. 行为型模式 (4) 迭代器模式

迭代器模式（Iterator Pattern）用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

优点：
1. 它支持以不同的方式遍历一个聚合对象。
2. 迭代器简化了聚合类。
3. 在同一个聚合上可以有多个遍历。
4. 在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：
1. 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

1. 迭代器模式

package com.andrew.pattern0304.iterator.model01;
public interface Iterator {
    public boolean hasNext();
    public Object next();
}

package com.andrew.pattern0304.iterator.model01;
public interface Container {
    public Iterator getIterator();
}

package com.andrew.pattern0304.iterator.model01;
public class NameRepository implements Container {
    public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};
    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }
    private class NameIterator implements Iterator {
        int index;
        @Override
        public boolean hasNext() {
            if (index < names.length) {
                return true;
            }
            return false;
        }
        @Override
        public Object next() {
            if (this.hasNext()) {
                return names[index++];
            }
            return null;
        }
    }
}

package com.andrew.pattern0304.iterator.model01;
/**
 * 1. 迭代器模式
 * 
 * @author andrew
 * @date 2018/08/01
 */
public class Client {
    public static void main(String[] args) {
        NameRepository namesRepository = new NameRepository();
        for (Iterator iter = namesRepository.getIterator(); iter.hasNext();) {
            String name = (String)iter.next();
            System.out.println("Name : " + name);
        }
    }
}
运行结果：
Name : Robert
Name : John
Name : Julie
Name : Lora

角色：
1. 抽象迭代子(Iterator)角色：此抽象角色定义出遍历元素所需的接口。
2. 具体迭代子(ConcreteIterator)角色：此角色实现了Iterator接口，并保持迭代过程中的游标位置。
3. 聚集(Aggregate)角色：此抽象角色给出创建迭代子(Iterator)对象的接口。
4. 具体聚集(ConcreteAggregate)角色：实现了创建迭代子(Iterator)对象的接口，返回一个合适的具体迭代子实例。
5. 客户端(Client)角色：持有对聚集及其迭代子对象的引用，调用迭代子对象的迭代接口，也有可能通过迭代子操作聚集元素的增加和删除。

2. 迭代子模式

package com.andrew.pattern0304.iterator.model02;
public abstract class Aggregate {
    public abstract Iterator createIterator();
}

package com.andrew.pattern0304.iterator.model02;
public class ConcreteAggregate extends Aggregate {
    private Object[] objArray = null;
    public ConcreteAggregate(Object[] objArray) {
        this.objArray = objArray;
    }
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
    public Object getElement(int index) {
        if (index < objArray.length) {
            return objArray[index];
        } else {
            return null;
        }
    }
    public int size() {
        return objArray.length;
    }
}

package com.andrew.pattern0304.iterator.model02;
public interface Iterator {
    public void first();
    public void next();
    public boolean isDone();
    public Object currentItem();
}

package com.andrew.pattern0304.iterator.model02;
public class ConcreteIterator implements Iterator {
    private ConcreteAggregate agg;
    private int index = 0;
    private int size = 0;
    public ConcreteIterator(ConcreteAggregate agg) {
        this.agg = agg;
        this.size = agg.size();
        index = 0;
    }
    @Override
    public void first() {
        index = 0;
    }
    @Override
    public void next() {
        if (index < size) {
            index ++;
        }
    }
    @Override
    public boolean isDone() {
        return (index >= size);
    }
    @Override
    public Object currentItem() {
        return agg.getElement(index);
    }
}

package com.andrew.pattern0304.iterator.model02;
/**
 * 2. 迭代器模式
 * 
 * @author andrew
 * @date 2018/08/01
 */
public class Client {
    public void operation() {
        Object[] objArray = {"One","Two","Three","Four","Five","Six"};
        Aggregate agg = new ConcreteAggregate(objArray);
        Iterator it = agg.createIterator();
        while (!it.isDone()) {
            System.out.println(it.currentItem());
            it.next();
        }
    }
    public static void main(String[] args) {
        Client client = new Client();
        client.operation();
    }
}
运行结果：
One
Two
Three
Four
Five
Six

3. 迭代子模式

package com.andrew.pattern0304.iterator.model03;
public abstract class Aggregate {
    public abstract Iterator createIterator();
}

package com.andrew.pattern0304.iterator.model03;
public interface Iterator {
    public void first();
    public void next();
    public boolean isDone();
    public Object currentItem();
}

package com.andrew.pattern0304.iterator.model03;
public class ConcreteAggregate extends Aggregate {
    private Object[] objArray = null;
    public ConcreteAggregate(Object[] objArray) {
        this.objArray = objArray;
    }
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator();
    }
    private class ConcreteIterator implements Iterator {
        private int index = 0;
        private int size = 0;
        public ConcreteIterator() {
            this.size = objArray.length;
            index = 0;
        }
        @Override
        public void first() {
            index = 0;
        }
        @Override
        public void next() {
            if (index < size) {
                index ++;
            }
        }
        @Override
        public boolean isDone() {
            return (index >= size);
        }
        @Override
        public Object currentItem() {
            return objArray[index];
        }
    }
}

package com.andrew.pattern0304.iterator.model03;
/**
 * 3. 迭代器模式
 * 
 * @author andrew
 * @date 2018/08/01
 */
public class Client {
    public void operation() {
        Object[] objArray = {"One","Two","Three","Four","Five","Six"};
        Aggregate agg = new ConcreteAggregate(objArray);
        Iterator it = agg.createIterator();
        while (!it.isDone()) {
            System.out.println(it.currentItem());
            it.next();
        }
    }
    public static void main(String[] args) {
        Client client = new Client();
        client.operation();
    }
}
运行结果：
One
Two
Three
Four
Five
Six