public class GenericTest {
        public static void main(String[] args) {
                List<String> inte = new LinkedList<String>();
                inte.add("1");
                inte.add("2");
                inte.add("3");
                inte.add("4");

                ListIterator<String> list =inte.listIterator();
                while(list.hasPrevious())
                {               
                        System.out.println(list.previous());
                }
               
               
        }
}
怎么什么也不输出错在哪了？

import java.util.*;

public class GenericTest {
        public static void main(String[] args) {
                List<String> inte = new LinkedList<String>();
                ListIterator<String> list =inte.listIterator();
                list.add("1");
                list.add("2");
                list.add("3");
                list.add("4");

                //ListIterator<String> list =inte.listIterator();
                while(list.hasPrevious())
                {               
                        System.out.println(list.previous());
                }
               
               
        }
}


输出没错，但是add错了。要往系列表迭代器里面添加，而不是 序列里面添加。

1.         List<String> inte = new LinkedList<String>();
   
2.         inte.add("1");
   
3.         inte.add("2");
   
4.         inte.add("3");
   
5.         inte.add("4");
   
6. 
   
7.        ListIterator<String> list =inte.listIterator();
   
8.         while(list.hasNext())//以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
   
9.         {               
   
10.                
    
11.                 System.out.println(list.next());返回列表中的下一个元素。
    
12.               
    
13.         }

复制代码

list.hasPrevious());// 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。 自己好看看API每个方法的用法吧。

黑马我来了 发表于 2012-4-5 14:58
list.hasPrevious());// 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。 自己好看看API每个方法 ...

恩 但是这里如果要实现你想遍历的话需要用到它的另外一个构造方法：带参数的的

public class GenericTest {
        public static void main(String[] args) {
                List<String> inte = new LinkedList<String>();
                ListIterator<String> list =inte.listIterator();
                list.add("1");
                list.add("2");
                list.add("3");
                list.add("4");

                //ListIterator<String> list =inte.listIterator(inte.size);//这里的参数
                while(list.hasPrevious())
                {               
                        System.out.println(list.previous());
                }
               
               
        }
}

黑马我来了 发表于 2012-4-5 14:58
list.hasPrevious());// 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。 自己好看看API每个方法 ...

恩 但是这里如果要实现你想遍历的话需要用到它的另外一个构造方法：带参数的的

public class GenericTest {
        public static void main(String[] args) {
                List<String> inte = new LinkedList<String>();
                ListIterator<String> list =inte.listIterator();
                list.add("1");
                list.add("2");
                list.add("3");
                list.add("4");

                //ListIterator<String> list =inte.listIterator(inte.size);//这里的参数
                while(list.hasPrevious())
                {               
                        System.out.println(list.previous());
                }
               
               
        }
}

2楼是正解  {:soso_e179:}  胶鞋脑袋 看来得去歇会了

public class GenericTest {
        public static void main(String[] args) {
                List<String> inte = new LinkedList<String>();
                inte.add("1");
                inte.add("2");
                inte.add("3");
                inte.add("4");

                ListIterator<String> list =inte.listIterator();
                while(list.hasPrevious())     //hasPrevious是以逆向遍历列表，当ListIterator初始化时，它指向的是列表的最前端，逆向遍历已经没有无素了，所以会返回false，导致下面代码无法执行。
                {               
                        System.out.println(list.previous());
                }
               
               
        }
}

ListIterator<String> list =inte.listIterator(); 返回是返回此列表元素的列表迭代器 ，而当他调用.next()方法时返回的是迭代器的第一个元素。。所以不然想到这时候迭代器的索引可能是第一个元素的索引-1.这时候再调用 hasPrevious()方法他的前面怎么可能有元素存在呢？可以想上面的说的直接把索引指定到你要 的位置（迭代器的最后一个元素加1.就是迭代器的元素个数。)从最后端遍历回来。。
                while(list.hasPrevious())因为一开始位置就在
                {               
                        System.out.println(list.previous());
                }