设计模式之迭代器模式

前言

迭代器模式（Iterator Pattern）提供了一个方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

一.迭代器模式简介

迭代器模式（Iterator Pattern）是Java中常用的设计模式，主要用在遍历整个集合对象。

二.迭代器的实例讲解

案例：火车站列车员需要迭代一群人检票，让有票的人上车，没票的禁入。

1.产品设计UML类图

（图片加载慢，多刷新几下，耐心等待……）

注：具体迭代器类ConcreteIterator和具体聚集类ConcreteIterator是关联关系，ConcreteIterator需要了解ConcreteIterator中内容。

关联关系（association）：当一个类需要“了解”另一个类时使用。

2.迭代器抽象类

设计分析：为遍历不同的聚集结构，提供开始、下一个、是否结束、获取当前项等统一的接口。

package com.pattern.iterator.iterator;

/**
 * 迭代器的抽象类
 * 
 * @author 葫芦娃
 *
 */
public abstract class Iterator {
    public abstract Object first();// 获取开始对象

    public abstract Object next();// 获取下一个对象

    public abstract boolean isDone();// 判断是否完成

    public abstract Object currentItem();// 获取当前对象
}

3.聚集抽象类

*设计分析：该类用于创建迭代器，提供一个抽象的接口，方便子类使用* 。

package com.pattern.iterator.aggregate;

import com.pattern.iterator.iterator.Iterator;

/**
 * 聚集抽象类
 * 
 * @author 葫芦娃
 *
 */
public abstract class Aggregate {
    public abstract Iterator createIterator();
}

4.具体聚集类

*设计分析：创建一个具体的聚合类，该类需要了解ConcreteIterator中的内容，与ConcreteIterator类是关联关系。*

代码如下：

package com.pattern.iterator.aggregate;

import java.util.List;

import com.pattern.iterator.iterator.ConcreteIterator;
import com.pattern.iterator.iterator.Iterator;

/**
 * 具体聚合类
 * @author 葫芦娃
 *
 */
public class ConcreteAggregate extends Aggregate {

    private List<String> items;

    public List<String> getItems() {
        return items;
    }

    public void setItems(List<String> items) {
        this.items = items;
    }

    public ConcreteAggregate(List<String> items) {
        this.items = items;
    }

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(new ConcreteAggregate(items));
    }

    public int count(){
        return items.size();
    }

}

5.具体迭代器类：

*设计分析：创建一个具体的迭代器类，用于对聚集对象迭代* 。

代码如下：

package com.pattern.iterator.iterator;

import com.pattern.iterator.aggregate.ConcreteAggregate;

/**
 * 具体迭代器
 * 
 * @author 葫芦娃
 *
 */
public class ConcreteIterator extends Iterator {

    private int current = 0; // 当前位置索引
    private ConcreteAggregate aggregate; // 创建聚集对象

    public ConcreteIterator(ConcreteAggregate cAggregate) {
        this.aggregate = cAggregate;
    }

    /**
     * 获取第一个对象
     */
    @Override
    public Object first() {
        return aggregate.getItems().get(0);
    }

    /**
     * 获取下一个对象
     */
    @Override
    public Object next() {
        current++;
        if (current < aggregate.getItems().size()) {
            return aggregate.getItems().get(current);
        }
        return null;
    }

    /**
     * 判断是否完成
     */
    @Override
    public boolean isDone() {
        return current >= aggregate.getItems().size() ? true : false;
    }

    /**
     * 获取当前对象
     */
    @Override
    public Object currentItem() {
        return aggregate.getItems().get(current);
    }

}

6.客户端中使用

创建一个数组，模拟一个上车的队伍，用迭代器进行迭代处理。

package com.pattern.iterator.client;


import java.util.Arrays;

import com.pattern.iterator.aggregate.ConcreteAggregate;
import com.pattern.iterator.iterator.ConcreteIterator;
import com.pattern.iterator.iterator.Iterator;

public class Client {
    public static void main(String[] args) {
        String[] array = { "马芸", "马画藤", "李艳红", "雷俊" };
        //创建一个聚集对象，模拟排队的乘客
        ConcreteAggregate cAggregate = new ConcreteAggregate(Arrays.asList(array));
        //创建一个迭代器，模拟售票员开始检票。
        Iterator iterator = new ConcreteIterator(cAggregate);
        //找到队伍的第一个人
        Object item = iterator.first();
        //检票上车
        while (!iterator.isDone()) {
            System.out.println(iterator.currentItem() + "上车");
            iterator.next();
        }
    }
}

7.运行结果展示

马芸上车
马画藤上车
李艳红上车
雷俊上车

8.源码下载

本文示例代码下载地址：点击下载

三.总结：

当需要为聚合对象提供多种遍历方式，或者为遍历不同的聚合对象提供一个统一的接口，或者访问一个聚合对象，不需要暴露它的内部表示的时候，适合使用迭代器模式。

1.迭代器模式的优点

• 支持多种方式遍历一个聚集对象。
• 增加聚合类和迭代器时，无需修改原有代码。
• 可以对同一个聚合对象，存在多个遍历。

2迭代器模式的缺点

• 增加了程序的复杂性，因为增加一个聚合类就要增加一个迭代器。