1. /**
   
2. *  Vector功能与ArrayList一样，只是线程不安全
   
3. *  ArrayList底层用数组实现，查找快，增删慢，线程不安全
   
4. *        LinkedList底层用链表实现，增删快，查找慢。
   
5. *
   
6. *
   
7. */
   
8. import java.util.*;
   
9. 
   
10. class Person {
    
11.         String name;
    
12.         int age;
    
13.         public Person(String name,int age){
    
14.                 this.age=age;
    
15.                 this.name=name;
    
16.         }
    
17.         public String toString(){
    
18.                 return name+"@"+age;
    
19.         }
    
20. }
    

复制代码

1. public class Test {
   
2.        
   
3.         public static Person findLuckyPerson(LinkedList<Person> list){
   
4.                 //得到迭代器，指针指向第一个元素的前一个位置
   
5.                 Iterator<Person> iter=list.iterator();
   
6.                 int count=0;   //用于计数
   
7.                 while(list.size()>1){  //当还有多于1个元素时就继续计数
   
8.                         count++;
   
9.                         //通过迭代器调用next方法，指针不断向后面移动，
   
10.                         //每迭代一个元素，表示当前数数的人
    
11.                         Person p=iter.next();  
    
12.                         if(count%3==0)               
    
13.                                 iter.remove();
    
14.                 //如果数数被三整除，就通过迭代器把这个元素从list集合移除去
    
15.                         if(!iter.hasNext()){//判断迭代器是否走到集合的末尾
    
16.                                 iter=list.iterator();
    
17.                 //如果迭代器访问完一遍list集合，就生成新的指向list第一个元素前面一个的迭代器
    
18.                 //该迭代器下次调用next方法就是上一轮结束后最前面的人
    
19.                         }
    
20.                 }
    
21.                 return list.get(0);               
    
22.         }
    

复制代码

1. public static void main(String[] args) {
   
2.                 Person p1=new Person("大毛",7);
   
3.                 Person p2=new Person("二毛",7);
   
4.                 Person p3=new Person("三毛",7);
   
5.                 Person p4=new Person("四毛",7);
   
6.                 Person p5=new Person("五毛",7);
   
7.                
   
8.                 //Vector的使用
   
9.                 //Vector也可以获取枚举对象，也可通过iterator()方法获取Iterator迭代对象
   
10.                 System.out.println("Vector的使用:");
    
11.                 Vector<Person> v=new Vector<Person>();
    
12.                 v.add(p1);
    
13.                 v.add(p2);
    
14.                 v.add(p3);
    
15.                 v.add(p4);
    
16.                 v.add(p5);
    
17.                 Enumeration<Person> enu=v.elements();               
    
18.                 while(enu.hasMoreElements()){
    
19.                         System.out.println(enu.nextElement());
    
20.                 }
    
21.                
    
22.                 //ArrayList的使用
    
23.                 //ArrayList没有elements方法来获取Enumeration枚举对象
    
24.                 System.out.println("ArrayList的使用:");
    
25.                 ArrayList<Person> arr=new ArrayList<Person>();
    
26.                 arr.add(p1);
    
27.                 arr.add(p2);
    
28.                 arr.add(p3);
    
29.                 arr.add(p4);
    
30.                 arr.add(p5);
    
31.                 Iterator<Person> iter=arr.iterator();
    
32.                 while(iter.hasNext()){
    
33.                         System.out.println(iter.next());
    
34.                 }
    
35.                
    
36.                 //LinkedList的使用
    
37.                 //实现一个小程序，让5个从1到4依次编号孩子手拉手排成一个圈，从1开始依次报数，
    
38.                 //报到可以被3整除的孩子出列，问最后剩下的孩子的编号是多少号？
    
39.                 //分析：5个孩子排个圈，可以用LikedList来做
    
40.                 System.out.println("LinkedList的使用:");
    
41.                 LinkedList<Person> link=new LinkedList<Person>();
    
42.                 link.add(p1);
    
43.                 link.add(p2);
    
44.                 link.add(p3);
    
45.                 link.add(p4);
    
46.                 link.add(p5);
    
47.                 System.out.println(findLuckyPerson(link));
    
48.         }
    
49. }
    

复制代码

不错 谢谢分享

明白啦，原来是每次迭代器指针走到最后时，再让指针从头开始走。
但是ArrayList不是也一样可以求解问题吗，为什么偏要用LinkedList集合呢？