A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© smile_joe 中级黑马   /  2013-4-15 21:02  /  1902 人查看  /  5 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 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?

评分

参与人数 1技术分 +1 收起 理由
冯海霞 + 1

查看全部评分

5 个回复

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

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

点评

好,再仔细去研究看看  发表于 2013-4-15 22:06
回复 使用道具 举报
小测试了一下,都挺有意思的,
  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. }
复制代码

点评

学到这里,感觉它总会有可以用到的地方,所以想了解它的规律,谢谢你  发表于 2013-4-15 22:06
回复 使用道具 举报
不用客气,多用打印语句一步步测试,分析,把自己当做jvm去执行代码
回复 使用道具 举报
  1. public class Test1 {
  2.         public static void main(String[] args) {
  3.                 method2();
  4.         }

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

  29.         }

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


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

恩,加油!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马