黑马程序员技术交流社区

标题: 关于List集合的问题,请大家看看 [打印本页]
作者: smile_joe    时间: 2013-4-15 21:02
标题: 关于List集合的问题,请大家看看
本帖最后由 smile_joe 于 2013-4-20 19:26 编辑

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?
作者: liuyangyang    时间: 2013-4-15 21:32
你好，
previous
E previous()返回列表中的前一个元素。可以重复调用此方法来迭代列表，或混合调用 next 来前后移动（注意交替调用 next 和 previous 将重复返回相同的元素）。

这个方法会是你注意看下。
并不是hasPrevious()方法上调的。
作者: 曹睿翔    时间: 2013-4-15 22:02
小测试了一下，都挺有意思的，
  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]，也真有意思，不好操作啊

  39.        }

  41. }
复制代码
作者: 曹睿翔    时间: 2013-4-15 22:08
不用客气，多用打印语句一步步测试，分析，把自己当做jvm去执行代码
作者: PANZERLEADER    时间: 2013-4-15 22:13
  1. public class Test1 {
  2.         public static void main(String[] args) {
  3.                 method2();
  4.         }

  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.                 }

  31.         }

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


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

恩，加油！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2