迭代器模式的定义：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。
从定义中可以看出，迭代器模式是为了在不暴露该对象内部表示的情况下，提供一种顺序访问聚合对象中元素的方法。这种思想在JAVA集合框架中已经体现的淋漓尽致，而且LZ相信每一个接触JAVA的同学都难免要去触碰。
对于ArrayList、LinkedList和HashSet这三种经典集合的遍历，我们先用通用的toArray来试一下。
package com.iterator;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for (int i = 1; i <= 11; i++) {
arrayList.add(i);
}
System.out.println("arrayList size:" + arrayList.size());
Object[] arrayListArray = arrayList.toArray();
for (int i = 0; i < arrayListArray.length; i++) {
System.out.println(arrayListArray[i]);
}
System.out.println("----------------------------------------------");
HashSet<Integer> hashSet = new HashSet<Integer>();
for (int i = 1; i <= 11; i++) {
hashSet.add(i);
}
System.out.println("hashSet size:" + hashSet.size());
Object[] setArray = hashSet.toArray();
for (int i = 0; i < setArray.length; i++) {
System.out.println(setArray[i]);
}
System.out.println("----------------------------------------------");
LinkedList<Integer> linkedList = new LinkedList<Integer>();
for (int i = 1; i <= 11; i++) {
linkedList.add(i);
}
System.out.println("linkedList size:" + linkedList.size());
Object[] linkedListArray = linkedList.toArray();
for (int i = 0; i < linkedListArray.length; i++) {
System.out.println(linkedListArray[i]);
}
}
}
那么这三个类的toArray方法各自是怎么实现的呢？
ArrayList：
package com.iterator;
public class ArrayList<E> {
private static final int INCREMENT = 10;
private E[] array = (E[]) new Object[10];
private int size;
public Object[] toArray(){
Object[] copy = new Object[size];
System.arraycopy(array, 0, copy, 0, size);
return copy;
}
public int size(){
return size;
}
}
LinkedList
package com.iterator;
public class LinkedList<E> {
private Entry<E> header = new Entry<E>(null, null, null);
private int size;
public int size(){
return size;
}
public Object[] toArray(){
Object[] result = new Object[size];
int i = size - 1;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i--] = e.value;
return result;
}
}
HashSet
package com.iterator;
import java.util.HashMap;
import java.util.Map;
public class HashSet<E> {
private static final Object NULL = new Object();
private Map<E, Object> map = new HashMap<E, Object>();
public int size(){
return map.size();
}
public Object[] toArray(){
return map.keySet().toArray();
}
}
但是在这里有一个很大的弊端，不知道各位注意到没有，那就是不论我们的集合类是如何实现的（比如链表，数组，散列），在使用数组遍历集合类的时候，我们其实遍历了两次。
为何会是这种情况呢？
很简单，因为我们的集合类本身就不是一个数组，所以自然要多一步从集合类到数组的过渡。哪怕是本身由数组实现的ArrayList，也避免不了多这一步，各位可以试一下在ArrayList中直接返回array属性，结果中会出现一堆null值，而且这样做的话，对于array的改变会直接影响到ArrayList本身，这并不是我们所希望看到的，所以我们返回的只是一个拷贝。
当然，为了解决这个问题，我们并不是没有办法，比如给LinkedList和ArrayList加入get方法，而这个方法有一个参数index，这是我们常用的遍历方法。如此一来，便解决了二次遍历的问题。
但是问题又来了，那就是我们无法给HashSet提供一个根据索引获取元素的方法，由于散列特性的缘故，set中的元素是无序的，或者说顺序是不被保证的。那么这个get方法，在HashSet中便无法提供，因为这里没有我们通俗意义上的索引的概念。
可以看到，上面LZ粗浅的分析，得出一个结论。三个集合类，如果统一提供数组给客户端遍历，那么在遍历过程中会出现重复遍历的现象。而如果消除这种重复遍历，则由于内部数据结构的不同，三个集合类无法做到像提供数组一样，给客户端提供统一的遍历方式。
下面我们就让三个集合类全部提供一个方法，可以返回一个Iterator实例，来解决这个问题，并且实现Iterable接口。
ArrayList
package com.iterator;
import java.util.Iterator;
public class ArrayList<E> implements Iterable<E>{
private static final int INCREMENT = 10;
private E[] array = (E[]) new Object[10];
private int size;
public Object[] toArray() {
Object[] copy = new Object[size];
System.arraycopy(array, 0, copy, 0, size);
return copy;
}
public int size() {
return size;
}
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor = 0;
public boolean hasNext() {
return cursor != size();
}
public E next() {
return array[cursor++];
}
public void remove() {
}
}
}
LinkedList
package com.iterator;
import java.util.Iterator;
public class LinkedList<E> implements Iterable<E>{
private Entry<E> header = new Entry<E>(null, null, null);
private int size;
public LinkedList() {
header.next = header.previous = header;
}
public int size(){
return size;
}
public Object[] toArray(){
Object[] result = new Object[size];
int i = size - 1;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i--] = e.value;
return result;
}
private static class Entry<E>{
E value;
Entry<E> previous;
Entry<E> next;
public Entry(E value, Entry<E> previous, Entry<E> next) {
super();
this.value = value;
this.previous = previous;
this.next = next;
}
}
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
Entry<E> current = header;
public boolean hasNext() {
return current.previous != header;
}
public E next() {
E e = current.previous.value;
current = current.previous;
return e;
}
}
}
HashSet:
package com.iterator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class HashSet<E> implements Iterable<E>{
private static final Object NULL = new Object();
private Map<E, Object> map = new HashMap<E, Object>(7,1);
public void add(E e){
map.put(e, NULL);
}
public int size(){
return map.size();
}
public Object[] toArray(){
return map.keySet().toArray();
}
public Iterator<E> iterator() {
return map.keySet().iterator();
}
}
其中输出的结果与第一例是一样的，都是将1到11输出三遍，可以明显的看出，我们刚才的重复遍历问题不见了，而且三个集合类的迭代方法是一样的，而有了这个特点，JAVA在此基础上，给我们提供了foreach语法，所以我们可以写成下面这样。
package com.iterator;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for (int i = 1; i <= 11; i++) {
arrayList.add(i);
}
System.out.println("arrayList size:" + arrayList.size());
for (Integer i : arrayList) {
System.out.println(i);
}
System.out.println("----------------------------------------------");
HashSet<Integer> hashSet = new HashSet<Integer>();
for (int i = 1; i <= 11; i++) {
hashSet.add(i);
}
System.out.println("hashSet size:" + hashSet.size());
for (Integer i : hashSet) {
System.out.println(i);
}
System.out.println("----------------------------------------------");
LinkedList<Integer> linkedList = new LinkedList<Integer>();
for (int i = 1; i <= 11; i++) {
linkedList.add(i);
}
System.out.println("linkedList size:" + linkedList.size());
for (Integer i : linkedList) {
System.out.println(i);
}
}
}
java8以后出现的Object.forEach方法也是利用iterator实现的，所以任意集合的遍历通过forEach的写法效率上是最优的。
