刚才看见以为同学的问题，试着写了下代码，结果他的问题解决了，我又产生了问题，下面是他的问题
http://bbs.itheima.com/thread-199984-1-1.html
(出处: 黑马程序员IT技术论坛)
在遍历中我发现用迭代器的方式，却不能求到结果，但是用增强for循环却可以，for循环底层靠的不还是迭代器吗？

1. public static void main(String[] args) {
   
2.                 ArrayList<String> listA = new ArrayList<String>();
   
3.                 listA.add("2008");
   
4.                 listA.add("2007");
   
5.                
   
6.                 ArrayList<String> listB = new ArrayList<String>();
   
7.                 listB.add("20089087");
   
8.                 listB.add("20081234");
   
9.                 listB.add("20200801");
   
10.                 listB.add("20071555");
    
11.                
    
12.                 ListIterator<String> itA = listA.listIterator();
    
13.                 ListIterator<String> itB = listB.listIterator();
    
14.                
    
15.                 while(itB.hasNext()){
    
16.                         String B= itB.next();                        
    
17.                         while(itA.hasNext()){
    
18.                                 if(B.startsWith(itA.next())){
    
19.                                         System.out.println(B);
    
20.                                 }
    
21.                         }
    
22.                 }
    
23. //                for(String b :listB){
    
24. //                        for(String a :listA){
    
25. //                                if(b.startsWith(a))
    
26. //                                        System.out.println(b);
    
27. //                        }

复制代码

觉得问题出现在String B= itB.next();                        这行代码不知道对不对，求助

:o
还真是游标的问题

问题不是出在那里，内循环完成一次后，A迭代器已经读到末尾了，当外循环第二次读到内循环时，itA.hasNext()返回的已经是false了，就不再读里边的代码了，这个代码是不用每次都new一个ArrayList的

1. import java.util.*;
   
2. class Demo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 ArrayList<String> listA = new ArrayList<String>();
   
7.         ArrayList<String> listB = new ArrayList<String>();
   
8.         listB.add("20089087");
   
9.         listB.add("20081234");
   
10.         listB.add("20200801");
    
11.         listB.add("20071555");     
    
12.         ListIterator<String> itB = listB.listIterator();
    
13.         while(itB.hasNext())
    
14.                 {
    
15.                         listA.clear();
    
16.                         listA.add("2008");
    
17.                         listA.add("2007");
    
18.                         ListIterator<String> itA = listA.listIterator();                               
    
19.                         String B= itB.next();                        
    
20.                         while(itA.hasNext())
    
21.                         {
    
22.                                 if(B.startsWith(itA.next()))
    
23.                                 {
    
24.                                         System.out.println(B);
    
25.                                 }
    
26.                         }
    
27.                                        
    
28.                 }
    
29.         }
    
30. }

复制代码

老夫再水一下   混一个黑马币  楼主不要介意~~~~

ackage jihekuangjia;
import java.util.*;
class jihekuangjia_test1
{
        public static void main(String[] args) {            
            ArrayList<String> listB = new ArrayList<String>();
            listB.add("20089087");
            listB.add("20081234");
            listB.add("20050801");
            listB.add("20071555");

            ListIterator<String> itB = listB.listIterator();
            
            while(itB.hasNext())
            {
                    String B= itB.next();  
                    ArrayList<String> listA = new ArrayList<String>();
                        listA.add("2008");
                        listA.add("2007");
                        ListIterator<String> itA = listA.listIterator();
                   
                    while(itA.hasNext())
                    {
                         String A = itA.next();
                                if(B.startsWith(A))
                               {
                                    System.out.println(B);
                               }
                                
                    }
            }
        }
}

表示应该成功了 输出的结果是三个 ：
20089087
20081234
20071555

刚才的帖子已经给出了答案
问题出在嵌套循环里用itA.hasNext(),当B中的第一个元素把A中的所有元素都遍历一次的时候，指针已经到了A集合尾部下个元素为空，必须让指针重新回到A集合头部才可以再次遍历A集合 也就是说 内部的嵌套其实只执行了一遍，我也不知道如果每次循环让迭代器指针都回到最初~~~~~~~~~~~~~我就只能提醒你  别人给了你答案了~~~~

第二个迭代器的问题，游标已经下去了，再循环，没有内循环了