【设计模式】Iterator迭代器设计模式(容器和容器的遍历)

光仔December

1879人浏览 · 2015-02-24 00:13:27

光仔December · 2015-02-24 00:13:27 发布

在遍历容器元素的时候，有很多初学者在疑惑，为什么返回一个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的对象。该如何写？

这是我自己写的: http://blog.csdn.net/acmman/article/details/43924261

感谢马士兵老师的"设计模式"视频提供的帮助
转载请注明出处:http://blog.csdn.net/acmman/article/details/43920153

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...