遍历ArrayList与LinkedList,使用FOR与迭代器的区别

网上结论：

如果是链表结构的集合，如LinkedList，则使用迭代器遍历，速度会更快(顺序获取)。

如果是数组结构的，如ArrayList，则使用for循环会更快(随机获取)

测试代码：

package com.ckhuang.maven.confused;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
 
/**
 * 验证遍历不同类型集合(基于数组的 and 基于链表的)<br/>
 * FOR 跟 迭代器Iterator 的性能区别
 *
 * @author ck.huang
 *
 */
public class ShowDifForAndIterator {
 
  /**
   * @param args
   */
  public static void main(String[] args) {
    // 集合大小
    int cSize = 80000;
 
    validateArray(cSize);
    System.out.println("==========================================");
    validateLinked(cSize);
  }
 
  private static void validateLinked(int cSize) {
    long insertStart = System.currentTimeMillis();
    LinkedList<Bussiness> list = createLinkedList(cSize);
    long insertEnd = System.currentTimeMillis();
    System.out.println("往 LinkedList 插入 " + cSize + "个对象，耗时：" + (insertEnd - insertStart));
 
    doCompare(list, "LinkedList");
  }
 
  private static void validateArray(int cSize) {
    long insertStart = System.currentTimeMillis();
    ArrayList<Bussiness> list = createArrayList(cSize);
    long insertEnd = System.currentTimeMillis();
    System.out.println("往 ArrayList 插入 " + cSize + "个对象，耗时：" + (insertEnd - insertStart));
 
    doCompare(list, "ArrayList");
  }
 
  private static void doCompare(List<Bussiness> list, String type) {
    long forStart = System.currentTimeMillis();
    doFor(list);
    long forEnd = System.currentTimeMillis();
    System.out.println(type + "(" + list.size() + ") 使用FOR 遍历，耗时：" + (forEnd - forStart));
 
    long linkedStart = System.currentTimeMillis();
    doIterator(list);
    long linkedEnd = System.currentTimeMillis();
    System.out.println(type + "(" + list.size() + ") 使用Iterator遍历，耗时：" + (linkedEnd - linkedStart));
 
  }
 
  private static void doFor(List<Bussiness> list) {
    for (int i = 0; i < list.size(); i++) {
      Bussiness buss = list.get(i);
      buss.doSomething();
    }
  }
 
  private static void doIterator(List<Bussiness> list) {
    Iterator<Bussiness> iterator = list.iterator();
    while (iterator.hasNext()) {
      Bussiness buss = iterator.next();
      buss.doSomething();
    }
  }
 
  public static LinkedList<Bussiness> createLinkedList(int size) {
    LinkedList<Bussiness> list = new LinkedList<Bussiness>();
    for (int i = 0; i < size; i++) {
      list.add(new Bussiness());
    }
    return list;
  }
 
  public static ArrayList<Bussiness> createArrayList(int size) {
    ArrayList<Bussiness> list = new ArrayList<Bussiness>();
    for (int i = 0; i < size; i++) {
      list.add(new Bussiness());
    }
    return list;
  }
 
}
 
class Bussiness {
  public void doSomething() {
    // do nothing..
  }
}

结果：

往 ArrayList 插入 80000个对象，耗时：15

ArrayList(80000) 使用FOR 遍历，耗时：0

ArrayList(80000) 使用Iterator遍历，耗时：16

==========================================

往 LinkedList 插入 80000个对象，耗时：0

LinkedList(80000) 使用FOR 遍历，耗时：14570

LinkedList(80000) 使用Iterator遍历，耗时：16

后记：

1. 相对ArrayList，LinekedList的插入速度更快。

2. ArrayList使用FOR循环遍历，速度更快。

3. LinekedList使用Iterator遍历，速度更快。