ArrayList和LinkedList的操作性能对比

ArrayList和LinkedList都是实现了Collection和List接口，继承AbstractList的链表。

• ArrayList：

  List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector 类，除了此类是不同步的。）

• LinkedList:：

  List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾get、remove 和insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列 (deque)。

下面就根据几个示例才测试一下它们之间使用的性能区别：

1. 我们创建一个成员变量List list;在不同的testcase中分别实例化为ArrayList和LinkedList，然后往各个列表中添加100000条数据，根据操作前后的时间差来判断他们的插入性能；
   [java]  view plain  copy

   1. package org.wxp.collection;  
   2.   
   3. import java.util.ArrayList;  
   4. import java.util.LinkedList;  
   5. import java.util.List;  
   6.   
   7. import junit.framework.TestCase;  
   8.   
   9. /** 
   10.  * 测试LinkedList和ArrayList的添加性能 
   11.  *  
   12.  * @author Champion.Wong 
   13.  *  
   14.  */  
   15. public class Test_List01 extends TestCase {  
   16.     private List list = null;  
   17.     private long start = 0;  
   18.     private long end = 0;  
   19.   
   20.     /** 
   21.      * 测试LinkedList的插入性能 
   22.      */  
   23.     public void test() {  
   24.         list = new LinkedList();  
   25.         start = System.currentTimeMillis(); // 记录执行操作前时间  
   26.         for (int i = 0; i < 1000000; i++) {  
   27.             list.add("Hello java.");  
   28.         }  
   29.         end = System.currentTimeMillis();// 记录执行操作后时间  
   30.   
   31.         System.out.println("LinkedList用时：" + (end - start));  
   32.     }  
   33.   
   34.     /** 
   35.      * 测试ArrayList的插入性能 
   36.      */  
   37.     public void test1() {  
   38.         list = new ArrayList();  
   39.         start = System.currentTimeMillis();// 记录执行操作前时间  
   40.         for (int i = 0; i < 1000000; i++) {  
   41.             list.add("Hello java.");  
   42.         }  
   43.         end = System.currentTimeMillis();// 记录执行操作后时间  
   44.   
   45.         System.out.println("ArrayList用时：" + (end - start));  
   46.     }  
   47. }  
   执行后的控制台结果为：
   
2. 我们创建一个成员变量List list;在不同的testcase中分别实例化为ArrayList和LinkedList，然后往各个列表中添加100000条数据。然后遍历这些集合，根据操作前后的时间差来判断他们的插入性能；
   
   [java]  view plain  copy

   1. package org.wxp.collection;  
   2.   
   3. import java.util.ArrayList;  
   4. import java.util.LinkedList;  
   5. import java.util.List;  
   6.   
   7. import junit.framework.TestCase;  
   8.   
   9. /** 
   10.  * 测试LinkedList和ArrayList的遍历性能 
   11.  *  
   12.  * @author Champion.Wong 
   13.  *  
   14.  */  
   15. public class Test_List02 extends TestCase {  
   16.     private List list = null;  
   17.     private long start = 0;  
   18.     private long end = 0;  
   19.   
   20.     public void test() {  
   21.         list = new LinkedList();  
   22.         for (int i = 0; i < 100000; i++) {  
   23.             list.add("Hello Java!");  
   24.         }  
   25.   
   26.         start = System.currentTimeMillis();  
   27.         for (int i = 0; i < 100000; i++) {  
   28.             list.get(i);  
   29.         }  
   30.         end = System.currentTimeMillis();  
   31.   
   32.         System.out.println("LinkedList用时：" + (end - start));  
   33.     }  
   34.   
   35.     public void test1() {  
   36.         list = new ArrayList();  
   37.         for (int i = 0; i < 100000; i++) {  
   38.             list.add("Hello Java!");  
   39.         }  
   40.   
   41.         start = System.currentTimeMillis();  
   42.         for (int i = 0; i < 100000; i++) {  
   43.             list.get(i);  
   44.         }  
   45.         end = System.currentTimeMillis();  
   46.   
   47.         System.out.println("ArrayList用时：" + (end - start));  
   48.     }  
   49. }  
   
   执行之后的结果为：
   
   
   再看看Junit控制台的显示情况：
   
3. 我们分别在两个方法里定义一个ArrayList和LinkedList，分别往每个集合中插入100000条数据。ArrayList使用add(object)方法来插入，而LinkedList则使用独自的addFirst(object)和addLast(object)来进行收尾同时插入。
   
   [java]  view plain  copy

   1. package org.wxp.collection;  
   2.   
   3. import java.util.ArrayList;  
   4. import java.util.LinkedList;  
   5. import java.util.List;  
   6.   
   7. import junit.framework.TestCase;  
   8.   
   9. /** 
   10.  * 测试LinkedList和ArrayList的首位操作性能 
   11.  *  
   12.  * @author Champion.Wong 
   13.  *  
   14.  */  
   15. public class Test_List03 extends TestCase {  
   16.     private long start = 0;  
   17.     private long end = 0;  
   18.   
   19.     public void test() {  
   20.         LinkedList list = new LinkedList();  
   21.   
   22.         start = System.currentTimeMillis();  
   23.         for (int i = 0; i < 100000; i++) {  
   24.             list.addFirst("hello first!");  
   25.             list.addLast("hello first!");  
   26.         }  
   27.         end = System.currentTimeMillis();  
   28.   
   29.         System.out.println("LinkedList用时：" + (end - start));  
   30.     }  
   31.   
   32.     public void test1() {  
   33.         ArrayList list = new ArrayList();  
   34.   
   35.         start = System.currentTimeMillis();  
   36.         for (int i = 0; i < 100000; i++) {  
   37.             list.add("hello first");  
   38.             list.add("hello last");  
   39.         }  
   40.         end = System.currentTimeMillis();  
   41.   
   42.         System.out.println("ArrayList用时：" + (end - start));  
   43.     }  
   44. }  
   
   再来看看执行结果：
   
   

由以上测试结果可以看出：

ArrayList在遍历和普通插入（add(object)）的性能上都优于LinkedList。但是LinkedList在首尾进行操作的性能上明显优于ArrayList.

并且，ArrayList和LinkedList的操作方法都不是同步的，在并发操作时，不能保证其合理性，在创建的时候可以保证外部同步：

[java]  view plain  copy

1. List arrayList = Collections.synchronizedList(new ArrayList(...));  
2. List linkedList = Collections.synchronizedList(new LinkedList(...));  

转载请注明出处： http://blog.csdn.net/it_wangxiangpan/article/details/8693803