java list 效率_Java中List效率的比较

Java Collections Framework(JCF)是Java SE中一个基本的类集，几乎所有的项目都会用到，其中的List则是JCF中最最常用的一个接口。围绕List接口，有很多实现，诸如常用的ArrayList、LinkedList、Vector、Stack，还有Java5之后引入的CopyOnWriteArrayList，也有不少List的开源实现，如Apache commons-collections中的各类List。

这么多的List 实现，如何选择？他们的运行效率具体怎样？本篇文章将用具体的代码来检测其中最最常用的一些List 实现。

测试环境：

处理器：Intel Core 2 Duo P8600 2.4GHz

内存：2G

硬盘：160G 7200rpm

Java：SUN JDK 1.6.0_15

开发环境：Eclipse 3.5

第三方类库：Apache commons-lang 2.4、Apache commons-collections 3.2.1

主要测试对象：

java.util.ArrayList;

java.util.LinkedList;

java.util.Stack;

java.util.Vector;

java.util.concurrent.CopyOnWriteArrayList;

org.apache.commons.collections.FastArrayList;

org.apache.commons.collections.list.TreeList;

测试用例：

1.测试List

1.1顺序添加

1.2随机插入

1.3随机删除

1.4随机访问

1.5随机更新

1.5顺序迭代

2.测试List 在三种情况下的排序效率

2.1初始时List 中元素已从小到大有序排列(最优情况)

2.2初始时List 中元素已从大到小有序排列(最差情况)

2.3初始时List 中元素随机排列，无序

3.测试List 互相转换的效率

3.1转化为TreeList

3.2转化为ArrayList

3.3转化为LinkedList

3.4转化为CopyOnWriteArrayList

3.5转化为Vector

测试代码：

packagetest;import staticjava.lang.System.out;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Iterator;importjava.util.LinkedList;importjava.util.List;importjava.util.Stack;importjava.util.Vector;importjava.util.concurrent.CopyOnWriteArrayList;importorg.apache.commons.collections.FastArrayList;importorg.apache.commons.collections.list.TreeList;importorg.apache.commons.lang.StringUtils;importorg.apache.commons.lang.time.StopWatch;

@SuppressWarnings("unchecked")public classListPerformance {public static voidmain(String[] args) {

ListPerformance test= new ListPerformance(10 * 10000);

out.print(StringUtils.center("Test List Performance: loop=" + test.loop, 80, '-'));

out.printf("/n%20s%10s%10s%10s%10s%10s%10s", "", "add", "insert", "remove", "get", "set","iterator");

test.benchmark(newFastArrayList());

test.benchmark(newTreeList());

test.benchmark(newArrayList());

test.benchmark(newLinkedList());

test.benchmark(newCopyOnWriteArrayList());

test.benchmark(newVector());

test.benchmark(newStack());//2.测试排序

out.print("/n/n");

out.print(StringUtils.center("Test List sort Performance: loop=" + test.loop, 80, '-'));

out.printf("/n%20s%10s%10s%10s", "", "optimize", "worst", "random");

test.benchmarkSort(newFastArrayList());

test.benchmarkSort(newTreeList());

test.benchmarkSort(newArrayList());

test.benchmarkSort(newLinkedList());//test.benchmarkSort(new CopyOnWriteArrayList());//UnsupportedOperationException

test.benchmarkSort(newVector());

test.benchmarkSort(newStack());//3.测试各种数据结构间转化

out.print("/n/n");

out.print(StringUtils.center("Test List convert Performance: loop=" + test.loop, 80, '-'));

out.printf("/n%20s%10s%10s%10s%10s%10s", "", "Tree", "Array", "Linked", "CopyOnWrite","Vector");

test.benchmarkConvert(newFastArrayList());

test.benchmarkConvert(newTreeList());

test.benchmarkConvert(newArrayList());

test.benchmarkConvert(newLinkedList());

test.benchmarkConvert(newCopyOnWriteArrayList());

}/**测试循环次数*/

private int loop = 10000;public ListPerformance(intloop) {this.loop =loop;

}public voidbenchmark(List list) {

out.printf("/n%20s", list.getClass().getSimpleName());intj;

StopWatch watch= null;//1.测试顺序性能(Add)

(watch = newStopWatch()).start();for (int i = 0; i < loop; i++) {

list.add(newInteger(i));

}

watch.stop();

out.printf("%10d", watch.getTime());//2.测试随机插入性能(Random insert)

(watch = newStopWatch()).start();for (int i = 0; i < loop; i++) {

j= (int) (Math.random() *loop);

list.add(j,new Integer(-j));

}

watch.stop();

out.printf("%10d", watch.getTime());//3.测试随机索引删除(Random remove)

(watch = newStopWatch()).start();for (int i = 0; i < loop; i++) {

j= (int) (Math.random() *loop);

list.remove(j);

}

watch.stop();

out.printf("%10d", watch.getTime());//4.测试随机取数性能(Random get)

(watch = newStopWatch()).start();for (int i = 0; i < loop; i++) {

j= (int) (Math.random() *loop);

list.get(j);

}

watch.stop();

out.printf("%10d", watch.getTime());//5.测试随机更新性能(Random set)

(watch = newStopWatch()).start();for (int i = 0; i < loop; i++) {

j= (int) (Math.random() *loop);

list.set(j, j);

}

watch.stop();

out.printf("%10d", watch.getTime());//6.测试迭代性能(Iterator)

(watch = newStopWatch()).start();

Iterator iter =list.iterator();while(iter.hasNext()) {

iter.next();

}

watch.stop();

out.printf("%10d", watch.getTime());

}public voidbenchmarkConvert(List list) {

out.printf("/n%20s", list.getClass().getSimpleName());

StopWatch watch= null;//1.转TreeList

(watch = newStopWatch()).start();newTreeList(list);

watch.stop();

out.printf("%10d", watch.getTime());//2.转ArrayList

(watch = newStopWatch()).start();newArrayList(list);

watch.stop();

out.printf("%10d", watch.getTime());//3.转LinkedList

(watch = newStopWatch()).start();newLinkedList(list);

watch.stop();

out.printf("%10d", watch.getTime());//4.转CopyOnWriteArrayList

(watch = newStopWatch()).start();newCopyOnWriteArrayList(list);

watch.stop();

out.printf("%10d", watch.getTime());//5.转Vector

(watch = newStopWatch()).start();newVector(list);

watch.stop();

out.printf("%10d", watch.getTime());

}public voidbenchmarkSort(List list) {

out.printf("/n%20s", list.getClass().getSimpleName());

StopWatch watch= null;//1.顺序List

for (int i = 0; i < loop; i++) {

list.add(newInteger(i));

}

(watch= newStopWatch()).start();

Collections.sort(list);

watch.stop();

out.printf("%10d", watch.getTime());//2.逆序List

for (int i = loop - 1; i > 0; i--) {

list.add(newInteger(i));

}

(watch= newStopWatch()).start();

Collections.sort(list);

watch.stop();

out.printf("%10d", watch.getTime());//3.随机顺序List

for (int i = 0, j = 0; i < loop; i++) {

j= (int) (Math.random() *loop);

list.add(newInteger(j));

}

(watch= newStopWatch()).start();

Collections.sort(list);

watch.stop();

out.printf("%10d", watch.getTime());

}

}

测试结果：

-----------------------Test List Performance: loop=100000-----------------------

add insert remove get set iterator

FastArrayList 16 8609 8360 15 47 0

TreeList 110 187 156 47 110 78

ArrayList 15 8313 8344 0 15 0

LinkedList 47 50110 80671 59016 55391 78

CopyOnWriteArrayList 54016 484003 370891 16 105406 0

Vector 15 8266 8328 0 16 0

Stack 31 8281 8266 0 16 0

--------------------Test List sort Performance: loop=100000---------------------

结论：

1.随机插入、随机删除操作中，用TreeList 效率最高；

2.在只需要追加、迭代的环境下，LinkedList 效率最高；

3.平均效率来讲，ArrayList 相对平衡，但如果海量随机操作，还是会造成性能瓶颈；

4.CopyOnWriteArrayList 因为线程安全的原因，致使性能降低很多，所以慎用；

5.Vector 没有传说中那么低的效率；

6.让Stack 来做List 的事可以，不过语义上Stack 不应该做过多的List 的事情；

7.在排序中，ArrayList 具有最好的性能，TreeList 平均性能也不错，LinkedList 的排序效率受元素初始状态的影响很大。

8.各种List 间转换几乎没有时间损耗。

optimize worst random

FastArrayList 47 78 110

TreeList 15 47 110

ArrayList 32 47 78

LinkedList 15 109 125

Vector 0 63 94

Stack 16 46 78

-------------------Test List convert Performance: loop=100000-------------------

Tree Array LinkedCopyOnWrite Vector

FastArrayList 0 0 0 0 0

TreeList 0 0 0 0 0

ArrayList 0 0 0 0 0

LinkedList 0 0 0 0 0

CopyOnWriteArrayList 0 0 0 0 0

原文：http://blog.csdn.net/inkfish/article/details/5185320