1，先了解下JAVA类库中的迭代器：JAVA提供了两种基本类型的迭代器，分别用两个接口来表示：Iterator<T>，ListIterator<T>。其中，Iterator<T>接口中只定义了三个方法：hasNext()、iterator()、next()，而ListIterator<T>中，除了拥有前面所述的三种方法外，而另外拥有hasPrevious()、previous()、remove()、set()等其他方法（具体参考JDK文档）。
这说明：实现了Iterator<T>接口的迭代器只能往一个方向遍历(正向)，而实现了ListIterator<T>接口的迭代器即可以正向遍历又可以反向遍历（由hasPrevious()、previous()实现反向遍历），同时，它还可以对遍历的元素进行修改（由set()方法实现）、删除当前遍历的元素（由remove()实现）。
2，当前，在写程序时，最好能够使用JAVA类库中已经为我们定义好的迭代器，它为JAVA的集合类都定义了返回上述两种迭代器的方法。
如：ArrayList<T>类的 iterator() 方法返回一个Iterator<T>类型的只能对单一方向进行迭代的迭代器，而listIterator()方法返回一个ListIterator<T>类型的迭代器，它不仅能双向迭代，而且修改、删除迭代的元素。
3，下面实例代码实现了一种ADT之顺序表（实质为数组），并且该数组拥有遍历器。该遍历器能对当前遍历的数组进行修改和删除。个人感觉要想同时保证迭代器具有修改和删除的功能，同时又要保证ADT基本操作的正确，对数组下标的合适定义真的很难。
4，首先定义了一个接口ListWithListIteratorInterface，该接口只有一个方法getIterator()，该方法负责生成一个迭代器并返回给调用者。然后，再让实现了数组的类SequenceListWithIterator<T> implements ListWithListIteratorInterface<T>.
为什么要这样做呢？为什么不用SequenceListWithIterator直接 implements ListIterator<T> ?
因为，如果用SequenceListWithIterator直接 implements ListIterator<T>，那么SequenceListWithIterator类的对象不仅是一个迭代器（因为它implements ListIterator<T>）而且是一个顺序表（因为它实现了线性表中的各种基本操作，相当于implments ListInterface<T>了）。这意味着，在我们的代码中，当创建了一个SequenceListWithIterator对象时，该对象不能在同一时刻对线性表进行多次迭代，因为它本身就是迭代器，只能对"自身"元素进行迭代了。
而采用SequenceListWithIterator<T> implements ListWithListIteratorInterface<T>，这样SequenceListWithIterator对象只是线性表，它不是迭代器。但是，由于它实现了ListWithListIteratorInterface<T>，它(顺序表对象)就可以调用getIterator()方法获得一个迭代对象，让该迭代器对象对自己进行遍历，当然了，它就可以多次调用getIterator()方法获得多个迭代器对象，从而可以让多个迭代器同时对自己进行遍历。
接口ListWithListIteratorInterface具体代码如下：
import java.util.ListIterator;
public interface ListWithListIteratorInterface<T> {
public ListIterator<T> getIterator();
}
实现了线性表的基本操作（说明它是一个顺序表）及拥有一个实现了ListIterator<T>接口内部类（说明它拥有一个迭代器）的具体代码如下：
import java.util.Arrays;
import java.util.ListIterator;
import java.util.NoSuchElementException;
public class SequenceListWithIterator<T> implements
ListWithListIteratorInterface<T> {
private final int DEFAULT_SIZE = 16;// final实例变量显示指定初始值，且不再变化。
private Object[] elementData;// 该数组用来保存顺序表中的元素
private int capacity;// 保存数组的长度
private int size;// 保存顺序表中当前元素的个数
private enum Move {
NEXT, PREVIOUS
};
private class IteratorForSequenceList implements ListIterator<T> {
private int nextIndex;// 标记迭代器指针的位置
private boolean isRemoveOrSetLegal;// 标记 remove() 或 set() 操作是否合法
private Move lastMove;// 当进行了一次移动操作后，lastMove指示这是前移而是后移
private IteratorForSequenceList() {
nextIndex = 0;
isRemoveOrSetLegal = false;//初始值为false，当调用了next()或previous()时被设置为true
lastMove = null;
}
public boolean hasNext() {
return nextIndex < size - 1;
}
public T next() {
if (hasNext()) {
lastMove = Move.NEXT;// 进行的是后移操作
isRemoveOrSetLegal = true;// 当next()调用了之后，才可以调用remove()或set()
return (T) elementData[nextIndex++];// 注意nextIndex的自增顺序
} else
throw new NoSuchElementException("Illegal call to next(),"
+ "迭代器位于表的最后端");
}
public boolean hasPrevious() {
return (nextIndex > 0) && (nextIndex <= size);
}
public T previous() {
if (hasPrevious()) {
lastMove = Move.PREVIOUS;// 进行的是前移操作
isRemoveOrSetLegal = true;
return (T) elementData[--nextIndex];// 注意nextIndex的自减顺序
} else
throw new NoSuchElementException("Illegal call to previous()"
+ "iterator is before beginning of list");
}
// 返回当前元素的索引
public int nextIndex() {
int result;
if (hasNext())
result = nextIndex + 1;
else
result = size;// 迭代超出顺序表的最后一个元素时返回顺序表中元素的个数
return result;
}
// 返回当前元素的前一个元素的索引
public int previousIndex() {
int result;
if (hasPrevious())
result = nextIndex - 1;
else
result = -1;// 迭代在顺序表的第一个元素时，返回-1
return result;
}
// 删除当前迭代的元素
public void remove() {
if (isRemoveOrSetLegal) {
isRemoveOrSetLegal = false;
if (lastMove.equals(Move.NEXT)) {
// next()被调用，但add() remove()没有被调用
SequenceListWithIterator.this.delete(nextIndex - 1);
nextIndex--;
} else if (lastMove.equals(Move.PREVIOUS)) {
SequenceListWithIterator.this.delete(nextIndex);
}
} else
throw new IllegalStateException(
"Illegal call to remove();"
+ "next() or previous() was not called, OR add() or remove() called since then");
}
// 更改当前迭代的元素
public void set(T e) {
if (isRemoveOrSetLegal) {
if (lastMove.equals(Move.NEXT))
// 使用内部类机制,内部类里面可以可以直接访问它外部类的底层数据
elementData[nextIndex - 1] = e;
else {
assert lastMove.equals(Move.PREVIOUS);
elementData[nextIndex] = e;
}
} else {
throw new IllegalStateException(
"Illegal call to set();"
+ "next() or previous() was not called, OR add() or remove() called since then");
}
}
// 在迭代器的当前元素之前添加一个元素,注意是之前
public void add(T e) {
// set 和 remove 操作只能是在迭代器访问过(跳跃过)某元素之后才能进行
isRemoveOrSetLegal = false; // 进行add操作之后，不能立即进行set() 或者 remove()
SequenceListWithIterator.this.insert(e, nextIndex++);
}
}
// 以默认的大小创建顺序表
public SequenceListWithIterator() {
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
}
// 以指定的大小创建顺序表
public SequenceListWithIterator(int initSize) {
capacity = 1;
while (capacity < initSize)
capacity <<= 1;// 将capacity设置成大于initSize的最小2次方
elementData = new Object[capacity];
}
public ListIterator<T> getIterator() {
return new IteratorForSequenceList();
}
// 获取顺序表中当前元素的个数
public int length() {
return size;
}
// 获取顺序表中索引为 i 处的元素，i表示索引，即以 0 开始
public T get(int i) {
if (i < 0 || i > size - 1)
throw new IndexOutOfBoundsException("顺序表索引越界");
return (T) elementData[i];
}
// 查看顺序表中指定元素的索引，若未找到，返回-1
public int locate(T element) {
for (int i = 0; i < size; i++)
if (elementData[i].equals(element))
return i;
return -1;
}
// 在顺序表的指定索引处插入一个元素
public void insert(T element, int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("顺序表索引越界");
ensureCapacity(size + 1);// 确保顺序表满时进行扩容，从而能插入元素
// 将指定索引后的所有元素向后移动一个位置
// System.arraycopy(elementData, index, elementData, index + 1, size -
// index);
for (int i = size; i > index; i--)
elementData[i] = elementData[i - 1];
elementData[index] = element;
size++;// 顺序表中的元素个数增1
}
private void ensureCapacity(int minCapacity) {
// 当数组容量已满时，对数组进行扩容。将容量扩展到大于minCapacity的最小2的次方
if (minCapacity > capacity) {
while (capacity < minCapacity)
capacity <<= 1;
elementData = Arrays.copyOf(elementData, capacity);
}
}
// 在顺序表的末尾添加一个元素
public void add(T element) {
insert(element, size);
}
// 删除顺序表中指定索引处的元素
public T delete(int index) {
if (index < 0 || index > size - 1)
throw new IndexOutOfBoundsException("顺序表索引越界");
T oldValue = (T) elementData[index];
int numMoved = size - index - 1;// 计算需要移动的元素个数
if (numMoved > 0) {
System.arraycopy(elementData, index + 1, elementData, index,
numMoved);
}
elementData[--size] = null;// 让垃圾回收器及时回收，避免内存泄露
return oldValue;
}
// 删除顺序表中的最后一个元素
public T remove() {
return delete(size - 1);
}
// 判断顺序表是否为空表
public boolean empty() {
return size == 0;
}
// 清空顺序表
public void clear() {
Arrays.fill(elementData, null);// 将数组elementData中的每个元素都赋值null
size = 0;
}
public String toString() {
if (size == 0)
return "[]";
else {
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < size; i++)
sb.append(elementData[i].toString() + ", ");
int len = sb.length();
// 删除由于上面for循环中最后添加的多余的两个字符 (一个是逗号，一个是空格符号)
return sb.delete(len - 2, len).append("]").toString();
}
}
}