java中三種for循環之間的對比

普通for循環語法：

for (int i = 0; i < integers.length; i++) {  
    System.out.println(intergers[i]);  
}  

foreach 循環語法：

for(Integer in : integers){  
    System.out.println(in);  
}  

今天我們來比較一下兩種for循環對ArrayList和LinkList集合的循環性能比較。首先簡單的了解一下ArrayList和LinkList的區別：

ArrayList：ArrayList是采用數組的形式保存對象的，這種方式將對象放在連續的內存塊中，所以插入和刪除時比較麻煩，查詢比較方便。

LinkList：LinkList是將對象放在獨立的空間中，而且每個空間中還保存下一個空間的索引，也就是數據結構中的鏈表結構，插入和刪除比較方便，但是查找很麻煩，要從第一個開始遍歷。

 

下面是我測試的代碼：

package cn.migu.newportal.activity.service.activity;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 *
 * @author 
 * @version C10 2017年11月30日
 * @since SDP V300R003C10
 */
public class Test
{
    public static void main(String[] args)
    {
        
        // 實例化arrayList
        List<Integer> arrayList = new ArrayList<Integer>();
        // 實例化linkList
        List<Integer> linkList = new LinkedList<Integer>();
        
        // 插入10萬條數據
        for (int i = 0; i < 100000; i++)
        {
            arrayList.add(i);
            linkList.add(i);
        }
        
        int array = 0;
        // 用for循環arrayList
        long arrayForStartTime = System.currentTimeMillis();
        for (int i = 0; i < arrayList.size(); i++)
        {
            array = arrayList.get(i);
        }
        long arrayForEndTime = System.currentTimeMillis();
        System.out.println("用for循環arrayList 10萬次花費時間：" + (arrayForEndTime - arrayForStartTime) + "毫秒");
        
        // 用foreach循環arrayList
        long arrayForeachStartTime = System.currentTimeMillis();
        for (Integer in : arrayList)
        {
            array = in;
        }
        long arrayForeachEndTime = System.currentTimeMillis();
        System.out.println("用foreach循環arrayList 10萬次花費時間：" + (arrayForeachEndTime - arrayForeachStartTime) + "毫秒");
        
        // 用for循環linkList
        long linkForStartTime = System.currentTimeMillis();
        int link = 0;
        for (int i = 0; i < linkList.size(); i++)
        {
            link = linkList.get(i);
        }
        long linkForEndTime = System.currentTimeMillis();
        System.out.println("用for循環linkList 10萬次花費時間：" + (linkForEndTime - linkForStartTime) + "毫秒");
        
        // 用froeach循環linkList
        long linkForeachStartTime = System.currentTimeMillis();
        for (Integer in : linkList)
        {
            link = in;
        }
        long linkForeachEndTime = System.currentTimeMillis();
        System.out.println("用foreach循環linkList 10萬次花費時間：" + (linkForeachEndTime - linkForeachStartTime) + "毫秒");
    }
}

循環10萬次的時候，控制台打印結果：  （結果每次都會變，但求個平均值還是可以分析出結果的）

用for循環arrayList 10萬次花費時間：6毫秒
用foreach循環arrayList 10萬次花費時間：7毫秒
用for循環linkList 10萬次花費時間：20489毫秒
用foreach循環linkList 10萬次花費時間：8毫秒

 

 

可以看出，循環ArrayList時，普通for循環比foreach循環花費的時間要少一點；循環LinkList時，普通for循環比foreach循環花費的時間要多很多。

 

當我將循環次數提升到一百萬次的時候，循環ArrayList，普通for循環還是比foreach要快一點；但是普通for循環在循環LinkList時，程序直接卡死。

 

結論：需要循環數組結構的數據時，建議使用普通for循環，因為for循環采用下標訪問，對於數組結構的數據來說，采用下標訪問比較好。

需要循環鏈表結構的數據時，一定不要使用普通for循環，這種做法很糟糕，數據量大的時候有可能會導致系統崩潰。

 

 

網上參考一種代碼更緊湊的寫法：

 

實體Person類

package cn.migu.newportal.activity.service.activity;

/**
 *
 * @author 
 * @version C10 2017年11月30日
 * @since SDP V300R003C10
 */
public class Person
{
    private String a;
    
    private int b;
    
    public Person(String a, int b)
    {
        super();
        this.a = a;
        this.b = b;
    }
    
    public String getA()
    {
        return a;
    }
    
    public void setA(String a)
    {
        this.a = a;
    }
    
    public int getB()
    {
        return b;
    }
    
    public void setB(int b)
    {
        this.b = b;
    }
    
}

測試ArrayList的主程序：

package com.zhang.loop;  
  
import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.LinkedList;  
import java.util.List;  
  
public class TestArrayList {  
    private static final int COUNT = 800000;  
    private static List<Person> persons = new ArrayList<Person>();  
      
    public static void main(String[] args) {  
        init();  
        System.out.println("for循環測試結果："+testFor());  
        System.out.println("foreach循環測試結果："+testForeach());  
        System.out.println("iterator循環測試結果："+testIterator());  
    }  
      
    //初始化集合  
    public static void init(){  
        for (int i = 0; i <COUNT; i++) {  
            persons.add(new Person("第"+i+"個元素",i));  
        }  
    }  
    //for循環便利集合  
    public static long testFor(){  
        long start = System.nanoTime();  
        Person p = null;  
        for (int i = 0; i < persons.size(); i++) {  
            p = persons.get(i);  
        }  
        return (System.nanoTime()-start)/1000;  
    }  
    //foreach循環便利集合  
    public static long testForeach(){  
        long start = System.nanoTime();  
        Person p = null;  
        for (Person person : persons) {  
            p = person;  
        }  
        return (System.nanoTime()-start)/1000;  
    }  
    //iterator循環便利集合  
    public static long testIterator(){  
        long start = System.nanoTime();  
        Person p = null;  
        Iterator<Person> itreator = persons.iterator();  
        while(itreator.hasNext()){  
            p = itreator.next();  
        }  
        return (System.nanoTime()-start)/1000;  
    }  
      
}  

ArrayList測試結果：

測試LinkedList的主程序：

package com.zhang.loop;  
  
import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.LinkedList;  
import java.util.List;  
  
public class TestArrayList {  
    private static final int COUNT = 8000;  
    private static List<Person> persons = new LinkedList<Person>();  
      
    public static void main(String[] args) {  
        init();  
        System.out.println("for循環測試結果："+testFor());  
        System.out.println("foreach循環測試結果："+testForeach());  
        System.out.println("iterator循環測試結果："+testIterator());  
    }  
      
    //初始化集合  
    public static void init(){  
        for (int i = 0; i <COUNT; i++) {  
            persons.add(new Person("第"+i+"個元素",i));  
        }  
    }  
    //for循環便利集合  
    public static long testFor(){  
        long start = System.nanoTime();  
        Person p = null;  
        for (int i = 0; i < persons.size(); i++) {  
            p = persons.get(i);  
        }  
        return (System.nanoTime()-start)/1000;  
    }  
    //foreach循環便利集合  
    public static long testForeach(){  
        long start = System.nanoTime();  
        Person p = null;  
        for (Person person : persons) {  
            p = person;  
        }  
        return (System.nanoTime()-start)/1000;  
    }  
    //iterator循環便利集合  
    public static long testIterator(){  
        long start = System.nanoTime();  
        Person p = null;  
        Iterator<Person> itreator = persons.iterator();  
        while(itreator.hasNext()){  
            p = itreator.next();  
        }  
        return (System.nanoTime()-start)/1000;  
    }  
      
}  

LinkedList測試結果：

記錄的存取方式有兩種：

             一種是順序存儲（數組，ArrayList..）可以根據其下標找到對應的記錄

            另一種是鏈接存儲(LinkedList..)鏈接存儲(拿單鏈表為例)則必須找到其前一個記錄的位置才能夠找到本記錄。

 

根據以上可以得到的結果是：for循環便於訪問順序存儲的記錄，而foreach和迭代器便於訪問鏈接存儲。