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