2. 程式人生 > >【設計模式】Iterator迭代器設計模式(容器和容器的遍歷)

【設計模式】Iterator迭代器設計模式(容器和容器的遍歷)

阿新 • • 發佈：2019-01-09
在遍歷容器元素的時候，有很多初學者在疑惑，為什麼返回一個iterator我就能夠去遍歷這個容器了呢？

今天我們就來深入剖析一下迭代器iterator的設計模式(循序漸進的剖析，一定要耐心看完)

iterator是"四人幫"所定義的23種設計模式之一(不太難，也不是非常重要，只是在遍歷容器的時候能夠用到)

首先需要讀這個總結的同志掌握面向物件的思想。

1.我們先自己寫一個可以動態新增物件的容器
建立一個新的Java工程：Iterator
建立一個包：cn.edu.hpu.iterator
在包下建立類ArrayList：
我們要在容器內首先新增一個add方法，用於向容器內新增元素
再寫一個size方法，用於查詢容器元素個數

ArrayList.java:
package cn.edu.hpu.iterator;

public class ArrayList {
	//我們要用陣列模擬一個可以新增任意大小元素的容器
	//首先我們固定一個數組空間，再新增元素的時候，我們去判斷
	//這個空間是不是滿了，如果滿了再在此基礎上再新增一個固定空間
	//往下依次類推，這樣就有了可以新增任意大小元素的容器
	//當然，容器大小一定不可能超過計算機記憶體的大小
	Object[] objects=new Object[10]; 
	int index=0;//代表objects的下一個空的位置在哪裡
	
	//新增元素方法
	public void add(Object o){
		if(index==objects.length){
			//原來的陣列已滿，要做擴充套件(原長度X2)
			Object[] newObjects=new Object[objects.length*2];
			//把objects內容拷貝到新的陣列newObjects上
			System.arraycopy(objects, 0, newObjects, 0, objects.length);//陣列拷貝函式
			objects=newObjects;//之後把newObjects拷貝給objects陣列
		}
		objects[index]=o;
		index++;
	}
	
	//獲取容器元素個數方法
	public int size(){
		return index;
	}
}

測試:

package cn.edu.hpu.iterator;

import cn.edu.hpu.iterator.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList al=new ArrayList();
		for(int i=0;i<20;i++){
			al.add(new Object());
		}
		System.out.println(al.size());
	}
}
測試結果:20

我們就完成了這樣一個容器，這個容器是用陣列來實現的。容器比陣列好在哪裡呢？使用容器就不需要考慮到陣列的邊界問題了，容器可以動態拓展。想往裡面裝就add就行了，想知道大小直接size就可以了。

2.我們加一個輔助類Cat
Cat.java:
package cn.edu.hpu.iterator;

public class Cat {
	private int id;


	public Cat(int id) {
		super();
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
}

以後新增元素就新增這個就可以了，因為可以通過id值知道添加了哪些資料
如測試:
package cn.edu.hpu.iterator;

import cn.edu.hpu.iterator.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList al=new ArrayList();
		for(int i=0;i<20;i++){
			al.add(new Cat(i));
		}
		System.out.println(al.size());
	}
}


3.OK，現在我膩歪了，不想用ArrayList容器了，我想用其它容器去裝Cat，這個新的容器我們底層不用陣列實現了，我們用連結串列來實現。（需要你先了解資料結構中的連結串列概念）
建立一個新容器類LinkedList,一個節點類Node
LinkedList.java:
package cn.edu.hpu.iterator;

public class LinkedList {
	Node head=null;//頭節點(以後的元素通過next得到)
	Node tail=null;//尾節點
	int size=0;
	public void add(Object o){
		Node n=new Node(o,null);
		if(head==null){
			head=n;
			tail=n;
		}
		tail.setNext(n);
		tail=n;
		size++;
		
	}
	
	public int size(){
		return size;
	}
}


Node.java:
package cn.edu.hpu.iterator;

public class Node {
	private Object data;
	private Node next;
	
	
	public Node(Object data, Node next) {
		super();
		this.data = data;
		this.next = next;
	}
	
	public Object getData() {
		return data;
	}
	
	public void setData(Object data) {
		this.data = data;
	}
	
	public Node getNext() {
		return next;
	}
	
	public void setNext(Node next) {
		this.next = next;
	}
	
}

測試:
package cn.edu.hpu.iterator;

import cn.edu.hpu.iterator.LinkedList;

public class LinkedListTest {
	public static void main(String[] args) {
		LinkedList ll=new LinkedList();
		for(int i=0;i<20;i++){
			ll.add(new Cat(i));
		}
		System.out.println(ll.size());
	}
}
測試結果:20


我們實現了兩個內部原理完全不同的容器，那麼下面我們來看:

4.考慮容器的可替換性
什麼叫做可替換性？考慮我們使用容器的客戶端類，想使這些容器可以任意的替換，其它程式碼不用改變，這就需要我們把所有容器的對外提供的方法統一起來。
解決方案:
我們寫一個統一的介面Collection，定義一些統一的規範，讓所有容器去實現這個介面。
Collection.java:
package cn.edu.hpu.iterator;

public interface Collection {
	void add(Object o);
	int size();
}

ArrayList.java:
package cn.edu.hpu.iterator;

public class ArrayList implements Collection{
	
	Object[] objects=new Object[10]; 
	int index=0;
	public void add(Object o){
		if(index==objects.length){
			
			Object[] newObjects=new Object[objects.length*2];
			
			System.arraycopy(objects, 0, newObjects, 0, objects.length);
			objects=newObjects;
		}
		objects[index]=o;
		index++;
	}
	
	public int size(){
		return index;
	}
}

LinkedList.java:
package cn.edu.hpu.iterator;

public class LinkedList implements Collection{
	Node head=null;
	Node tail=null;
	int size=0;
	public void add(Object o){
		Node n=new Node(o,null);
		if(head==null){
			head=n;
			tail=n;
		}
		tail.setNext(n);
		tail=n;
		size++;
		
	}
	
	public int size(){
		return size;
	}
}

這樣我們就用Collection介面來實現對不同容器對外方法的統一。
在我們測試的時候就可以使用這種方式來實現容器:
Collection c=new ArrayList();
我對ArrayList不滿意，就可以改成
Collection c=new LinkedList();

小結：針對介面程式設計就不需要考慮具體的實現類是什麼，所以你的程式會更加靈活，要替換其它實現的時候，只需換一個位置(當然如果你寫在配置檔案上，你連程式碼都不用改)。

5.接下來重點來了，我們的容器需要一個非常非常重要的功能-------遍歷
我想遍歷容器中的所有元素，如何去做？
當然可以這樣來寫:
package cn.edu.hpu.iterator;

import cn.edu.hpu.iterator.ArrayList;
import cn.edu.hpu.iterator.Collection;

public class ArrayListTest {
	public static void main(String[] args) {
		Collection c=new ArrayList();
		for(int i=0;i<20;i++){
			c.add(new Cat(i));
		}
		System.out.println(c.size());
		
		ArrayList al=(ArrayList)c;
		for(int i=0;i<al.index;i++){
			Cat cat=(Cat)al.objects[i];
			System.out.print(cat.getId()+" ");
		}
	}
}
結果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 

但是，當我們將Collection的實現改為LinkedList的時候下面的遍歷方法就不行了。
這個時候就需要一種統一的遍歷方式。

每一種容器都應該有它自己的一種遍歷方式，我們要想方設法的給他們統一起來，但是每種容器的遍歷器的實現又不一樣，所以統一遍歷方式只能用一種共同的實現方式，介面或抽象類的方式。

所以我們這麼寫：
定義一個介面Iterator：
package cn.edu.hpu.iterator;

public interface Iterator {
	Object next();
	boolean hasNext();
}

其中有兩個未實現的方法:next和hasNext。
我要求任何一個容器都必須給我一個實現了這個介面的類的物件，
具體的實現交給具體的容器自己去實現。實現完了之後，我肯定知道，
這個物件就實現這兩個方法了，有了這兩個方法，我就可以實現對這
個容器的遍歷了。

我們在Collection中加入返回Iterator的未實現方法
package cn.edu.hpu.iterator;

public interface Collection {
	void add(Object o);
	int size();
	Iterator iterator();
}

ArrayList實現了iterator()這個方法
public Iterator iterator(){
		return null;
	}

測試:
package cn.edu.hpu.iterator;

import cn.edu.hpu.iterator.ArrayList;
import cn.edu.hpu.iterator.Collection;
import cn.edu.hpu.iterator.Iterator;

public class ArrayListTest {
	public static void main(String[] args) {
		Collection c=new ArrayList();
		for(int i=0;i<20;i++){
			c.add(new Cat(i));
		}
		System.out.println(c.size());
		
		/*之前的方法
                ArrayList al=(ArrayList)c;
		for(int i=0;i<al.index;i++){
			Cat cat=(Cat)al.objects[i];
			System.out.print(cat.getId()+" ");
		}*/

                //使用統一遍歷器的遍歷方法
                ArrayList al=(ArrayList)c;
		Iterator it=c.iterator();
		while(it.hasNext()){
			Object o=it.next();
			Cat cat=(Cat)o;
			System.out.print(cat.getId()+" ");
		}
	}
}
這樣我們怎麼改變Collection的實現類，都不影響遍歷方式。

6.當然我沒還沒有寫Iterator的實現，我們來寫實現：
我們在ArrayList中寫一個內部類ArrayListIterator，實現Iterator介面：
package cn.edu.hpu.iterator;

public class ArrayList implements Collection{

	Object[] objects=new Object[10]; 
	int index=0;
	
	public void add(Object o){
		if(index==objects.length){
			
			Object[] newObjects=new Object[objects.length*2];
	
			System.arraycopy(objects, 0, newObjects, 0, objects.length);
			objects=newObjects;
		}
		objects[index]=o;
		index++;
	}
	
	public int size(){
		return index;
	}
	
	public Iterator iterator(){
		return new ArrayListIterator();
	}
	
	private class ArrayListIterator implements Iterator{


		private int currentIndex=0;
		
		@Override
		public boolean hasNext() {
			if(currentIndex>index) return false;
			else return true;
		}

		@Override
		public Object next() {
			Object o=objects[currentIndex];
			currentIndex++;
			return o;
		}
		
	}
}

測試:
package cn.edu.hpu.iterator;

import cn.edu.hpu.iterator.ArrayList;
import cn.edu.hpu.iterator.Collection;
import cn.edu.hpu.iterator.Iterator;


public class ArrayListTest {
	public static void main(String[] args) {
		Collection c=new ArrayList();
		for(int i=0;i<20;i++){
			c.add(new Cat(i));
		}
		System.out.println(c.size());


                //使用統一遍歷器的遍歷方法
		ArrayList al=(ArrayList)c;
		Iterator it=c.iterator();
		while(it.hasNext()){
			Object o=it.next();
			Cat cat=(Cat)o;
			System.out.print(cat.getId()+" ");
		}
	}
}
測試結果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 

在我們的JavaAPI中的ArrayList也實現了Java的Collection介面，同樣提供了一個方法，
叫iterator()，這個方法返回了一個實現了Iterator介面的物件。

現在大家明白iterator()方法到底是幹什麼用的，它返回的介面又是什麼意思了吧？

作業:
這個LinkedList也需要寫一個iterator方法，返回一個實現了Iterator的物件。該如何寫？

這是我自己寫的:

感謝馬士兵老師的"設計模式"視訊提供的幫助

相關推薦

【設計模式】Iterator迭代器設計模式(容器和容器的遍歷)

在遍歷容器元素的時候，有很多初學者在疑惑，為什麼返回一個iterator我就能夠去遍歷這個容器了呢？ 今天我們就來深入剖析一下迭代器iterator的設計模式(循序漸進的剖析，一定要耐心看完) iterator是"四人幫"所定義的23種設計模式之一(不太難，也不是非常重要，

設計模式之Iterator(迭代器)的設計和使用

目的： 提供一種方法順序訪問或者遍歷一個聚合物件中的各個元素，且不希望暴露該物件的內部結構。 一、設計 1. 因為是聚合物件，所以設計的這個類應該使用類似list這樣的結構體儲存聚合物件； 2.迭代器應該是通用的，適用於各種型別的聚合物件，所以設計的類應該是模板型別； 3.

Iterator(迭代器)設計模式

宣告：本博文篇幅短，適合review。 一、概念        提供一種方法訪問一個容器物件中的各個元素，而又不暴露該物件的內部細節。 二、模式結構圖 三、例子 template<class Item> class Iterator { public:

Java中Iterator迭代器設計原理

         我們知道迭代器(Iterator)是一種物件，它能夠用來遍歷標準模板庫容器中的部分或全部元素。那麼Iterator迭代器的設計原理是什麼呢？迭代器問什麼定義了一個藉口，而不是一個類呢

【重溫基礎】13.迭代器和生成器

本文是 重溫基礎 系列文章的第十三篇。 今日感受：每次自我年終總結，都會有各種情緒和收穫。 系列目錄： 【複習資料】ES6/ES7/ES8/ES9資料整理(個人整理) 【重溫基礎】1.語法和資料型別 【重溫基礎】2.流程控制和錯誤處理 【重溫基礎】3.迴圈和

Java設計模式(十)：迭代器設計模式

1.應用場景 (1)訪問一個聚合物件的內容而無需暴露它的內部表示 (2)支援對聚合物件的多種遍歷 (3)為遍歷不同的聚合結構提供一個統一的介面 2.概念 提供一種順序訪問聚合物件元素的方法，並且不暴露聚合物件的內部表示。這個模式給使用者提供了一種方法，可以順序訪問一個聚集

python迭代器&生成器使用技巧(1)：遍歷、代理、生成器建立迭代、反向迭代

1. 手動遍歷迭代器 next() 遍歷一個可迭代物件中的所有元素，但是卻不想使用for迴圈。為了手動的遍歷可迭代物件，使用 next() 函式並在程式碼中捕獲 StopIteration 異常。 通常來講， StopIteration 用來指示迭代的結尾。 然而，如果手動

迭代器迭代元素，迭代器修改元素；集合集合遍歷元素集合修改元素解決併發修改異常

import java.util.ArrayList;import java.util.List;import java.util.ListIterator;public class TextDemo1

路一步步走>> 設計模式十六：Iterator-迭代器

package com.test.DPs.XingWei.Iterator; /** * 行為型：Iterator-迭代器 外觀：作用面為 物件 * * 用途：提供一種方法順序訪問一個聚合物件中各個元素，而又不需要暴露該物件的內部表示。 * 理解：一是需要遍歷的物件，即聚集物件，

Iterator使用與迭代器設計模式

Iterator使用 迭代器（Iterator）對應與迭代器設計模式。 Iterator提供三個方法： hasNext() 判斷是否還有下一個元素 next() 獲取下一個元素 remove() 刪除元素 forEachRemaining() jdk1.8以後新增的方法，可以在動

迭代器設計模式Iterator

背景：如果一個檔案在不斷的增量增加資料，如果需要增量的讀取這個檔案，則可以使用迭代器設計模式對增量的資料進行迭代遍歷。 例如：一篇文件aa.txt aaa aaa aaa aaa 則可以把這片文章分為 片段（檔案，開始，結束），段落（檔案，開始，結束） 檔案的中新增的資料需

Iterator Pattern--迭代器設計模式

1. What is? 關於迭代器設計模式 下面的解釋如果看不下去可以看這個連結，以及這個。 設計意圖： 1). 提供一種順序訪問一組物件而不用暴露其潛在實現的機制。 2). C++和java標

集合框架、單列集合體系、Collection、Iterator迭代器、泛型、上限&下限【學習筆記】

一、單列集合 1.單列集合體系 Collection List Set ArrayList

設計模式學習筆記(十三)—Iterator迭代器模式

轉貼自 http://www.blogjava.net/flustar/archive/2007/12/04/iterator.htmlIterator模式定義: 提供一個方法順序訪問一個聚合物件的各個元素，而又不暴露該物件的內部表示。 這個模式在java的類庫中已經實現了，

Go語言設計模式實踐：迭代器（Iterator）

關於本系列 決定開個新坑。 這個系列首先是關於Go語言實踐的。在專案中實際使用Go語言也有段時間了，一個體會就是不論是官方文件、圖書還是網路資料，關於Go語言慣用法（idiom）的介紹都比較少，基本只能靠看標準庫原始碼自己琢磨，所以我特別想在這方面有一些收集和總結。 然後這個系列也是關於設計模式的。雖然G

JS-Javascript 迭代器設計模式 Iterator pattern

這篇博文簡短的提一下Iterator的設計模式，以及這種設計模式給我們帶來什麼樣的好處。 1.begin 為了體現面向物件的特性（近年來的ES6為這方面做了很大的努力），此篇博文的語言編寫基於typescript，當然也會附上原生js的書寫方式。 1.1迭

設計模式系列之迭代器模式(Iterator Pattern)——遍歷聚合物件中的元素

模式概述 模式定義 模式結構圖 模式虛擬碼 模式改進 模式應用 模式在JDK中的應用 模式在開源專案中的應用 模式總結 說明：設計模式系列文章是讀劉偉所著《設計模式的藝術之道(軟體開發人員內功修煉之道)》一書的閱讀筆記。個人感覺這本書講的不錯，有興趣推薦讀一讀。詳細內容也可以看看此書作者的部

設計模式之九 迭代器與組合模式

迭代器與組合模式 定義  迭代器模式提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部的表示。 組合模式允許你將物件組合成樹形結構來表現“整體/部分”層次結構。組合能讓客戶以一致的方式處理個別對象以及物件組合 例子  廢話不多說，先看具體案例

設計模式篇之迭代器模式

迭代器模式（Iterator Pattern）是 Java 和 .Net 程式設計環境中非常常用的設計模式。這種模式用於順序訪問集合物件的元素，不需要知道集合物件的底層表示。 迭代器模式屬於行為型模式

[LeetCode] Design Compressed String Iterator 設計壓縮字串的迭代器

Design and implement a data structure for a compressed string iterator. It should support the following operations: next and hasNext. The given compress