[原创]设计模型探索H-Iterator parttern 之深藏不露

[原创]设计模型探索H-Iterator parttern 之深藏不露

迭代器模式,又叫游标模式.

提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。
在迭代器模式中，具体迭代器角色和具体容器角色是耦合在一起的 —— 遍历算法是与容器的内部细节紧密相关的。为了使客户程序从与具体迭代器角色耦合的困境中脱离出来，避免具体迭代器角色的更换给客户程序带来的修改，迭代器模式抽象了具体迭代器角色，使得客户程序更具一般性和重用性。这被称为多态迭代
迭代器模式的组成部份
1.集合,一个接口,规定了具体集合需要实现的操作.
2.具体集合,是实现集合接口的实例,具体集合按着一定的结构存储对象,具体集合应当有一个方法返回针对该集合的具体迭代器.
3.迭代器, 一个接口,规定了遍历集合的方法.
4.具体迭代器
迭代器各组成部份之间的关系

例子:
集合:

package  iterator;

public   interface  Aggregate < E >
{
    public Iterator<E> createIterator();
    
    public int length();
    
    public E get(int index);
    
    public void add(E obj);
}

具体集合:

package  iterator;

import  java.util.ArrayList;
import  java.util.List;

public   class  ConcreteAggregate < E >   implements  Aggregate < E >
{
    private List<E> items = new ArrayList<E>();
    
    public Iterator<E> createIterator()
    {
        return new ConcreteIterator<E>(this);
    }
    
    public int length()
    {
        return items.size();
    }
    
    public E get(int index)
    {
        return (E) items.get(index);
    }
    
    public void add(E obj)
    {
        items.add(obj);
    }
    
}

迭代器:

 

package  iterator;

public   interface  Iterator < E >
{
    public E first();
    
    public boolean hasNext();
    
    public E next();
    
    public E current();
}

具体迭代器:

package  iterator;

public   class  ConcreteIterator < E >   implements  Iterator < E >
{
    private Aggregate<E> aggregate;
    
    private int currentIndex = 0;
    
    public ConcreteIterator(Aggregate<E> aggregate)
    {
        this.aggregate = aggregate;
    }
    
    public E first()
    {
        currentIndex = 0;
        if (hasNext())
        {
            return aggregate.get(currentIndex);
        }
        else
        {
            return null;
        }
    }
    
    public boolean hasNext()
    {
        return (currentIndex < aggregate.length());
    }
    
    public E next()
    {
        currentIndex++;
        if (hasNext())
        {
            return aggregate.get(currentIndex);
        }
        else
        {
            return null;
        }
    }
    
    public E current()
    {
        return aggregate.get(currentIndex);
    }
}

测试类:

package  iterator;

public   class  Test
{
    public static void main(String[] args)
    {
        Aggregate<String> a = new ConcreteAggregate<String>();
        a.add("111");
        a.add("222");
        a.add("333");
        
        Iterator<String> it = a.createIterator();
        for (String s = it.first(); it.hasNext(); s = it.next())
        {
            System.out.println(s);
        }
    }
    
}

迭代器的优点:
      1、支持以不同的方式遍历一个容器角色。根据实现方式的不同，效果上会有差别。
      2、简化了容器的接口。但是在java Collection中为了提高可扩展性，容器还是提供了遍历的接口。
      3、对同一个容器对象，可以同时进行多个遍历。因为遍历状态是保存在每一个迭代器对象中的。