Java中List集合的遍历

 一、对List的遍历有三种方式   
    
   List<String>    list    =    new    ArrayList<String>();   
   list.add("testone");   
   list.add(“testtwo”);   
   ...   
    
   第一种:   
   for(Iterator<String>    it    =    list.iterator();    it.hasNext();    )    {   
       ....   
   }   
   这种方式在循环执行过程中会进行数据锁定,    性能稍差,    同时,如果你想在循环过程中去掉某个元素,只能调用it.remove方法,    不能使用list.remove方法,    否则一定出现并发访问的错误.   

    
   第二种:   
   for(String   data    :    list)    {   
       .....   
   }   
   内部调用第一种,    换汤不换药,  因此比Iterator 慢,这种循环方式还有其他限制, 不建议使用它。
    
   第三种:   
   for(int    i=0;    i<list.size();    i++)    {   
       A    a    =    list.get(i);   
       ...   
   }   
   内部不锁定,    效率最高,    但是当写多线程时要考虑并发操作的问题。



二、测试实例
package com.inspur.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 *@author WHD
 *2015-3-5
 */
@SuppressWarnings("unused")
public class MapTest {
    private static List<String> list= new ArrayList<String>();
    public static void main(String[]args){
        MapTest  mapTest = new  MapTest();
        mapTest.initList(list);
        mapTest.foreach(list);
        mapTest.forlist(list);
        mapTest.iteratorList(list);
    }
    
    //list 集合中添加10万条数据
    public List initList(List<String> list){
        int i=0;
        int num=6000000;
        for(i=0;i<num;i++){
            list.add("list"+i);
        }
        return list;
    }
    //list 集合遍历 foreach
    
    public void  foreach(List<String> list){
        long start= System.currentTimeMillis();
        for(String data:list){
            String value=data;
        }
        
        long end=System.currentTimeMillis();
        long count=end-start;
        System.out.println("foreach 循环时间"+count);
    }
    // list集合遍历  for
    public void forlist(List<String> list){
        long start=System.currentTimeMillis();
        int i=0;
        for( i=0;i<list.size();i++){
            String value=list.get(i);
        }
        long end=System.currentTimeMillis();
        long count=end-start;
        System.out.println("for list.size() 遍历时间"+count);
    }
    
    // Iterator 遍历循环
    public void iteratorList(List<String> list){
        long start= System.currentTimeMillis();
        for(Iterator<String>  it=list.iterator();it.hasNext();){
            String value=it.next();
        }
        long end=System.currentTimeMillis();
        long count=end-start;
        System.out.println("iterator 遍历时间"+count);
    }

}


三、测试结果：
（1）、第一次
foreach  遍历时间：55
for list.size()遍历时间：47
iterator 遍历时间：51
（2）、第二次
foreach  遍历时间：54
for list.size()遍历时间：44
iterator 遍历时间：50
（3）、第三次
foreach  遍历时间：48
for list.size()遍历时间：43
iterator 遍历时间：44
从测试的结果我们可以明显的看到效率了！

------------------------------------------------分------------------割-----------------------线---------------------------------------------------

   从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码如下：

[java] view plain copy

1. package com.hisense.tiger.list;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.List;  
6.   
7. public class ListTest {  
8.     public static void main(String[] args)  
9.     {  
10.         List<String> list = new ArrayList<String>();  
11.         long t1,t2;  
12.         for(int j = 0; j < 10000000; j++)  
13.         {  
14.             list.add("aaaaaa" + j);  
15.         }  
16.         System.out.println("List first visit method:");  
17.         t1=System.currentTimeMillis();  
18.         for(String tmp:list)  
19.         {  
20.             //System.out.println(tmp);  
21.         }  
22.         t2=System.currentTimeMillis();  
23.         System.out.println("Run Time:" + (t2 -t1) + "(ms)");  
24.         System.out.println("List second visit method:");  
25.           
26.         t1=System.currentTimeMillis();  
27.         for(int i = 0; i < list.size(); i++)  
28.         {  
29.             list.get(i);  
30.             //System.out.println(list.get(i));  
31.         }  
32.         t2=System.currentTimeMillis();  
33.         System.out.println("Run Time:" + (t2 -t1) + "(ms)");  
34.           
35.         System.out.println("List Third visit method:");  
36.         Iterator<String> iter = list.iterator();  
37.           
38.         t1=System.currentTimeMillis();  
39.         while(iter.hasNext())  
40.         {  
41.             iter.next();  
42.             //System.out.println(iter.next());  
43.         }  
44.         t2=System.currentTimeMillis();  
45.         System.out.println("Run Time:" + (t2 -t1) + "(ms)");  
46.                   
47.         System.out.println("Finished!!!!!!!!");  
48.           
49.           
50.     }  
51. }  

    测试结果如下：

List first visit method:
Run Time:170(ms)
List second visit method:
Run Time:10(ms)
List Third visit method:
Run Time:34(ms)
Finished!!!!!!!!

ArrayList底层是采用数组来保存数据的，对于访问数组里的数据来说，直接采用数组索引当然是最快的了，相当于直接从内存读取数据，其他的两种迭代方式，实际上都是一种，即iterator，foreach包装了一下；iterator遍历最终还是要通过索引来访问数据，源码中对应的get方法了，但是除此之外，还要经过其他的检查，所以耗时较多，但还在一个数量级上