测试发现，ArrayList性能全面超越LinkedList

分别对ArrayList和LinkedList的批量插入、遍历访问、随机访问、随机插入、随机删除进行了性能测试，发现ArrayList的性能居然完胜LinkedList，包括随机插入和删除数据（JDK是1.6），测试结果如下：
时间单位：毫秒
一万条数据测试：
ArrayList中插入10000条数据，共花费：3
LinkedList中插入10000条数据，共花费：5
ArrayList中遍历全部数据，共花费：2
LinkedList中遍历全部数据，共花费：136
ArrayList中随机访问1000数据，共花费：1
LinkedList中随机访问1000数据，共花费：15
ArrayList中随机插入1000数据，共花费：5
LinkedList中随机插入1000数据，共花费：15
ArrayList中随机删除1000数据，共花费：5
LinkedList中随机删除1000数据，共花费：15

十万条数据测试：
ArrayList中插入100000条数据，共花费：18
LinkedList中插入100000条数据，共花费：38
ArrayList中遍历全部数据，共花费：6
LinkedList中遍历全部数据，共花费：12875
ArrayList中随机访问1000数据，共花费：0
LinkedList中随机访问1000数据，共花费：155
ArrayList中随机插入1000数据，共花费：43
LinkedList中随机插入1000数据，共花费：156
ArrayList中随机删除1000数据，共花费：42
LinkedList中随机删除1000数据，共花费：158

百万条数据测试
ArrayList中插入1000000条数据，共花费：186
LinkedList中插入1000000条数据，共花费：435
ArrayList中遍历全部数据，共花费：19
LinkedList在遍历全部数据时，超过10分钟还未遍历完，直接结束程序了

测试代码：

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

public class TestList {
	private static int total = 1000000;
	private static List<Integer> aList = new ArrayList<Integer>();//后面再演示先定义长度的
	private static List<Integer> lList = new LinkedList<Integer>();

	/**
	 * 演示批量插入数据
	 */
	private static void testBatchInsert() {
		Random r = new Random();
		//测试ArrayList
		long beginTime = System.currentTimeMillis();
		for (int i = 0; i < total; i++) {
			aList.add(r.nextInt());//在最后插入数据，使用add()方法
		}
		long endTime = System.currentTimeMillis();
		System.out.println("ArrayList中插入" + total + "条数据，共花费：" + (endTime - beginTime));

		//测试LinkedList
		beginTime = System.currentTimeMillis();
		for (int i = 0; i < total; i++) {
			lList.add(r.nextInt());//在最后插入数据，使用add()方法
		}
		endTime = System.currentTimeMillis();
		System.out.println("LinkedList中插入" + total + "条数据，共花费：" + (endTime - beginTime));
	}

	/**
	 * 测试遍历访问全部数据
	 */
	private static void testTraverseAccess() {
		//测试ArrayList
		long beginTime = System.currentTimeMillis();
		for (int i = 0; i < aList.size(); i++) {
			aList.get(i);//通过get(int i)方法获得
		}
		long endTime = System.currentTimeMillis();
		System.out.println("ArrayList中遍历全部数据，共花费：" + (endTime - beginTime));

		//测试LinkedList
		beginTime = System.currentTimeMillis();
		for (int i = 0; i < lList.size(); i++) {
			lList.get(i);//通过get(int i)方法获得
		}
		endTime = System.currentTimeMillis();
		System.out.println("LinkedList中遍历全部数据，共花费：" + (endTime - beginTime));
	}

	/**
	 * 测试随机访问数据
	 */
	private static void testRandomAccess() {
		int num = 1000;
		Random r = new Random();

		//测试ArrayList
		long beginTime = System.currentTimeMillis();
		for(int i = 0; i < num; i++) {
			aList.get(r.nextInt(aList.size()));
		}
		long endTime = System.currentTimeMillis();
		System.out.println("ArrayList中随机访问" + num + "数据，共花费：" + (endTime - beginTime));

		//测试LinkedList
		beginTime = System.currentTimeMillis();
		for(int i = 0; i < num; i++) {
			lList.get(r.nextInt(aList.size()));
		}
		endTime = System.currentTimeMillis();
		System.out.println("LinkedList中随机访问" + num + "数据，共花费：" + (endTime - beginTime));
	}

	/**
	 * 演示随机插入数据
	 */
	private static void testRandomInsert() {
		int num = 1000;
		Random r = new Random();

		//测试ArrayList
		long beginTime = System.currentTimeMillis();
		for(int i = 0; i < num; i++) {
			//通过list.add(int index, Integer element)在指定位置插入数据
			aList.add(r.nextInt(aList.size()), r.nextInt());
		}
		long endTime = System.currentTimeMillis();
		System.out.println("ArrayList中随机插入" + num + "数据，共花费：" + (endTime - beginTime));

		//测试LinkedList
		beginTime = System.currentTimeMillis();
		for(int i = 0; i < num; i++) {
			//通过list.add(int index, Integer element)在指定位置插入数据
			lList.add(r.nextInt(lList.size()), r.nextInt());
		}
		endTime = System.currentTimeMillis();
		System.out.println("LinkedList中随机插入" + num + "数据，共花费：" + (endTime - beginTime));
	}

	/**
	 * 演示随机删除数据
	 */
	private static void testRandomDelete() {
		int num = 1000;
		Random r = new Random();

		//测试ArrayList
		long beginTime = System.currentTimeMillis();
		for(int i = 0; i < num; i++) {
			//通过list.remove(int index)在指定位置删除数据
			aList.remove(r.nextInt(aList.size()));
		}
		long endTime = System.currentTimeMillis();
		System.out.println("ArrayList中随机删除" + num + "数据，共花费：" + (endTime - beginTime));

		//测试LinkedList
		beginTime = System.currentTimeMillis();
		for(int i = 0; i < num; i++) {
			//通过list.remove(int index)在指定位置删除数据
			lList.remove(r.nextInt(lList.size()));
		}
		endTime = System.currentTimeMillis();
		System.out.println("LinkedList中随机删除" + num + "数据，共花费：" + (endTime - beginTime));
	}

	public static void main(String[] args) {
		testBatchInsert();
		testTraverseAccess();
		testRandomAccess();
		testRandomInsert();
		testRandomDelete();
	}
}