查阅API得到ListIterator的基本介绍：

public interface ListIterator<E>extends Iterator<E>系列表迭代器，
允许程序员按任一方向遍历列表、迭代期间修改列表，
并获得迭代器在列表中的当前位置。
ListIterator没有当前元素；
它的光标位置始终位于调用 previous() 所返回的元素和调用 next() 所返回的元素之间。

方法
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的理解。
ListIterator是List集合特有的迭代器，中文名字叫做列表迭代器。
那么为什么List会有这么独特的一个迭代器呢？
在使用迭代器迭代的时候，是不可以使用集合的操作方法的，
因为会发生ConcurrentModificationException，即并发修改异常。

所以在使用迭代器时，只能使用迭代器有的方法，
可是Iterator只有三种方法，
使用Iterator只能进行判断，取出和删除操作。
如果想要添加，修改等操作，就必须使用ListIterator接口了。

需要注意的是：ListIterator接口只能通过List集合获取。
可以通过ListIterator listLiterator()方法获取接口的迭代器。

下面对ListIterator方法进行演示。

1. import java.util.*;
   
2. class ListIteratorDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 method_ListIterator();
   
7.         }
   
8. 
   
9.         //演示ListIterator
   
10.         public static void method_ListIterator()
    
11.         {
    
12.                 //创建一个集合
    
13.                 ArrayList al = new ArrayList();
    
14. 
    
15.                 //共性方法给集合添加元素
    
16.                 al.add("num01");
    
17.                 al.add("num02");
    
18.                 al.add("num03");
    
19. 
    
20.                 //打印原有集合
    
21.                 System.out.println("原有集合"+al);
    
22. 
    
23.                
    
24.                 //创建ListIterator迭代器，
    
25.                 ListIterator li = al.listIterator();
    
26.                
    
27.                
    
28.                 //并对集合集合进行正向遍历
    
29.                 while(li.hasNext())
    
30.                         System.out.println(li.next());
    
31.                
    
32. 
    
33.                 //并对集合集合进行逆向遍历
    
34.                 while(li.hasPrevious())
    
35.                         System.out.println(li.previous());
    
36. 
    
37.                 //ListIterator特有的添加方法
    
38.                 li.add("num04");
    
39.                 //li.add("num05");//添加元素后的集合：[num04, num05, num01, num02, num03]
    
40. 
    
41.                 //打印集合
    
42.                 System.out.println("添加元素后的集合："+al);
    
43. 
    
44.                 //修改
    
45.                 while(li.hasNext())
    
46.                 {
    
47.                         //设置一个临时引用指向集合元素
    
48.                         Object obj = li.next();
    
49. 
    
50.                         //修改指定元素
    
51.                         if(obj.equals("num02"))
    
52.                                 li.set("num10");
    
53.                 }
    
54. 
    
55.                 //打印被修改过后的集合
    
56.                 System.out.println("修改元素“num02”为“num10”后的集合："+al);
    
57. 
    
58.         }
    
59. }

复制代码

说明一下ListIterator正向遍历和逆向遍历的原理，以及添加的原理。
原理就是操作指针。
原有集合[头][num01, num02, num03]
初始     ↑
hasNext = true;
hasPrevious = false;
正向遍历后[头][num01, num02, num03]
指针位置                     ↑
hasNext = false;
hasPrevious = true;

所以在上面的例子中执行添加操作结果是
添加元素后的集合：[num04, num01, num02, num03]
而不是[ num01, num02, num03，num04]
要想变成这样，可以利用正向遍历语句。

受教了，看完感觉又温习了一遍