package cn.itcast.lianxi;

import java.util.ArrayList;
import java.util.ListIterator;

import org.omg.CORBA.Object;

public class JiHeKUANGJiang {

public static void main(String[] args) {
                ArrayList<String> list = new ArrayList<String>();
                show(list);
        }

        public static void show(ArrayList<String> list) {
                list.add("xiaoqinag");
                list.add("wangwu");
                list.add("lisi");
                list.add("zhangsan");
                for(ListIterator<String> it=list.listIterator();it.hasNext();){
                        System.out.println(it.next());//这个为什么就有；
                }
                for (ListIterator<String> it = list.listIterator(); it.hasPrevious();) {
                        System.out.println(it.previous());//为什么这个没有输出？？
                }
}

这位同学，你自己都蒙，别人更蒙啊。能不能把问题表达清楚呀，不然别人怎么回答你呀。

楼主,你第二个 for (ListIterator<String> it = list.listIterator(); it.hasPrevious();) {
                        System.out.println(it.previous());//为什么这个没有输出？？
                }
里面的it和上面for语句里的不是一个,你放在for语句里,它们都是局部变量,
相当于你重新定义了一个listIterator,它开始指的位置还是头的位置,hasPrevious()肯定为假喽,就没输出了

如果想达到你预想的要求,把迭代器定义在两个for外面即可,如下:
        public static void show(ArrayList<String> list) {
                list.add("xiaoqinag");
                list.add("wangwu");
                list.add("lisi");
                list.add("zhangsan");
                ListIterator<String> it = list.listIterator();
                for (; it.hasNext();) {
                        System.out.println(it.next());
                }
                for (; it.hasPrevious();) {
                        System.out.println(it.previous());
                }
        }

不妨先这样写试一下。   
  ListIterator<String> it = list.listIterator();
                  
                         while(it.hasNext()){
                                 System.out.println(it.next());
                         }
                         while(it.hasPrevious()){
                                 System.out.println(it.previous());
                         }


因为
        public static void show(ArrayList<String> list) {
                 list.add("xiaoqinag");
                 list.add("wangwu");
                 list.add("lisi");
                 list.add("zhangsan");
                 for(ListIterator<String> it=list.listIterator();it.hasNext();){
                         System.out.println(it.next());//这个为什么就有；
                 }
                 for (ListIterator<String> it = list.listIterator(); it.hasPrevious();) {
                         System.out.println(it.previous());//为什么这个没有输出？？
                 }
                因为第一个for中的it 作用域在第一个for中，当第一个for循环执行完时，it 会释放
              第二个for中的it作用域在第二个for中，it在此作用域中才有效。
          所以第一个for中的it 与第二个for中的it 不是同一个对象。
          第一个for可以循环出来数据，是因为ListIterator的指针最开始是在最上面的
          例如：  ——>  
                                       "sdfsdf"
                                       "sdf"
                                        "sdfs"
                hasNext（）方法就是在判断这个指针下面有没有数据，如果有就返回ture  用next()方法返回下面的元素
          第二个for不可以循环出来数据，是因为ListIterator的指针最开始是在最上面的
          例如：  ——>  
                                       "sdfsdf"
                                       "sdf"
                                        "sdfs"
               hasPrevious() 方法就是在判断这个指针上面有没有数据，如果有就返回ture  用previous()方法返回下面的元素
         因为指针上面没有数据，所以就不打印。返回false.
              其实根本原因就是 两个it 它们不是同一个对象。指针的起始位置都是在最上面。

                  
        

}

1.         public static void main(String[] args) {
   
2.                 ArrayList<String> list = new ArrayList<String>();
   
3.                 show(list);
   
4.         }
   
5. 
   
6.         public static void show(ArrayList<String> list) {
   
7.                 list.add("xiaoqinag");
   
8.                 list.add("wangwu");
   
9.                 list.add("lisi");
   
10.                 list.add("zhangsan");
    
11.                 ListIterator<String> it = list.listIterator();
    
12.                 while (it.hasNext()) {
    
13.                         System.out.println(it.next());
    
14.                 }
    
15. 
    
16.                 while (it.hasPrevious()) {
    
17.                         System.out.println(it.previous());
    
18.                 }
    
19.         }

复制代码

这样就OK了

楼主用正向遍历hasNext()方法和用逆向遍历hasPervious()遍历ListIterator，只是两次for循环中用的都是独立的ListIterator实例对象，在逆向遍历的时候，因为指针还在容器的开始处，在向上查询没有元素可查，因而逆向遍历打印结果是空。只需要让容器的指针指向其结尾处就可以完全遍历容器元素。修改的具体代码如下：

1. public class TestListIterator {
   
2.        
   
3.         public static void main(String[] args) {
   
4.         ArrayList<String> list = new ArrayList<String>();
   
5.         show(list);
   
6.         }
   
7.         public static void show(ArrayList<String> list) {
   
8.         list.add("xiaoqinag");
   
9.         list.add("wangwu");
   
10.         list.add("lisi");
    
11.         list.add("zhangsan");
    
12.         
    
13.         ListIterator<String> it=list.listIterator();
    
14.         for(;it.hasNext();){
    
15.                 System.out.println(it.next());
    
16.         }
    
17.         for (;it.hasPrevious();) {
    
18.                 System.out.println(it.previous());
    
19.         }
    
20.         }
    
21. }

复制代码

2楼 正解{:soso_e179:}

嗯谢谢各位、、我懂了！{:soso_e179:}