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和迭代器便于访问链接存储。