上一章  双向链表的简单实现，本章介绍迭代实现模式使用迭代模式的优点：1，实现功能分离，简化容器接口。让容器只实现本身的基本功能，把迭代功能委让给外部类实现，符合类的设计原则。2，隐藏容器的实现细节。3，为容器或其子容器提供了一个统一接口，一方面方便调用；另一方面使得调用者不必关注迭代器的实现细节。4，可以为容器或其子容器实现不同的迭代方法或多个迭代方法。我觉得第4点说的很好，对于一堆数据而言，不同的人(或业务逻辑)使用它的方式也不尽相同，定义一个theIterator继承Iterator，不仅提供next，hasNext以及remove这个最小的操作集合，同时也可以提供更多的其它方法。在theIterator的实现类中，具体实现不同的迭代方法，比如顺序、逆序或根据其它语义进行遍历等，再通过类厂的方式将一个theIterator实现的对象交给用户使用。

迭代模式实现：package com.ds.link;

import java.util.Iterator;

import java.util.NoSuchElementException;

public class DoubleLinkIt implements Iterable {

/**

* Node类定义了双向链表中节点的结构，它是一个私有类，

* 而其属性和构造函数都是公有的，这样，其父类可以直接访问其属性

* 而外部类根本不知道Node类的存在。

* @author ZHB

*

* @param 类型

* @param Data 是节点中的数据

* @param pre 指向前一个Node节点

* @param next 指向后一个Node节点

*/

private class Node {

public Node pre;

public Node next;

public T data;

public Node(T data, Node pre, Node next) {

this.data = data;

this.pre = pre;

this.next = next;

}

public Node() {

this.data = null;

this.pre = null;

this.next = null;

}

}

// 下面是DoubleLinkedList类的数据成员和方法

private int theSize;

private Node Header;

private Node Tail;

/*

* 构造函数

* 我们构造了一个带有头、尾节点的双向链表

* 头节点的Next指向尾节点

* 为节点的pre指向头节点

* 链表长度起始为0。

*/

public DoubleLinkIt() {

theSize = 0;

Header = new Node(null, null, null);

Tail = new Node(null, Header, null);

Header.next = Tail;

}

public void add(T item) {

Node aNode = new Node(item, null, null);

Tail.pre.next = aNode;

aNode.pre = Tail.pre;

aNode.next = Tail;

Tail.pre = aNode;

theSize++;

}

public boolean isEmpty() {

return (this.theSize == 0);

}

public int size() {

return this.theSize;

}

public T getInt(int index) {

if (index > this.theSize - 1 || index < 0)

throw new IndexOutOfBoundsException();

Node current = Header.next;

for (int i = 0; i < index; i++) {

current = current.next;

}

return current.data;

}

public void print() {

Node current = Header.next;

while (current.next != null) {

System.out.println(current.data.toString());

current = current.next;

}

}

/*

*

* DoubleLinkIt类实现了java.lan.Itrable接口，

* 因此我们必须实现其public Iterator iterator() {}方法，它的返回值是一个迭代器对象，

* 那么我就定义一个内部私有类——MyListIterator，这个类实现了iterator接口。

* 在public Iterator iterator() 方法中，我就构造这么一个MyListIterator的对象并返回。

*Iterator接口有三个方法是我们必须实现的，hasNext，next和remove，

*这是迭代操作的最小集合了。对于不同的迭代器执行方式，

*我们可以定义多个类似MyListIterator这样的实现类，只要在链表类中的iterator() 方法中把具体实现类的对象返回给用户就OK了。

*/

@Override

public Iterator iterator() {

return new myListIterator();

}

public class myListIterator implements Iterator {

Node current = Header.next;

@Override

public boolean hasNext() {

return (current != Tail);

}

@Override

public T next() {

if (!hasNext())

throw new IndexOutOfBoundsException();

T item = current.data;

current = current.next;

return item;

}

@Override

public void remove() {

if (!hasNext())

throw new NoSuchElementException();

current.pre.next = current.next;

current.next.pre = current.pre;

current = current.next;

theSize--;

}

}

//测试代码

public static void main(String[] args) {

DoubleLinkIt itLink = new DoubleLinkIt();

for (int i = 0; i < 10; i++) {

ItemInfo item = new ItemInfo(" " + i, i * i);

itLink.add(item);

}

Iterator it = itLink.iterator();

// while (it.hasNext())

// it.remove();

while (it.hasNext())

System.out.println(it.next().toString());

}

}

其中ItemInfo的定义如下：package com.ds.link;

public class ItemInfo {

private String name;

private int age;

public ItemInfo(String name,int age){

this.name = name;

this.age = age;

}

public ItemInfo(){

this.name = null;

this.age = 0;

}

public String toString(){

StringBuilder sb = new StringBuilder("姓名：");

sb.append(this.name).append("\t").append("年龄:").append(this.age);

return sb.toString();

}

}

运行结果：姓名： 0 年龄:0

姓名： 1 年龄:1

姓名： 2 年龄:4

姓名： 3 年龄:9

姓名： 4 年龄:16

姓名： 5 年龄:25

姓名： 6 年龄:36

姓名： 7 年龄:49

姓名： 8 年龄:64

姓名： 9 年龄:81

如果存在问题，我们随时沟通！