Iterator(迭代器)模式二

   CompositeIterator类的next()方法需要枚举属于某组合对象的每个子对象的节点.我们需要子类来实现iterator(:Set)方法,以便于next()代码可以使用.图2给出了这些类和接口的关系.

 

 

  为更新ProcessComponent类层次结构,以便于枚举,我们需要提供一个iterator()方法:

public ComponentIterator iterator(){
	return iterator(new HashSet());
}

public abstract ComponentIterator iterator(Set visited);

ProcessComponent类是抽象的,需要子类来实现iterator(:Set)方法.对于ProcessComposite类,其相关代码如下:

 

public ComponentIterator iterator(Set visited){
	return new CompositeIterator(this,subprocesses,visited);
}

ProcessStep对iterator()方法的实现如下:

public ComponentIterator iterator(Set visited){
	return new LeafIterator(this,visited);
}

 

突破题:如果让ProcessComponent类层次结构中的类实现iterator()方法以创建适当迭代器类的实例,请问应该使用什么设计模式?

答:  根据前面的描述,我们知道迭代器是Factory Method模式的一个很好的实例.如果用户期望为ProcessComponent类的实例创建一个迭代器,那么必须清楚何时需要创建这个迭代器.而接收类应该知道对哪个类进行实例化.

 

    除了当前对ProcessComponent类层次结构的调整之外,现在我们编写模拟过程组合结构的代码.典型的Oozinoz过程的对象模型如图4所示,如下简短代码枚举了本模型中所有节点:

 

 

package app.iterator.process;

import com.oozinoz.iterator.ComponentIterator;
import com.oozinoz.process.ProcessComponent;
import com.oozinoz.process.ShellProcess;

public class ShowProcessIteration
{
	public static void main(String[] args){
		ProcessComponent pc = ShellProcess.make();
		ComponentIterator iter = pc.iterator();
		while(iter.hasNext())
			System.out.println(iter.next());
	}
}

制作高空焰火弹的流程是一个带有环的组合结构.

该图中的每个叶节点都是ProceeStep类的实例,其余节点是ProcessComposite类的实例

 

运行本程序会得到如下结果:

  Make an aerial shell

  Build inner shell

  Inspect

  Rework inner shell, or complete shell

  Rework

  Disassemble

  Finish:Attach lift, insert fusing,wrap

输出的文本是ShellProcess类分配给每个步骤的名称.请注意在本对象模型中,disassemble步骤之后是make.没有显示出来是因为在第一行输出中已经输出这个步骤一次.

 

3.1 组合枚举器的深度:

  如果每个过程步骤加上在本模型的深度,上述代码的输出会更加容易理解.我们可以把叶枚举器的深度定义为0,组合枚举器的当前深度是子迭代器的深度加1. ComponentIterator超类中getDepth()抽象方法的定义如下:

public abstract int getDepth();

LeafIterator类使用如下代码来实现getDepth()方法:

 

public int getDepth()[
   return 0;
}

CompositeIterator.getDepth()代码实现如下所示:

public int getDepth(){
	if(subiterator != null)
		return subiterator.getDepth() + 1;  //组合枚举器的当前深度是子迭代器的当前深度加1
	return 0;
}

以下代码会产生更加容易理解的输出:

package app.iterator.process;

import com.oozinoz.iterator.ComponentIterator;
import com.oozinoz.process.ProcessComponent;
import com.oozinoz.process.ShellProcess;

public class ShowProcessIteration2
{
	public static void main(String[] args){
		ProcessComponet pc = ShellProcess.make();
		ComponentIterator iter = pc.iterator();
		while(iter.hasNext()){
			for(int i=0;i<4*iter.getDepth();i++)
				System.out.println(' ');
			System.out.println(iter.next());
		}
	}
}

上述程序的输出结果如下所示:

  Make an aerial shell

          Build inner shell

          Inspect

          Rework inner shell, or complete shell

                  Rework

                          Disassemble

                  Finish:Attach lift, insert fusing,wrap    

 

3.2. 枚举叶节点:

   假设我们希望枚举只返回叶节点.在我们只关注叶节点的属性时,这样做是很有价值的.我们可向ComponentIterator类中添加returnInterior字段,以便于记录内部(非叶子)节点是否应该从枚举处理中返回.

 

 

protected boolean returnInterior = true;

public boolean shoudShowInterior(){
	return returnInterior;
}

public void setShowInterior(boolean value){
	returnInterior = value;
}

在CompositeIterator类的nextDescendant()方法中,当为组合节点的子节点创建一个新的枚举机构时,有必要把这个属性传递下去.

protected Object nextDescendant(){
	while(true){
		if(subiterator != null){
			if(subiterator.hasNext())
				return subiterator.next();
		}

		if(!children.hasNext9)) return null;

		ProcessComonent pc = (ProcessComponent)children.next();

		if(!visited.contains(pc)){
			subiterator = pc.iterator(visited);
			subiterator.setShowInterior(shouldShowInterior());
		}
	}
}

  

我们也需要更新CompositeIterator类的next()方法,已有代码包括:

public Object next(){
    if ( peek != null){
        Object result = peek;
        peek = null;
        return  result;
    }

    if(!visited.contains(head)){
        visited.add(head);
    }

    return nextDescendant();
}

 

突破题:请更新CompositeIterator类的next()方法,以便于获取returnInterior字段的值.

答:完整的代码如下所示:

 

public Object next(){
    if ( peek != null){
        Object result = peek;
        peek = null;
        return  result;
    }

    if(!visited.contains(head)){
        visited.add(head);
        if(shouldShowInterior()) return head;
    }

    return nextDescendant();
}

为某种新的集合类型创建一个迭代器或者枚举器是项非常重要的设计任务.带来的处理是自己的集合就像Java类库中的集合类那么容易使用.

 

4.小结:

      Iterator模式的意图在于使得用户可以顺序访问集合内的元素.Java类库中的集合类为集合操作提供丰富的支持,其中也包括了对迭代或者枚举的支持.当创建一个新的集合类型时,我们通常期望能够为它创建一个迭代器.应用领域相关的组合结构是新的集合类型的一个例子.对for循环的扩展会使得代码更加清晰.可以为组合结构设计一个非常通用的迭代器,能够在各种组合结构上使用该迭代器.

      在实例化某迭代器的时候,我们应该考虑在对集合进行迭代处理的同时,集合是否会发生改变.在单线程的应用中,通常不会发生这种可能.而在多线程的应用中,我们必须首先确保对集合的访问是同步的.为保证多线程程序中迭代的安全性,可以通过锁住互斥量对象,实现对集合的同步访问.但是这种方法也有负面效果,在迭代的同时会阻塞其他所有对象对这个集合的访问;同时使用克隆集合的方法也会阻塞对该集合的访问.如果设计巧妙,我们可以为客户提供具有线程安全的迭代器代码.