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