import java.util.*;
class Test1 {
        public static void main(String[] args) {
                method2();
        }
               public static void method2() {
                List l=new ArrayList();
                l.add("a");
                l.add("b");
                l.add("c");
                ListIterator lt=l.listIterator();
                while(lt.hasNext()) {
                        Object obj=lt.next();
                        if(obj.equals("b")) {
                                lt.add("d");
                                lt.hasPrevious();
                                Object obj1=lt.previous();//得到d/b/a
                                //lt.set("d");
                                System.out.println(obj1);//a d b d c
                        }
                        System.out.println(obj);
                }//System.out.println(l);

        }

}
希望大家仔细看下,我在用到List集合特有迭代器ListIterator中,从头判断hasNext()方法和从后判断hasPrevious()方法混合使用.
但是输出的结果和自己过一遍得到的结果不一样,请大家分析下  -->obj1的结果是怎么回事?的到a d b d c?

你好，
previous
E previous()返回列表中的前一个元素。可以重复调用此方法来迭代列表，或混合调用 next 来前后移动（注意交替调用 next 和 previous 将重复返回相同的元素）。

这个方法会是你注意看下。
并不是hasPrevious()方法上调的。

小测试了一下，都挺有意思的，

1. import java.util.*;
   
2. class Test1 {
   
3.        public static void main(String[] args) {
   
4.                 method2();
   
5.         }
   
6.                public static void method2() {
   
7.                 List l=new ArrayList();
   
8.                 l.add("a");
   
9.                 l.add("b");
   
10.                 l.add("c");
    
11.                 ListIterator lt=l.listIterator();
    
12.                 while(lt.hasNext()) {
    
13.                         Object obj=lt.next();
    
14.                         if(obj.equals("b")) {
    
15.                                 lt.add("d");
    
16.                                 System.out.println(l);
    
17.                                 
    
18.                                 System.out.println(lt.hasPrevious());
    
19.                               
    
20.                                 Object obj1=lt.previous();//因为lt.previous()不是说从列表最后，而是当前指针操作
    
21.                                 System.out.println(obj1);//打印的d，可不是a d b d c
    
22.                                 
    
23.                                 System.out.println(l);//没有改变列表
    
24.                                 
    
25.                                 lt.set("eee");
    
26.                                 System.out.println(l);//已经修改了列表中d的值
    
27.                               
    
28.                         }
    
29.                         System.out.println(obj);//打印
    
30.                        /* b
    
31.                           eee
    
32.                           c           这个不奇怪吧
    
33.                           */
    
34.                 }
    
35.                 lt.set("ede");
    
36.                 System.out.println(l);
    
37.                //打印的这个，[a, b, eee, ede]，也真有意思，不好操作啊
    
38. 
    
39.        }
    
40. 
    
41. }

复制代码

不用客气，多用打印语句一步步测试，分析，把自己当做jvm去执行代码

1. public class Test1 {
   
2.         public static void main(String[] args) {
   
3.                 method2();
   
4.         }
   
5. 
   
6.         public static void method2() {
   
7.                 List l = new ArrayList();
   
8.                 l.add("a");
   
9.                 l.add("b");
   
10.                 l.add("c");
    
11.                 //这个时候，l里的顺序是这样的[a,b,c]
    
12.                 ListIterator lt = l.listIterator();
    
13.                 while (lt.hasNext()) {
    
14.                         //这个obj会得到a(第一次)，b(第二次)，d(第三次),c(第四次)
    
15.                         Object obj = lt.next();
    
16.                         //循环只有为b的时候才会进去，所以也就是第2次会进去
    
17.                         if (obj.equals("b")) {
    
18.                                 lt.add("d");       
    
19.                                 //加完d以后，l里的顺序是这样的[a,b,d,c]，因为add昨晚以后，it会把指针指向3的位置，也就是c的位置。
    
20.                                 lt.hasPrevious();
    
21.                                 //因为previous的影响，指针指向前一位的值，即2位置上的d
    
22.                                 Object obj1 = lt.previous();
    
23.                                 //输出obj1，即d(这个输出语句整个程序运行期间只会输出一次)
    
24.                                 System.out.println(obj1);
    
25.                                
    
26.                         }
    
27.                         //这个依次输出a/b/d/c
    
28.                         System.out.println(obj);
    
29.                 }
    
30. 
    
31.         }
    
32. 
    
33. }

复制代码

总结下：
ListIterator对象在做正续遍历的时候，每次取完值以后，指针会加1指向下个元素，但是执行previous时，指针去取出当前指针的前一个数，取完后并不会继续-1以便指向更前的数。
所以插入d以后，previous的结果是取出d，但是指针指向的还是d，而不是之前的b。

liuyangyang 发表于 2013-4-15 21:32
你好，
previous
E previous()返回列表中的前一个元素。可以重复调用此方法来迭代列表，或混合调用 next 来 ...

恩，加油！