Question

java中ListIterator接口的方法到底是如何实现的呢？高分在线等啊！~

查了API文档，为何ListIterator接口为何没有实现类 但是可以通过arraylist类实例化它的对象呢？

ListIterator 的方法摘要
void add(E e) 将指定的元素插入列表（可选操作）。
boolean hasNext() 以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E next() 返回列表中的下一个元素。
int nextIndex() 返回对 next 的后续调用所返回元素的索引。
E previous() 返回列表中的前一个元素。
int previousIndex() 返回对 previous 的后续调用所返回元素的索引。
void remove() 从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

=====以上=====
ListIterator中定义的那么多抽象方法到底是怎么实现的呢？查了API文档，arraylist类或他的父类中本身并没有找到任何覆写以上抽象方法的记录啊？

既然都是抽象方法总要有个类去实现它们吧，一下程序中用arraylist的listIterator()实例化后就可以直接调用这么多的方法了，这个真的很奇怪啊~！

import java.util.ArrayList ;
import java.util.List ;
import java.util.ListIterator ;
public class ListIteratorDemo02{
public static void main(String argsp[]){
List<String> all = new ArrayList<String>() ;
all.add("hello") ;
all.add("_") ;
all.add("world") ;
ListIterator<String> iter = all.listIterator() ; //用 ArrayList的对象all实例化ListIterator接口对象
System.out.print("由前向后输出：") ;
iter.add("Best");
iter.add("choice");
while(iter.hasNext()){
String str = iter.next() ;
System.out.print(str + "、") ;
iter.set("LI - " + str) ; // 修改内容
}
System.out.print("\n由后向前输出：") ;
iter.add("LXH"); //不能是all.add()方法
iter.add("dow"); //不能是all.add()方法
while(iter.hasPrevious()){
String str = iter.previous() ;
System.out.print(str + "、") ;
}
}
};

Answer 1

哥们，能够考虑到这个问题，说明你的求知欲挺强烈，不满足于简单的应用，而重视原理的探究，并且善于思考问题，这些品质正是一个优秀程序员所必须的，坚持下去，相信你肯定会有所建树！
惭愧的是我以前却没有考虑过这个问题，看到你的提问后，我才发现这个原来我也不知道，于是决定研究一下！通过查看API源码并结合文档，终于弄清了其原理：
ArrayList 继承了 AbstractList 这个抽象类

虽然AbstractList 类并未实现ListIterator接口，但是AbstractList 中定义了一个内部类 ListItr ,这个内部类实现了ListIterator接口及其所有的方法。
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
cursor = index;
}
……
}
AbstractList 类还提供了两个公有方法可以获得ListItr这个内部类的实例，也即是ListIterator类型的实例。
public ListIterator<E> listIterator() {
return listIterator(0);
}
public ListIterator<E> listIterator(final int index) {
if (index<0 || index>size())
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}

ArrayList 继承了这两个方法，所以可以通过调用这两个方法获得一个ListIterator类型的实例，
并使用该接口的方法。具体的实现可以查看AbstractList 类的源代码！
建议你使用Eclipse 或者 Myeclipse 集成开发工具调试java程序，这样把光标放到类名上后，按F3键即可查看到该类的源代码了！

Answer 2

查看 java 源码可知，是这样实现的。
==================================
public ListIterator<E> listIterator() {
return new ListItr(0);
}

/**
* An optimized version of AbstractList.ListItr
*/
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}