黑马程序员技术交流社区

标题: 关于listIterator的一个问题 [打印本页]
作者: 张先龙    时间: 2013-4-5 20:11
标题: 关于listIterator的一个问题
本帖最后由 张先龙 于 2013-4-6 08:36 编辑

为什么一下程序的结果是这样的：
code：
import java.util.*;
public class Test {
  public static void main (String args[]) {
   String elements[] = {"Apple", "Samsung", "Lenovo", "MOTO"};
    int i=0;
   List list = new LinkedList(Arrays.asList(elements));
   ListIterator iter = list.listIterator(list.size());
   while(iter.hasPrevious()){
       if (iter.previous().equals("Samsung")){
           iter.set("aa");
      }
       System.out.println(iter.previous());  
   } } }

输出结果：
Lenovo
Apple
为什么 MOTO 没输出来？ 但是如果我没用set的话 就有输出
作者: 刘焕新    时间: 2013-4-5 20:32
本帖最后由 刘焕新 于 2013-4-5 21:08 编辑

因为迭代器遍历集合里的元素时，previous()方法被调用一次之后，下一次再调用它时，它读取的将是集合中的下一个元素。

你在while的每次循环里调用了两次previous方法，但只有一次打印输出，所以只看到一半的元素。
  1. import java.util.*;

  3. public class ClassTest {
  4.         public static void main(String args[]) {
  5.                 String elements[] = { "Apple", "Samsung", "Lenovo", "MOTO" };
  6.                 int i = 0;
  7.                 List list = new LinkedList(Arrays.asList(elements));
  8.                 ListIterator iter = list.listIterator(list.size());
  9.                 while (iter.hasPrevious()) {
  10.                         //为了避免之前的情况，每次循环内部，只调用一次previous()方法：
  11.                         String s = (String)iter.previous();
  12.                         System.out.println("original:"+s);
  13.                         if (s.equals("Samsung")) {
  14.                                 iter.set("aa");
  15.                         }
  16.                 }
  17.                
  18.                 //用增强for循环重新遍历，打印看看：
  19.                 for(Object o : list) {
  20.                         System.out.println(o);
  21.                 }
  22.         }
  23. }
复制代码
作者: 火麒麟    时间: 2013-4-5 20:37
肯定是这样啊，iter.previous()指的是前一个元素，你在if (iter.previous().equals("Samsung"))这里调用了iter.previous()，判断的是"MOTO“，输出时又写了一遍，它就输出了前边的 "Lenovo”，一次类推，后边的也是
作者: 随便    时间: 2013-4-5 20:47
  1. public static void main(String[] args) {
  2.                 String elements[] = {"Apple", "Samsung", "Lenovo", "MOTO"};
  3.             int i=0;
  4.            List list = new LinkedList(Arrays.asList(elements));
  5.            ListIterator iter = list.listIterator(list.size());
  6.            while(iter.hasPrevious()){
  7.                    Object o = iter.previous(); //把前一个对象，存起来。
  8.                if (o.equals("Samsung")){
  9.                    iter.set("aa");
  10.               }
  11.                System.out.println(o);  
  12.            }
  13.         }
复制代码
while(iter.hasPrevious()){
       if (iter.previous().equals("Samsung")){//调用一次
           iter.set("aa");
      }
       System.out.println(iter.previous());//调用一次

你连续调用两次,MOTO肯定看不见。
作者: 刘印12    时间: 2013-4-5 20:48
不对啊！我按照你这个程序吧set去了输出的结果就是  "Apple", "Samsung", "Lenovo",
  1. import java.util.*;

  3. public class Test {
  4.         public static void main(String args[]) {
  5.                 String elements[] = { "Apple", "Samsung", "Lenovo", "MOTO" };
  6.                
  7.                 @SuppressWarnings("unused")
  8.                 int i = 0;
  9.                 List<String> list = new LinkedList<String>(Arrays.asList(elements));
  10.                 ListIterator<String> iter = list.listIterator(list.size());
  11.                 while (iter.hasPrevious()) {
  12.         //                if (iter.previous().equals("Samsung")) {
  13.         //                        iter.set("aa");
  14.         //                }
  15.                         System.out.println(iter.previous());
  16.                 }
  17.         }
  18. }
复制代码
下面是我查询的API你仔细看看，如果你发现我哪回答的不好 希望得到你的回复！！！！

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

返回：
列表中的上一个元素。

void set(E e)用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。只有在最后一次调用 next 或 previous 后既没有调用 ListIterator.remove 也没有调用 ListIterator.add 时才可以进行该调用。

参数：
e - 用于替换 next 或 previous 返回的最后一个元素的元素。
作者: 田光峰    时间: 2013-4-5 21:11
为什么一下程序的结果是这样的：
code：
import java.util.*;
public class Test {
  public static void main (String args[]) {
   String elements[] = {"Apple", "Samsung", "Lenovo", "MOTO"};
    int i=0;
   List list = new LinkedList(Arrays.asList(elements));
   ListIterator iter = list.listIterator(list.size());
   while(iter.hasPrevious()){
       if (iter.previous().equals("Samsung")){
           iter.set("aa");
      }
       System.out.println(iter.previous());  
   } } }
iter.hasPrevious()是从后面判断元素是否存在，iter.previous()是获取元素
hasnext（）是从前面判断元素是否存在，next（）是获得元素。
iter.previous()每调用一次就会向前移动一次，而在
if (iter.previous().equals("Samsung")){
           iter.set("aa");
      }
       System.out.println(iter.previous());  
中调用了两次所以只有两个值。



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