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
测试代码：
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://blog.sina.com.cn
分享到：
相关推荐
Java中List对象的分页思想-按10个或者n个数对list进行分组 Java中List对象的分页思想是一种常用的数据处理技术，通过将一个大的List对象分割成多个小的List对象，每个小的List对象包含一定数量的元素，例如10个或n...
### Java 计算同一 List 中是否有相同值 在 Java 编程中，判断一个 `List` 中是否存在重复元素是一项常见的需求。特别是在数据处理、验证或分析等场景中，确保数据的唯一性对于维持数据完整性至关重要。 #### 核心...
提高 List 转换效率是 Java 开发中非常重要的一方面，本文将讨论如何将 List 转换为逗号分隔的字符串，并提高开发效率。 首先，为什么需要将 List 转换为逗号分隔的字符串？因为在实际开发中，我们经常需要将数据...
本示例涉及的核心知识点是将Java中的List对象与XML文档进行相互转换。这里，我们使用的库是dom4j-1.6.1.jar，这是一个强大的Java XML处理库。 首先，让我们详细了解一下List和XML。List是Java集合框架的一部分，它...
本文将深入分析Java中的List接口及其常见的实现类，如ArrayList、LinkedList和Vector，探讨它们的效率差异和适用场景。 首先，List是Java集合框架中的一个重要接口，它扩展了Collection接口，并规定了元素的有序性...
随机插入、随机删除操作中，用TreeList 效率最高； 2.在只需要追加、迭代的环境下，LinkedList 效率最高； 3.平均效率来讲，ArrayList 相对平衡，但如果海量随机操作，还是会造成性能瓶颈； 4....
在Java编程中，处理Excel文件是一项常见的任务，特别是在数据导入导出、数据分析或者报表生成的场景下。本文将深入探讨如何使用Java来处理Excel，并特别关注如何将List对象导出为Excel文件。 首先，我们需要一个库...
在Java应用中，使用FreeMarker导出Word文档时，经常会遇到列表（list）的嵌套问题，这涉及到数据模型构建、模板设计以及Word文档的格式化。下面我们将详细探讨这个主题。 1. **FreeMarker简介** FreeMarker是一个...
在Java编程中，对List进行多个排序和查询条件的处理是一项常见的任务，特别是在处理数据集合时。本篇文章将深入探讨如何使用Java实现这些操作，并基于给出的`GroupFilterSortUtils.java`文件，我们可以推断这是一个...
在Java编程中，将List集合数据导出到Excel表格是一个常见的需求，特别是在数据分析、报表生成或数据导出等场景。本实例提供了一个通用工具类，能够处理多种不同类型的对象集合，实现了最大化的通用性，使得开发者...
"javaList用法详解" Java 中的 List 用法是指在 Java 编程语言中使用 List 集合的方法和实现方式。List 集合是 Java 中的一种常用的集合类型，提供了许多实用的方法和实现类，下面将详细介绍 List 用法和实例。 ...
在Java编程语言中，List接口是集合框架的重要组成部分，它属于Collection接口的子接口。List接口主要用于存储有序的、可重复的元素序列。与Set不同，List允许元素重复，并且保持插入时的顺序。本篇将详细介绍Java中...
本测试着重探讨了Java集合类中的Set接口实现类（如HashSet）以及List接口实现类（如ArrayList和LinkedList）在进行增、删、改、查操作时的性能差异。 首先，我们来看ArrayList。ArrayList是一个基于数组实现的列表...
在Java编程中，经常需要对两个`List`进行比较，找出它们之间的差异。这通常涉及到数据结构的理解、算法设计以及编程实现等多个方面。本文将详细探讨如何通过一个示例代码来理解如何比较两个`List`并提取出不同的对象...
在Java编程中，集合框架是核心部分之一，而List接口是集合框架的重要组成部分。当我们处理业务数据时，经常需要在不同实体类的列表之间进行转换，以满足不同的业务需求。这个压缩包文件“基于java8新特性+反射机制...
在Java编程中，List接口是集合框架的重要组成部分，它提供了有序的、允许重复元素的存储。遍历List对象集合是日常开发中常见的操作，这里我们将详细介绍三种遍历List的方法，并探讨它们的性能特点和适用场景。 ### ...
在Java编程中，将List对象转换为Excel文件是一项常见的任务，尤其在数据处理和报告生成时。本项目“Java list转excel.zip”提供了一个解决方案，它涵盖了如何利用Java的库来实现这一转换的过程。以下是对这个主题的...
"Java中初始化List的5种方法示例" Java中初始化List有多种方法，本文将介绍五种常见的初始化方式。了解这些方法可以帮助...了解这些方法可以帮助开发者更好地使用Java中的List数据结构，并提高开发效率和代码质量。
Java List集合是Java编程语言中一个非常重要的数据结构，它属于集合框架的一部分，主要用于存储一组有序的、可重复的对象。List接口提供了许多方法，使得在处理列表数据时具有很高的灵活性和效率。在这个“Java List...