java 迭代器模式_【java设计模式】（6）---迭代器模式（案例解析）

设计模式之迭代器模式

一、java迭代器介绍

1、迭代器接口

在jdk中,与迭代器相关的接口有两个:Iterator 与 Iterable。

Iterator:迭代器，Iterator及其子类通常是迭代器本身的结构与方法；迭代器是一种模式，它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离，即我们无需关心该序列的底层结构是什么样子的。只要拿到

这个对象,使用迭代器就可以遍历这个对象的内部。

Iterable:可迭代的，那些想用到迭代器功能的其它类，如AbstractList HashMap等，需要实现该接口。

1)Iterator

Java提供一个专门的迭代器<>Iterator，我们可以对某个序列实现该interface，来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器。

Package java.util;public interface Iterator{//判断是否存在下一个对象元素

booleanhasNext();//获得下一个元素

E next();//移除下一个元素

voidremove();

}

2)Iterable

Java中还提供了一个Iterable接口，Iterable接口实现后的功能是“返回”一个迭代器(Iterator),我们常用的实现了该接口的子接口有: Collection, Deque, List, Queue, Set 等.该接口的iterator()方

法返回一个标准的Iterator实现。

public interface Iterable{

Iteratoriterator();

}

2、迭代器的实现

看完源码,我们来看看迭代器是如何使用的:

1) 若类A想要使用迭代器,则它的类声明部分为 class A implement Iterable

2) 在类A实现中，要实现Iterable接口中的唯一方法：Iterator iterator(); 这个方法用于返回一个迭代器,即Iterator接口及其子类；

3) 在类A中,定义一个内部类S,专门用于实现Iterator接口,定制类A自已的迭代器实现。

如下：

//A实现Iterable接口

classA implement Iterable

{//该接口返回一个Iterator对象

Iteratoriterator() {...}class S implement Iterator{//上面这个对象会有具体实现的方法

booleanhasNext() {....}

E next() {....}voidremove() {....}

}

}

下面我们来看下抽象类AbstractList的jdk源码

public abstract class AbstractList extends AbstractCollection implements List { //List接口实现了Collection, Iterable

protectedAbstractList() {

}

...//这里返回一个迭代器对象

public Iteratoriterator() {return newItr();

}//Itr内部类实现迭代器

private class Itr implements Iterator{int cursor = 0;int lastRet = -1;int expectedModCount =modCount;//实现hasNext方法

public booleanhasNext() {return cursor !=size();

}//实现next方法

publicE next() {//判断是否有下一个

checkForComodification();try{

E next=get(cursor);

lastRet= cursor++;//返回下一个

returnnext;

}catch(IndexOutOfBoundsException e) {

checkForComodification();throw newNoSuchElementException();

}

}//实现remove方法

public voidremove() {if (lastRet == -1)throw newIllegalStateException();

checkForComodification();try{

AbstractList.this.remove(lastRet);if (lastRet

cursor--;

lastRet= -1;

expectedModCount=modCount;

}catch(IndexOutOfBoundsException e) {throw newConcurrentModificationException();

}

}//判断是否有下一个方法

final voidcheckForComodification() {if (modCount !=expectedModCount)throw newConcurrentModificationException();

}

}

}

3、小案例

//实现Iterable

class ScanAppleStore implements Iterable{

ArrayList appleStore = new ArrayList();//为初始appleStore赋值

ScanAppleStore() {

Collections.addAll(appleStore,"Sweet", "Sour", "Bitter", "litter Sweet", "litter Sour", "litter Bitter");

System.out.print(appleStore);

}//重写Iterator方法

@Overridepublic Iteratoriterator() {return new Iterator() {private int i = 0;public booleanhasNext() {if (i

}else{return false;

}

}publicString next() {return appleStore.get(i++);

}public voidremove() {

System.out.print("not defined!");

}

};

}public IterablereverseIterator() {return new Iterable() {public Iteratoriterator() {return new Iterator() {private int i = appleStore.size() - 1;public booleanhasNext() {if (i > -1) {return true;

}else{return false;

}

}publicString next() {return appleStore.get(i--);

}public voidremove() {

System.out.print("not defined!");

}

};

}

}; }}

测试类

public classTestIterable {//构造函数初始化

TestIterable() {

ScanAppleStore appleTree= newScanAppleStore();//采用系统自带的迭代器

System.out.println("采用系统自带的迭代器iterator:");for(String str : appleTree) {

System.out.println(str);

}

System.out.println("======================");

System.out.println("采用自己重新迭代器，让相反输出");//采用自己重新迭代器，让相反输出

for(String str : appleTree.reverseIterator()) {

System.out.println(str);

}

}public static voidmain(String[] args) {

TestIterable a= newTestIterable();

}

}

运行结果：

[Sweet, Sour, Bitter, litter Sweet, litter Sour, litter Bitter]

采用系统自带迭代器iterator:

Sweet

Sour

Bitter

litter Sweet

litter Sour

litter Bitter======================采用自己重新迭代器，让相反输出:

litter Bitter

litter Sour

litter Sweet

Bitter

Sour

Sweet

二、迭代器模式

1、什么是迭代器模式

GOF给出的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。

Iterator模式就是分离了集合对象的遍历行为,抽象出一个迭代器类来负责,这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。

2、迭代器模式角色组成

1) 迭代器角色(Iterator)：迭代器角色负责定义访问和遍历元素的接口。

2) 具体迭代器角色(Concrete Iterator)：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。

3) 容器角色(Container)：容器角色负责提供创建具体迭代器角色的接口。

4) 具体容器角色(Concrete Container)：具体容器角色实现创建具体迭代器角色的接口——这个具体迭代器角色于该容器的结构相关。

3、案例解析

1)迭代器角色

public interfaceIterator {publicObject next();public booleanhasNext();

}

2)具体迭代器角色

public class ConcreteIterator implementsIterator {private List list = newArrayList();private int cursor = 0;publicConcreteIterator(List list) {this.list =list;

}

@OverridepublicObject next() {

Object obj= null;if (this.hasNext()) {

obj= this.list.get(cursor++);

}returnobj;

}

@Overridepublic booleanhasNext() {if (cursor ==list.size()) {return false;

}return true;

}

}

3)容器角色

public interfaceAggregate {public voidadd(Object obj);public voidremove(Object obj);publicIterator iterator();

}

4) 具体容器角色

public class ConcreteAggregate implementsAggregate {private List list = newArrayList();

@Overridepublic voidadd(Object obj) {

list.add(obj);

}

@Overridepublic voidremove(Object obj) {

list.remove(obj);

}

@OverridepublicIterator iterator() {return newConcreteIterator(list);

}

}

测试类

public classClient {public static voidmain(String[] args) {

Aggregate ag= newConcreteAggregate();

ag.add("小明");

ag.add("小红");

ag.add("小刚");

Iterator it=ag.iterator();while(it.hasNext()) {

String str=(String) it.next();

System.out.println(str);

}

}}

运行结果

小明

小红

小刚

4、迭代器优点和缺点

优点：

1)它支持以不同的方式遍历一个聚合对象。

2)迭代器简化了聚合类。

3)在同一个聚合上可以有多个遍历。

4)在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

参考

其实这整篇文章几乎都来自该篇文章，用参考都不太好意思，哈哈。

想太多，做太少，中间的落差就是烦恼。想没有烦恼，要么别想，要么多做。中校【7】