Java Collections Framework(JCF) 是Java SE中一个基本的类集,几乎所有的项目都会用到,其中的List 则是JCF中最最常用的一个接口。围绕List 接口,有很多实现,诸如常用的ArrayList 、LinkedList 、Vector 、Stack ,还有Java5之后引入的CopyOnWriteArrayList ,也有不少List 的开源实现,如Apache commons-collections中的各类List
这么多的List 实现,如何选择?他们的运行效率具体怎样?本篇文章将用具体的代码来检测其中最最常用的一些List 实现
主要测试对象:
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顺序迭代
1.6for顺序迭代
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
测试代码:
测试结果:
-----------------------Test List Performance: loop=100000-----------------------
add insert remove get set iterator for
FastArrayList 31 16344 16312 47 62 0 0
TreeList 156 391 281 109 110 15 0
ArrayList 47 16406 16500 16 47 16 0
LinkedList 15 149719 264203 176125 179406 0 31
CopyOnWriteArrayList 27422 141797 160906 31 65375 0 0
Vector 16 26391 24437 31 47 16 0
Stack 31 25094 22703 31 16 16 0
--------------------Test List sort Performance: loop=100000---------------------
optimize worst random
FastArrayList 31 78 188
TreeList 32 94 343
ArrayList 16 94 172
LinkedList 16 266 219
Vector 15 78 219
Stack 15 94 156
-------------------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
结论:
1.随机插入、随机删除操作中,用TreeList 效率最高;
2.在只需要追加、迭代的环境下,LinkedList 效率最高;
3.平均效率来讲,ArrayList 相对平衡,但如果海量随机操作,还是会造成性能瓶颈;
4.CopyOnWriteArrayList 因为线程安全的原因,致使性能降低很多,所以慎用;
5.Vector 没有传说中那么低的效率;
6.让Stack 来做List 的事可以,不过语义上Stack 不应该做过多的List 的事情;
7.在排序中,ArrayList 具有最好的性能,TreeList 平均性能也不错,LinkedList 的排序效率受元素初始状态的影响很大。
8.各种List 间转换几乎没有时间损耗。
注:增强性for循环其实是对iterator循环的一种简单写法,在编译时增强性for循环会被编译为iterator的for循环写法。在测试结果中两者变现出来的性能有一点相差(不正确,有时变现的快,有时变现的慢一点,可能与其他因素有关系),从理论上说,应该基本一样。
引用地址:http://ldbjakyo.iteye.com/blog/1142899
http://blog.sina.com.cn
这么多的List 实现,如何选择?他们的运行效率具体怎样?本篇文章将用具体的代码来检测其中最最常用的一些List 实现
主要测试对象:
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顺序迭代
1.6for顺序迭代
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
测试代码:
- import static java.lang.System.out;
- import java.util.ArrayList;
- import java.util.Collections;
- import java.util.Iterator;
- import java.util.LinkedList;
- import java.util.List;
- import java.util.Stack;
- import java.util.Vector;
- import java.util.concurrent.CopyOnWriteArrayList;
- import org.apache.commons.collections.FastArrayList;
- import org.apache.commons.collections.list.TreeList;
- import org.apache.commons.lang.StringUtils;
- import org.apache.commons.lang.time.StopWatch;
- @SuppressWarnings("unchecked")
- public class ListPerformance {
- public static void main(String[] args) {
- ListPerformance test = new ListPerformance(10 * 10000);
- out.print(StringUtils.center("Test List Performance: loop=" + test.loop, 80, '-'));
- out.printf("\n ssssssss", "", "add", "insert", "remove", "get", "set",
- "iterator","for");
- test.benchmark(new FastArrayList());
- test.benchmark(new TreeList());
- test.benchmark(new ArrayList());
- test.benchmark(new LinkedList());
- test.benchmark(new CopyOnWriteArrayList());
- test.benchmark(new Vector());
- test.benchmark(new Stack());
- //2.测试排序
- out.print("\n\n");
- out.print(StringUtils.center("Test List sort Performance: loop=" + test.loop, 80, '-'));
- out.printf("\n ssss", "", "optimize", "worst", "random");
- test.benchmarkSort(new FastArrayList());
- test.benchmarkSort(new TreeList());
- test.benchmarkSort(new ArrayList());
- test.benchmarkSort(new LinkedList());
- //test.benchmarkSort(new CopyOnWriteArrayList());//UnsupportedOperationException
- test.benchmarkSort(new Vector());
- test.benchmarkSort(new Stack());
- //3.测试各种数据结构间转化
- out.print("\n\n");
- out.print(StringUtils.center("Test List convert Performance: loop=" + test.loop, 80, '-'));
- out.printf("\n ssssss", "", "Tree", "Array", "Linked", "CopyOnWrite",
- "Vector");
- test.benchmarkConvert(new FastArrayList());
- test.benchmarkConvert(new TreeList());
- test.benchmarkConvert(new ArrayList());
- test.benchmarkConvert(new LinkedList());
- test.benchmarkConvert(new CopyOnWriteArrayList());
- }
- private int loop = 10000;
- public ListPerformance(int loop) {
- this.loop = loop;
- }
- public void benchmark(List list) {
- out.printf("\n s", list.getClass().getSimpleName());
- int j;
- StopWatch watch = null;
- //1.测试顺序性能(Add)
- (watch = new StopWatch()).start();
- for (int i = 0; i < loop; i++) {
- list.add(new Integer(i));
- }
- watch.stop();
- out.printf("d", watch.getTime());
- //2.测试随机插入性能(Random insert)
- (watch = new StopWatch()).start();
- for (int i = 0; i < loop; i++) {
- j = (int) (Math.random() * loop);
- list.add(j, new Integer(-j));
- }
- watch.stop();
- out.printf("d", watch.getTime());
- //3.测试随机索引删除(Random remove)
- (watch = new StopWatch()).start();
- for (int i = 0; i < loop; i++) {
- j = (int) (Math.random() * loop);
- list.remove(j);
- }
- watch.stop();
- out.printf("d", watch.getTime());
- //4.测试随机取数性能(Random get)
- (watch = new StopWatch()).start();
- for (int i = 0; i < loop; i++) {
- j = (int) (Math.random() * loop);
- list.get(j);
- }
- watch.stop();
- out.printf("d", watch.getTime());
- //5.测试随机更新性能(Random set)
- (watch = new StopWatch()).start();
- for (int i = 0; i < loop; i++) {
- j = (int) (Math.random() * loop);
- list.set(j, j);
- }
- watch.stop();
- out.printf("d", watch.getTime());
- //6.测试迭代性能(Iterator)
- (watch = new StopWatch()).start();
- Iterator<Object> iter = list.iterator();
- while (iter.hasNext()) {
- iter.next();
- }
- watch.stop();
- out.printf("d", watch.getTime());
- //7.测试迭代性能(Iterator)
- (watch = new StopWatch()).start();
- // Iterator<Object> iter = list.iterator();
- for (Object obj : list) {
- }
- watch.stop();
- out.printf("d", watch.getTime());
- }
- public void benchmarkConvert(List list) {
- out.printf("\n s", list.getClass().getSimpleName());
- StopWatch watch = null;
- //1.转TreeList
- (watch = new StopWatch()).start();
- new TreeList(list);
- watch.stop();
- out.printf("d", watch.getTime());
- //2.转ArrayList
- (watch = new StopWatch()).start();
- new ArrayList(list);
- watch.stop();
- out.printf("d", watch.getTime());
- //3.转LinkedList
- (watch = new StopWatch()).start();
- new LinkedList(list);
- watch.stop();
- out.printf("d", watch.getTime());
- //4.转CopyOnWriteArrayList
- (watch = new StopWatch()).start();
- new CopyOnWriteArrayList(list);
- watch.stop();
- out.printf("d", watch.getTime());
- //5.转Vector
- (watch = new StopWatch()).start();
- new Vector(list);
- watch.stop();
- out.printf("d", watch.getTime());
- }
- public void benchmarkSort(List list) {
- out.printf("\n s", list.getClass().getSimpleName());
- StopWatch watch = null;
- //1.顺序List
- for (int i = 0; i < loop; i++) {
- list.add(new Integer(i));
- }
- (watch = new StopWatch()).start();
- Collections.sort(list);
- watch.stop();
- out.printf("d", watch.getTime());
- //2.逆序List
- for (int i = loop - 1; i > 0; i--) {
- list.add(new Integer(i));
- }
- (watch = new StopWatch()).start();
- Collections.sort(list);
- watch.stop();
- out.printf("d", watch.getTime());
- //3.随机顺序List
- for (int i = 0, j = 0; i < loop; i++) {
- j = (int) (Math.random() * loop);
- list.add(new Integer(j));
- }
- (watch = new StopWatch()).start();
- Collections.sort(list);
- watch.stop();
- out.printf("d", watch.getTime());
- }
- }
测试结果:
-----------------------Test List Performance: loop=100000-----------------------
add insert remove get set iterator for
FastArrayList 31 16344 16312 47 62 0 0
TreeList 156 391 281 109 110 15 0
ArrayList 47 16406 16500 16 47 16 0
LinkedList 15 149719 264203 176125 179406 0 31
CopyOnWriteArrayList 27422 141797 160906 31 65375 0 0
Vector 16 26391 24437 31 47 16 0
Stack 31 25094 22703 31 16 16 0
--------------------Test List sort Performance: loop=100000---------------------
optimize worst random
FastArrayList 31 78 188
TreeList 32 94 343
ArrayList 16 94 172
LinkedList 16 266 219
Vector 15 78 219
Stack 15 94 156
-------------------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
结论:
1.随机插入、随机删除操作中,用TreeList 效率最高;
2.在只需要追加、迭代的环境下,LinkedList 效率最高;
3.平均效率来讲,ArrayList 相对平衡,但如果海量随机操作,还是会造成性能瓶颈;
4.CopyOnWriteArrayList 因为线程安全的原因,致使性能降低很多,所以慎用;
5.Vector 没有传说中那么低的效率;
6.让Stack 来做List 的事可以,不过语义上Stack 不应该做过多的List 的事情;
7.在排序中,ArrayList 具有最好的性能,TreeList 平均性能也不错,LinkedList 的排序效率受元素初始状态的影响很大。
8.各种List 间转换几乎没有时间损耗。
注:增强性for循环其实是对iterator循环的一种简单写法,在编译时增强性for循环会被编译为iterator的for循环写法。在测试结果中两者变现出来的性能有一点相差(不正确,有时变现的快,有时变现的慢一点,可能与其他因素有关系),从理论上说,应该基本一样。
引用地址:http://ldbjakyo.iteye.com/blog/1142899
http://blog.sina.com.cn