比如有如下代码
                      List list = new ArrayList();
                list.add("a");
                list.add("b");
                list.add("c");
                //方式一:
                Iterator it = list.iterator();
                while(it.hasNext()){
                        String s = (String) it.next();
                        //处理数据
                }
                //方式二;
                for(Iterator ite =list.iterator();ite.hasNext();){
                        String s = (String) ite.next();
                        //处理数据
                }

问题一:两种方式效率上是否一样,要是不一样,哪一个效率更高,为什么?
问题二:一般我们在什么场景运用这两个不同的方式?

一般我都用第二种,但是不知道为什么比第一种好?

这只是一种情况吧哥们。假如说我有一个学生类，要求你用集合并使用泛型修饰，将学生这个类传进去，那你的第二种情况还效率高吗？
  两种不一样，一般在我下面的这种情况下用的是高效率的
  public static void main(String[] args) {
               Map<Mouse,Cat>  map=new TreeMap<Mouse,Cat>();
                Cat anim=new Cat("234", 23);
                Cat cat=new  Cat("322", 12);
               Mouse mou=new  Mouse("ww", 43);
               Mouse mou1=new Mouse("fw", 23);
               map.put(mou1, cat);
               map.put(mou, anim);
               Set<Entry<Mouse, Cat>> kets=map.entrySet();
               Iterator<Entry<Mouse, Cat>> it=kets.iterator();
               while(it.hasNext()){
                       Entry<Mouse, Cat> ca=it.next();
                       Set<Mouse> mo=(Set<Mouse>) ca.getKey();
                     Iterator<Mouse> s= mo.iterator();
                        while(s.hasNext()){
                                Mouse mouse=s.next();
                                System.out.println(mouse.getAge()+","+mouse.getName());
                   
                                 Set<Cat> e=(Set<Cat>) ca.getKey();
                                 Iterator<Cat> ss= e.iterator();
                                 while(ss.hasNext()){
                                         Cat vt=map.get(mouse);
                                         System.out.println(vt.getAge()+","+vt.getName());
                                 }
                                 
                        }
                             
                          
                      }
                     

        }
}

class Mouse{
        private String name;
        private int age;

       
    Mouse(String name,int age){
                this.name=name; this.age=age;
                }
        public void getSong(String belongid){
                System.out.println("被猫咪咬过之后老鼠的声音是"+belongid);
        }
        public void setName(String name){
                this.name=name;
        }
        public String getName(){
                return name;
        }
        public void setAge(int age){
                this.age=age;
        }
        public int getAge(){
                return age;
        }
        @Override
        public String toString() {
                // TODO Auto-generated method stub
                return name+","+age;
        }
}
class Cat {
         String name;
       int age;
        Cat(String name,int age)
           {
                this.name=name;
                this.age=age;
                }
public void Animal(String name,int age){
                this.name=name;
                this.age=age;

        }
        public void getSong(String name,int age){
                System.out.println(name+"的年龄"+age+"，他的叫声是这个声音还行吧！");
               
        }
        public void setName(String name){
                this.name=name;
        }
        public String getName(){
                return name;
        }
        public void setAge(int age){
                this.age=age;
        }
        public int getAge(){
                return age;
        }

        @Override
        public String toString() {
                // TODO Auto-generated method stub
                return name+","+age;
        }
}
如果你可以理解，就改改这个代码，他就是你没有考虑到的情况

两种方式的效率差不多，但在内存上有点区别。
对于while循环，迭代器的定义Iterator it = list.iterator();是在while循环外，所以当循环结束后引用it还在内存中。
而在for循环中，迭代器的定义Iterator ite= list.iterator();是在for循环内，是局部变量，当for循环结束后就没有了。所以建议用for循环

//方式一:
                Iterator it = list.iterator(); //it指向一个对象，循环结束后it还留在内存中，它在内存中代表对象也在内存中，可这时迭代器已经用完结束了，这就没意义了。
while(it.hasNext()){
                        String s = (String) it.next();
                        //处理数据
                }
                //方式二;
                for(Iterator ite =list.iterator();ite.hasNext();)  //这里的ite是for局部变量，for循环结束后，ite就被释放了。所以出于内存管理的考虑，for循环比较优一些。
{
String s = (String) ite.next();
                        //处理数据
                }

明白了,受教了~~~~

黄珊珊 发表于 2012-8-31 07:09
//方式一:
                Iterator it = list.iterator(); //it指向一个对象，循环结束后it还留在内存中 ...

明白了,谢谢