本文共 10805 字,大约阅读时间需要 36 分钟。
转自:http://blog.csdn.net/acmman/article/details/43920153
在遍历容器元素的时候,有很多初学者在疑惑,为什么返回一个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;
-
-
- 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;
- }
- }
:
- 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;
- 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;
- 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://www.cnblogs.com/ysw-go/p/5384516.html
迭代器模式定义
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中的各种元素,而又不暴露该对象的内部表示。
迭代器模式的角色构成
(1)迭代器角色(Iterator):定义遍历元素所需要的方法,一般来说会有这么三个方法:取得下一个元素的方法next(),判断是否遍历结束的方法hasNext()),移出当前对象的方法remove(),
(2)具体迭代器角色(Concrete Iterator):实现迭代器接口中定义的方法,完成集合的迭代。
(3)容器角色(Aggregate): 一般是一个接口,提供一个iterator()方法,例如java中的Collection接口,List接口,Set接口等
(4)具体容器角色(ConcreteAggregate):就是抽象容器的具体实现类,比如List接口的有序列表实现ArrayList,List接口的链表实现LinkList,Set接口的哈希列表的实现HashSet等。
迭代器模式应用的场景及意义
(1)访问一个聚合对象的内容而无需暴露它的内部表示
(2)支持对聚合对象的多种遍历
1 public interface Iterator {2 3 public boolean hasNext();4 public Object next();5 }
定义具体迭代器角色(Concrete Iterator)
1 package patten.design; 2 3 import patten.design.List;; 4 5 public class ConcreteIterator implements Iterator { 6 private List list = null; 7 private int index; 8 9 public ConcreteIterator(List list) {10 super();11 this.list = list;12 }13 14 @Override15 public boolean hasNext() {16 if (index >= list.getSize()) {17 return false;18 } else {19 return true;20 }21 }22 23 @Override24 public Object next() {25 Object object = list.get(index);26 index++;27 return object;28 }29 30 }
定义容器角色(Aggregate)
1 package patten.design; 2 3 //定义集合可以进行的操作 4 public interface List { 5 6 public void add(Object obj); 7 public Object get(int index); 8 public Iterator iterator(); 9 public int getSize();10 }
定义具体容器角色(ConcreteAggregate)
1 package patten.design; 2 3 public class ConcreteAggregate implements List{ 4 5 private Object[] list; 6 private int size=0; 7 private int index=0; 8 public ConcreteAggregate(){ 9 index=0;10 size=0;11 list=new Object[100];12 }13 @Override14 public void add(Object obj) {15 list[index++]=obj;16 size++;17 }18 19 @Override20 public Iterator iterator() {21 22 return new ConcreteIterator(this);23 }24 @Override25 public Object get(int index) {26 27 return list[index];28 }29 @Override30 public int getSize() {31 32 return size;33 }34 35 }
代码测试
1 package patten.design; 2 3 public class IteratorTest { 4 5 /** 6 * @param args 7 */ 8 public static void main(String[] args) { 9 10 List list=new ConcreteAggregate();11 list.add("a");12 list.add("b");13 list.add("c");14 list.add("d");15 Iterator it=list.iterator();16 while(it.hasNext()){17 System.out.println(it.next());18 }19 }20 21 }
迭代器模式的优缺点:
迭代器模式的优点有:
- 简化了遍历方式,对于对象集合的遍历,还是比较麻烦的,对于数组或者有序列表,我们尚可以通过游标来取得,但用户需要在对集合了解很清楚的前提下,自行遍历对象,但是对于hash表来说,用户遍历起来就比较麻烦了。而引入了迭代器方法后,用户用起来就简单的多了。
- 可以提供多种遍历方式,比如说对有序列表,我们可以根据需要提供正序遍历,倒序遍历两种迭代器,用户用起来只需要得到我们实现好的迭代器,就可以方便的对集合进行遍历了。
- 封装性良好,用户只需要得到迭代器就可以遍历,而对于遍历算法则不用去关心。
迭代器模式的缺点:
- 对于比较简单的遍历(像数组或者有序列表),使用迭代器方式遍历较为繁琐,大家可能都有感觉,像ArrayList,我们宁可愿意使用for循环和get方法来遍历集合。
总的来说: 迭代器模式是与集合共生共死的,一般来说,我们只要实现一个集合,就需要同时提供这个集合的迭代器,就像java中的Collection,List、Set、Map等,这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器,当然也需要引入迭代器模式,给我们的容器实现一个迭代器。