1、Iterator模式

迭代器（iterator）有時又稱遊標（cursor）是程序設計的軟件設計模式，可在容器（container，例如鏈表或者陣列）上遍訪的接口，設計人員無需關心容器的內容。

Iterator模式 - 一個一個遍歷，我們將學習從含有多個元素的集合中將各個元素逐一取出來的iterator模式。

導學

對於數組我們使用的是下標來進行處理的：

1intarray[]=newint[3];
2for(inti=0;i<array.length;i++){
3System.out.println(array[i]);
4}

對ArrayList的處理

1List<String>list=newArrayList<String>();
 
2for(inti=0;i<list.size();i++){
3Stringstring=list.get(i);
4}

將這裡的i的作用抽象化，通用化後形成的模式，在設計模式中稱為iterator模式。

Iterator模式用於在數據集合按照順序遍歷集合。英語單詞iterate有反復做某件事情的意思，漢語稱為“迭代器”。

2、實例程序

這段程序的作用是將書(Book)放置到書架(BookShelf)中,並將書的名字按照順序顯示出來.

類和接口的意義:

Aggregate:表示集合的接口
Iterator:遍歷集合的接口
BookShelf:表示書架的類
BookShelfIterator:遍歷書架的類
 
Book:表示書的類

2.1 Aggregate接口

packagecn.design.iterator;

/**
*@authorlin
*@version1.0
*@date2020-07-1314:16
*@Description表示集合的接口
*/
publicinterfaceAggregate{
/**
*在Aggregate接口中聲明的方法只有一個一-iterator方法。該方法會生成-一個用於遍歷集合的迭代器。
*想要遍歷集合中的元素時，可以調用iterator方法來生成一一個實現了Iterator接口的類的實例。
*/
publicabstractIteratoriterator();
}

2.2 Iterator接口

packagecn.design.iterator;

/**
*@authorlin
*@version1.0
*@date2020-07-1314:30
*@DescriptionTODO
*/
publicinterfaceIterator{

/**
*判斷是否存在下一-個元素
*當集合中存在下一個元素
*時，該方法返回true;當集合中不存在下一個元素，即已經遍歷至集合末尾時，該方法返回
*false。hasNext方法主要用於循環終止條件。
*
*@return
*/
publicabstractbooleanhasNext();

/**
*取下一個元素
*該方法返回的是集合
*中的一一個元素。但是，next方法的作用並非僅僅如此。為了能夠在下次調用next方法時正確地返
*回下一個元素，該方法中還隱含著將迭代器移動至下一個元素的處理。說“隱含”，是因為
*Iterator接口只知道方法名。想要知道next方法中到底進行了什麼樣的處理，還需要看一下實
*現了Iterator接口的類(BookShelfIterator)。這樣，我們才能看懂next方法的作用。
*
*@returnobject
*/
publicabstractObjectnext();
}

2.3 Book類

packagecn.design.iterator;

/**
*@authorlin
*@version1.0
*@date2020-07-1314:33
*@DescriptionTODO
*/
publicclassBook{
privateStringname;

publicBook(Stringname){
this.name=name;
}

publicBook(){
}

publicvoidsetName(Stringname){
this.name=name;
}

publicStringgetName(){
returnname;
}

@Override
publicStringtoString(){
return"Book{"+
"name='"+name+'\''+
'}';
}
}

2.4 BookShelf類

packagecn.design.iterator;

/**
*@authorlin
*@version1.0
*@date2020-07-1319:00
*@DescriptionTODO
*/
publicclassBookShelfimplementsAggregate{
/**
*這個書架中定義了books字段,它是Book類型的數組。該數組的大小(maxsize)在生成
*BookShelf的實例時就被指定了。之所以將books字段的可見性設置為private,是為了防止.
*外部不小心改變了該字段的值。
*/
privateBook[]books;
privateintlast=0;

publicBookShelf(intmaxSize){
this.books=newBook[maxSize];
}

publicBookgetBookAt(intindex){
returnbooks[index];
}

publicvoidappendBook(Bookbook){
this.books[last]=book;
last++;
}

publicintgetLength(){
returnlast;
}

/**
*BookShelf類對應的Iterator。當外部想要遍歷書架時，就會調用這個方法。
*
*@returnIterator實現類
*/
@Override
publicIteratoriterator(){
returnnewBookShelfIterator(this);
}
}

2.5 BookShelfIterator 類

packagecn.design.iterator;

/**
*@authorlin
*@version1.0
*@date2020-07-1319:03
*@DescriptionTODO
*/
publicclassBookShelfIteratorimplementsIterator{
/**
*bookShelf字段表示BookShelfIterator所要遍歷的書架。
*/
privateBookShelfbookShelf;
/**
*index字段表示迭代器當前所指向的書的下標。
*/
privateintindex;

/**
*@parambookShelf
*/

/**
*構造函數會將接收到的BookShelf的實例保存在bookShelf字段中，並將index初始化為0。
*
*@parambookShelf
*/
publicBookShelfIterator(BookShelfbookShelf){
this.bookShelf=bookShelf;
this.index=0;
}

/**
*hasNext方法是Iterator接口中所聲明的方法。該方法將會判斷書架中還有沒有下一-本書,.
*如果有就返回true,如果沒有就返回false。而要知道書架中有沒有下一本書，可以通過比較
*index和書架中書的總冊數(bookShelf.getLength()的返回值)來判斷。
*
*@return
*/
@Override
publicbooleanhasNext(){
returnindex<bookShelf.getLength();
}

/**
*next方法會返回迭代器當前所指向的書(Book的實例),並讓迭代器指向下一-本書。它也是
*Iterator接口中所聲明的方法。next方法稍微有些復雜，它首先取出book變量作為返回值,
*然後讓index指向後面--本書。
*如果與本章開頭的for語句來對比，這裡的“讓index指向後面一-本書”的處理相當於其中
*的i++,它讓循環變量指向下一個元素。
*
*@return
*/
@Override
publicObjectnext(){
BookbookAt=bookShelf.getBookAt(index);
index++;
returnbookAt;
}
}

2.6 TestMain測試類

packagecn.design.iterator;

importjava.util.AbstractCollection;
importjava.util.ArrayList;
importjava.util.List;

/**
*@authorlin
*@version1.0
*@date2020-07-1319:05
*@DescriptionTODO
*/
publicclassTestMain{

publicstaticvoidmain(String[]args){
BookShelfbookShelf=newBookShelf(4);
bookShelf.appendBook(newBook("環遊世界80天"));
bookShelf.appendBook(newBook("聖經"));
bookShelf.appendBook(newBook("灰姑娘"));
bookShelf.appendBook(newBook("阿拉丁神燈"));
Iteratorit=bookShelf.iterator();
while(it.hasNext()){
Bookbook=(Book)it.next();
System.out.println(book.toString());
}

//ArrayList<String>list=newArrayList<>();
//list.add("aaaa");
//list.add("bbbb");
//list.add("cccc");
//list.add("dddd");
//java.util.Iterator<String>it2=list.iterator();
//while(it2.hasNext()){
//System.out.println("it2.next()="+it2.next());
//}
}
}

運行結果如下:

Book{name='環遊世界80天'}
Book{name='聖經'}
Book{name='灰姑娘'}
Book{name='阿拉丁神燈'}

通過bookShelf. iterator()得到的it是用於遍歷書架的Iterator實例。while部分的條件當然就是it.hasNext()了。只要書架上有書，while 循環就不會停止。然後，程序會通過it.next()一本一本地遍歷書架中的書。

3、Iterator模式中的各個角色

讀完示例程序，讓我們來看看Iterator模式中的登場角色。

1、Iterator (迭代器)

該角色負責定義按順序逐個遍歷元素的接口( API)。在示例程序中，由Iterator接口扮演這個角色，它定義了hasNext和next兩個方法。其中，hasNext 方法用於判斷是否存在下一個元素，next方法則用於獲取該元素。

2、Concretelterator (具體的迭代器)

該角色負責實現Iterator角色所定義的接口( API)。在示例程序中，由BookShelfIterator類扮演這個角色。該角色中包含了遍歷集合所必需的信息。在示例程序中，BookShelf類的實例保存在bookShelf字段中，被指向的書的下標保存在index字段中。

3、Aggregate (集合)

該角色負責定義創建Iterator角色的接口( API)。這個接口( API)是-一個方法，會創建出“按順序訪問保存在我內部元素的人”。在示例程序中，由Aggregate接口扮演這個角色，它裡面定義了iterator 方法。

4、ConcreteAggregate ( 具體的集合)

該角色負責實現Aggregate角色所定義的接口(API)。它會創建出具體的Iterator角色，即Concretelterator角色。在示例程序中，由BookShelf類扮演這個角色，它實現了iterator 方法。

4、擴展思路的要點

4.1、為何iterator必不可少？

while(it.hasNext()){
Bookbook=(Book)it.next();
System.out.println(book.toString());
}

上述只使用了Iterator的hasNext方法和next方法，並沒有調用BookShelf的方法。也就是說，這裡的while循環並不依賴於BookShelf的實現。

如果編寫BookShelf的開發人員決定放棄用數組來管理書本，而是用java.util. vector取而代之，會怎樣呢?不管BookShelf如何變化，只要BookShelf的iterator方法能正確地返回Iterator的實例(也就是說，返回的Iterator類的實例沒有問題，hasNext 和next方法都可以正常工作)，即使不對上面的while循環做任何修改，代碼都可以正常工作。

這對於BookShelf的調用者來說真是太方便了。設計模式的作用就是幫助我們編寫可復用的類。所謂“可復用”，就是指將類實現為“組件”，當一個組件發生改變時，不需要對其他的組件進行修改或是只需要很小的修改即可應對。

這樣也就能理解為什麼在示例程序中iterator方法的返回值不是BookShelfIterator類型而是Iterator類型了(代碼清單1-6)。這表明，這段程序就是要使用Iterator的方法進行編程，而不是BookShelfIterator的方法。

4.2、難以理解的抽象類和接口

難以理解抽象類和接口的人常常使用ConcreteAggregate角色和ConcreteIterator角色編程，而不使用Aggregate接口和Iterator接口，他們總想用具體的類來解決所有的問題。

但是如果只使用具體的類來解決問題，很容易導致類之間的強耦合，這些類也難以作為組件被再次利用。為了弱化類之間的耦合，進而使得類更加容易作為組件被再次利用，我們需要引入抽象類和接口。

4.3、Java中ArrayList源碼

私有的內部類Itr

/**
*AnoptimizedversionofAbstractList.Itr
*/
privateclassItrimplementsIterator<E>{
intcursor;//indexofnextelementtoreturn
intlastRet=-1;//indexoflastelementreturned;-1ifnosuch
intexpectedModCount=modCount;

publicbooleanhasNext(){
returncursor!=size;
}

@SuppressWarnings("unchecked")
publicEnext(){
checkForComodification();
inti=cursor;
if(i>=size)
thrownewNoSuchElementException();
Object[]elementData=ArrayList.this.elementData;
if(i>=elementData.length)
thrownewConcurrentModificationException();
cursor=i+1;
return(E)elementData[lastRet=i];
}

publicvoidremove(){
if(lastRet<0)
thrownewIllegalStateException();
checkForComodification();

try{
ArrayList.this.remove(lastRet);
cursor=lastRet;
lastRet=-1;
expectedModCount=modCount;
}catch(IndexOutOfBoundsExceptionex){
thrownewConcurrentModificationException();
}
}

@Override
@SuppressWarnings("unchecked")
publicvoidforEachRemaining(Consumer<?superE>consumer){
Objects.requireNonNull(consumer);
finalintsize=ArrayList.this.size;
inti=cursor;
if(i>=size){
return;
}
finalObject[]elementData=ArrayList.this.elementData;
if(i>=elementData.length){
thrownewConcurrentModificationException();
}
while(i!=size&&modCount==expectedModCount){
consumer.accept((E)elementData[i++]);
}
//updateonceatendofiterationtoreduceheapwritetraffic
cursor=i;
lastRet=i-1;
checkForComodification();
}

finalvoidcheckForComodification(){
if(modCount!=expectedModCount)
thrownewConcurrentModificationException();
}
}

ArrayList內部：

/**
*Returnsaniteratorovertheelementsinthislistinpropersequence.
*
*<p>Thereturnediteratoris<ahref="#fail-fast"><i>fail-fast</i></a>.
*
*@returnaniteratorovertheelementsinthislistinpropersequence
*/
publicIterator<E>iterator(){
returnnewItr();
}

獲取到Iterator，就可以使用boolean hasNext();和E next();倆個方法進行遍訪操作。

Java源碼：

發哥講上傳到碼雲上：

https://gitee.com/naimaohome/talk_about_fage.git

發哥講

如果你覺得文章還不錯，就請點擊右上角選擇發送給朋友或者轉發到朋友圈~

●掃碼關注公眾號