1.迭代器模式概念

迭代器模式（Iterator Pattern），提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示，它属于行为型模式。

2.使用场景

遍历一个聚合对象(也可以理解为集合对象，集合是指具有某种特定性质的具体的或抽象的对象汇总成的集体，这些对象称为该集合的元素)。

3.优点和缺点

优点
1、它支持以不同的方式遍历一个聚合对象。
2、迭代器简化了聚合类。
3、在同一个聚合上可以有多个遍历。
4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
缺点
由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

4.例子解析

迭代器模式类图

这是一个关于餐厅菜单的例子：
Iterator:迭代器接口，这个接口定义了访问集合数据的方法,任何对集合的操作都是在这个接口中定义。

public interface Iterator {

    boolean hasNext();
    Object next();
}

ConreteIterator:迭代器的具体类，实现了迭代器接口，这里是具体定义迭代器管理聚合对象的规则。

public class DinerMenuIterator implements Iterator {

    MenuItem[] items;
    int position = 0;
    public DinerMenuIterator(MenuItem[] items) {
        this.items = items;
    }
    @Override
    public boolean hasNext() {
        if (position>=items.length||items[position]==null) {
            return false;
        }else
            return true;
    }

    @Override
    public Object next() {
        MenuItem item = items[position];
        position = position+1;
        return item;
    }
}

Aggregate:聚合对象接口

public interface Menu {

    public Iterator createIterator();
}

ConreteAggregate:聚合对象的具体类

public class DinerMenu  implements Menu{
    static final int MAX_ITEMS = 6;
    int numberOfItems = 0;
    MenuItem[] menuItems;

    public DinerMenu() {
        menuItems = new MenuItem[MAX_ITEMS];
        addItem("1", "1", true, 1);
        addItem("2", "2", false, 2);
        addItem("3", "3", false, 3);
        addItem("4", "4", false, 4);
    }
    
    private void addItem(String name, String description, boolean vegetarian,
            double price) {
            MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
            if (numberOfItems>=MAX_ITEMS) {
                System.out.println("Sorry,Menu is full!");
            }else
            {
                menuItems[numberOfItems] = menuItem;
                numberOfItems = numberOfItems+1;
            }
    }

    public Iterator createIterator() {

        return new DinerMenuIterator(menuItems);
    }
}

Client客户端：

public class Test {

    public static void main(String[] args) {
        PancakeHouseMenu houseMenu = new PancakeHouseMenu();
        DinerMenu dinerMenu = new DinerMenu();
        
        Waitress waitress = new Waitress(houseMenu, dinerMenu);
        waitress.printMenu();
    }

}

5.总结

1.如果我们将对集合的遍历也放到聚合类（也就是产生集合的类）中，那么这个集合类就同时要负担两个责任，分别是产生集合和遍历集合的两个任务，那么一旦集合发生改变或者遍历方法发生改变，我们都必须要修改这个类。这违反了单一责任原则（即一个类应该只有一个引起变化的原因），因为修改代码很容易造成许多潜在的错误。
2.内聚：用来度量一个类或模块紧密的达成单一目的或者责任的程度。
高内聚：当一个类或者模块被设计成只支持一组相关的功能的时候，我们就说它是高内聚。
低内聚:当一个类或者模块被设计成只支持一组不相关的功能的时候，我们就说它是地内聚。
3.java.util.Iterator，提供了集合的实现。与迭代器一起使用的是集合类包括ArrayList,Vetor,LinkedList,Stack和PriorityQueue。这些类都实现了java.util.Collection接口。
4.实现了java.util.Collection接口的集合类，都可以通过iterator()方法获取对应的迭代器，而HashTable并没有实现这个接口，但是他可以间接通过values().iterator()方式获取迭代器。