迭代器模式小试
迭代器是行为型设计模式的一种，是一种非常简单的设计模式。
转载请注明出处 http://www.cnblogs.com/zrtqsk/p/3716173.html，谢谢！
一、介绍
先来看一下《研磨设计模式》的定义——提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。
迭代器模式的本质是——控制访问聚合对象中的元素
Java中有的聚合对象主要是Collection类、Map类的各子类对象。同样的，数组也算一种聚合对象。迭代器模式就是希望从外部用同一种方式去访问不同的聚合对象。这个怎么做呢？
说白了，就是创建一个迭代类，持有聚合对象，并且提供迭代这个聚合对象的方法。这个迭代类怎么得到呢？让原本的聚合对象增加一个方法，可以用来返回一个迭代对象，返回时，将自身传递给这个迭代对象。我们得到了这个迭代对象，就可以轻松的在外部访问这个聚合对象了。
二、我的实现
1、假设我们本身有一个包含简单功能的聚合类MyList，如下：
1 public class MyList<T> { 2 3 private Object[] elements; 4 //容量 5 private int capacity = 10; 6 //当前大小 7 private int size = 0; 8 9 //指定容量的构造方法 10 public MyList(int capacity){ 11 this.capacity = capacity; 12 elements = new Object[10]; 13 } 14 15 //默认构造方法 16 public MyList(){ 17 this(10); 18 } 19 20 public int size(){ 21 return size; 22 } 23 24 public T get(int i){ 25 if(i > capacity){ 26 System.out.println("List数组越界"); 27 return null; 28 }else { 29 return (T) elements[i]; 30 } 31 } 32 33 public void add(T obj){ 34 if(size >= capacity){ 35 //扩容 36 }else { 37 elements[size ++] = obj; 38 } 39 } 40 }
2、测试一下：
1 public class Test { 2 3 public static void main(String[] args) 4 { 5 MyList<Apple> list = new MyList<Apple>(); 6 list.add(new Apple("a")); 7 list.add(new Apple("b")); 8 System.out.println(list.get(0)); 9 System.out.println(list.get(1)); 10 System.out.println(list.get(3)); 11 } 12 } 13 14 class Apple{ 15 private String name; 16 17 public Apple(String name){ 18 this.name = name; 19 } 20 21 public String toString(){ 22 return "Apple:" + name; 23 } 24 25 }
3、结果如下：
Apple:a Apple:b List数组越界 null
可见功能正常。
4、我们需要从外部访问这个聚合对象，该怎么做呢？
如前面说的，写一个简单的访问数据的接口，包含简单的迭代聚合对象的功能如下：
1 public interface Iterator<T> { 2 3 public T next(); 4 5 public boolean hasNext(); 6 }
5、简单的实现类；
1 public class IteratorImpl<T> implements Iterator<T> { 2 3 private int index = 0; 4 MyList list = null; 5 public IteratorImpl(MyList list){ 6 this.list = list; 7 } 8 9 @Override 10 public T next() 11 { 12 return (T) list.get(index++); 13 } 14 15 @Override 16 public boolean hasNext() 17 { 18 boolean flag = false; 19 if(list.get(index) != null){ 20 flag = true; 21 } 22 return flag; 23 } 24 }
6、构建一个简单的抽象类AbstractList，而实际上List的大部分方法都可以放到这个抽象类来，这里为了演示方便，如下：
1 public abstract class AbstractList { 2 3 public abstract Iterator iterator(); 4 }
7、刚才的MyList继承这个抽象类，其实现方法如下：
1 @Override 2 public Iterator iterator() 3 { 4 return new IteratorImpl(this); 5 }
非常简单！
8、下面我们就是测试，测试类比之前改变一点点，如下；
1 public class Test { 2 3 public static void main(String[] args) 4 { 5 MyList<Apple> list = new MyList<Apple>(); 6 list.add(new Apple("a")); 7 list.add(new Apple("b")); 8 // System.out.println(list.get(0)); 9 // System.out.println(list.get(1)); 10 // System.out.println(list.get(3)); 11 Iterator it = list.iterator(); 12 while(it.hasNext()){ 13 System.out.println(it.next()); 14 } 15 } 16 }
9，结果如下：
Apple:a
Apple:b
提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。这就是迭代器模式。
三、Java的迭代器
通常而言，我们遍历一个聚合对象除了使用Iterator外，还有一种更简便的方法，那就是用简易的for循环——for(Type t : Collection)。但是当我们用这个方式去访问上文我自定义的聚合对象MyList的时候，发现编译错误。错误提示说，因为我们没有实现java.lang.Iterable接口。 这个接口位于java.lang包下，意味着我们不用额外导包了。我们来看一下这个接口的源代码：
package java.lang; import java.util.Iterator; public interface Iterable<T> { Iterator<T> iterator(); }
可见，这个接口只有一个方法，用来返回一个java.util.Iterator接口对象。相当于我们刚才的抽象类。
Java的迭代器实现主要就是围绕着这两个接口，我们来看一下java.util.Iterator的源代码
package java.util; public interface Iterator<E> { boolean hasNext(); E next(); void remove(); }
可以看到，这个接口是非常简单的。跟上面我自定义的Iterator相比，只是多了一个void remove()方法。
下面我们将上面的例子改为Java的迭代器实现。通常而言，由于一个Iterator的实现类是对应一个聚合对象的。为了提高内聚性，我们应该将Iterator实现类作为聚合对象的内部类。而JDK也是这么做的。如下：
1 import java.util.Iterator; 2 3 //实现Iterable接口 4 public class MyList<T> implements Iterable<T>{ 5 6 private Object[] elements; 7 // 容量 8 private int capacity = 10; 9 // 当前大小 10 private int size = 0; 11 12 // 指定容量的构造方法 13 public MyList(int capacity) 14 { 15 this.capacity = capacity; 16 elements = new Object[10]; 17 } 18 19 // 默认构造方法 20 public MyList() 21 { 22 this(10); 23 } 24 25 public int size() 26 { 27 return size; 28 } 29 30 public T get(int i) 31 { 32 if (i > capacity) 33 { 34 System.out.println("List数组越界"); 35 return null; 36 } 37 else 38 { 39 return (T) elements[i]; 40 } 41 } 42 43 public void add(T obj) 44 { 45 if (size >= capacity) 46 { 47 // 扩容 48 } 49 else 50 { 51 elements[size++] = obj; 52 } 53 } 54 55 //返回java.util.Iterator对象 56 @Override 57 public Iterator iterator() 58 { 59 return new IteratorImpl(this); 60 } 61 62 //内部类 63 class IteratorImpl<T> implements Iterator<T> { 64 65 private int index = 0; 66 MyList list = null; 67 68 public IteratorImpl(MyList list) 69 { 70 this.list = list; 71 } 72 73 @Override 74 public T next() 75 { 76 return (T) list.get(index++); 77 } 78 79 @Override 80 public boolean hasNext() 81 { 82 boolean flag = false; 83 if (list.get(index) != null) 84 { 85 flag = true; 86 } 87 return flag; 88 } 89 90 @Override 91 public void remove() 92 { 93 94 } 95 } 96 }
同时，我们还可以使用简易for循环迭代这个聚合对象，如下：
1 public class Test { 2 3 public static void main(String[] args) 4 { 5 MyList<Apple> list = new MyList<Apple>(); 6 list.add(new Apple("a")); 7 list.add(new Apple("b")); 8 // System.out.println(list.get(0)); 9 // System.out.println(list.get(1)); 10 // System.out.println(list.get(3)); 11 Iterator it = list.iterator(); 12 for(Apple a : list ){ 13 System.out.println(a); 14 } 15 } 16 }
结果与之前没有什么不同。