设计模式---迭代器（Iterator）模式

1. 什么是迭代器模式？

迭代器模式，提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。
迭代器模式的本质是将遍历聚合对象中数据的行为提取出来，封装到一个迭代器中，通过专门的迭代器来遍历聚合对象的内部数据。

2. 迭代器用来做什么？

用于在数据集合中按照顺序遍历集合。

3. 迭代器模式中的角色

• Iterator（迭代器）
  一般是一个接口，负责定义遍历元素的方法。
• ConcreteIterator（具体迭代器）
  负责实现Iterator角色所定义的方法，完成集合的迭代。
• Aggregate（集合）
  一般是一个接口，提供一个iterator()方法，用来创建Iterator。
• ConcreteAggregate（具体集合）
  就是抽象集合Aggregate的具体实现类，它会创建出具体的Iterator，即ConcreteIterator。

4. 示例代码

为了方便理解，写一段代码简单演示一下迭代器模式。这段代码是模拟停车场，主要是将车停进停车场，并将车牌号按顺序显示出来。简单演示功能，请不要过于在意代码的细节。

Iterator接口

/**
 * 对应类图中的Iterator角色
 * 用于遍历集合中的元素，其作用就相当于循环语句中的循环变量。
 * 主要有两个方法：
 * hasNext()判断集合是否存在下一个元素；
 * next()获取下一个元素。
 */
public interface Iterator {

    boolean hasNext();

    Object next();
}

Aggregate接口

/**
 * 对应类图中的Aggregate角色
 * 主要负责创建Iterator
 */
public interface Aggregate {

    Iterator iterator();
}

接口中只声明了一个方法，该方法会生成一个用于遍历集合的迭代器。

Car类

/**
 * 汽车类
 */
public class Car {

    private String no;

    public Car(String no) {
        this.no = no;
    }

    public String getNo() {
        return no;
    }
}

Car类表示汽车的类。作用有限，只是通过getNo方法来获取车牌号。

Park类

**
 * 停车场类
 * 对应类图中的ConcreteAggregate角色。
 */
public class Park implements Aggregate {
    // 汽车数组
    private Car[] cars;
    // 下标
    private int index;

    /**
     * 初始化对象的时候指定数组的最大长度
     *
     * @param maxSize
     */
    public Park(int maxSize) {
        this.cars = new Car[maxSize];
        this.index = 0;
    }

    /**
     * 获取对应位置的Car
     *
     * @param index
     * @return
     */
    public Car getCarAt(int index) {
        return cars[index];
    }

    /**
     * 获取数组长度
     *
     * @return
     */
    public int getSize() {
        return index;
    }

    /**
     * 添加车到停车场中
     *
     * @param car
     */
    public void parkTheCar(Car car) {
        cars[index++] = car;
    }

    @Override
    public Iterator iterator() {
        return new ParkIterator(this);
    }
}

Park类表示停车场类。由于需要将它当做集合来处理，所有实现了Aggregate接口，就相当与类图中的ConcreteAggregate类。
它实现了iterator方法，该方法返回了ParkIterator类的实例。当外部想要遍历这个停车场时，就会调用这个方法。

ParkIterator类

/**
 * 具体的迭代器
 * 相当于类图中的ConcreteIterator
 */
public class ParkIterator implements Iterator {

    // 需要遍历的停车场
    private Park park;

    private int index;

    public ParkIterator(Park park) {
        this.park = park;
        this.index = 0;
    }

    @Override
    public boolean hasNext() {
        return index < park.getSize();
    }

    @Override
    public Object next() {
        Car car = park.getCarAt(index);
        index++;
        return car;
    }
}

Test类

public class Test {

    public static void main(String[] args) {
        Park park = new Park(3);

        park.parkTheCar(new Car("京A11111"));
        park.parkTheCar(new Car("沪A22222"));
        park.parkTheCar(new Car("辽B33333"));

        Iterator it = park.iterator();
        while (it.hasNext()) {
            Car car = (Car) it.next();
            System.out.println(car.getNo());
        }
    }
}

这段代码首先生成了一个能容纳3辆车的停车场，然后按顺序停入3辆车。
通过park.iterator()得到的it就是用于遍历停车场的迭代器。
代码运行的结果如下：