1、List的整体介绍

  List集合的总结和应用场景的介绍-风君雪科技博客

List 是一个接口，它继承于Collection的接口，它代表着有序的队列。list的实现类对象中每一个元素都有一个索引值，能够按照索引值进行元素查找。
AbstractList 是一个抽象类，它继承于AbstractCollection。AbstractList实现List接口中除size()、get(int location)之外的函数。
AbstractSequentialList 是一个抽象类，它继承于AbstractList。AbstractSequentialList 实现了“链表中，根据index索引值操作链表的全部函数”。
ArrayList, LinkedList, Vector, Stack是List的4个实现类。

ArrayList 是一个数组队列，相当于动态数组。它由动态数组实现，随机访问效率高，随机插入、随机删除效率低。ArrayList是非线程安全的。
LinkedList 是一个双向链表。它是由双向链表实现的，它也可以被当作堆栈、队列或双端队列进行操作。LinkedList随机访问效率低，但随机插入、随机删除效率低。一般对LinkedList进行元素遍历的时候使用removeFist()函数和removeLast()函数进行遍历的时候效率比较高，随机访问的方式效率最低。　　
Vector 是矢量队列，和ArrayList一样，它也是一个动态数组实现。Vector是线程安全的。

Stack 是栈，它继承于Vector。它的特性是：先进后出(FILO, First In Last Out)。

2、List的使用场景

 如果涉及到“栈”、“队列”、“链表”等操作，应该考虑用List，具体的选择哪个List，根据下面的标准来取舍。
(01) 对于需要快速插入，删除元素，应该使用LinkedList。
(02) 对于需要快速随机访问元素，应该使用ArrayList，也可以使用Vector。
(03) 对于“单线程环境” 或者 “多线程环境，但List仅仅只会被单个线程操作”，此时应该使用非同步的类(如ArrayList)。
       对于“多线程环境，且List可能同时被多个线程操作”，此时，应该使用同步的类(如Vector)。

下面是对不同集合类是测试程序：

 1 import java.util.*;
 2 import java.lang.Class;
 3 
 4 /*
 5  * @desc 对比ArrayList和LinkedList的插入、随机读取效率、删除的效率
 6  *
 7  * @author skywang
 8  */
 9 public class ListCompareTest {
10 
11     private static final int COUNT = 100000;
12 
13     private static LinkedList linkedList = new LinkedList();
14     private static ArrayList arrayList = new ArrayList();
15     private static Vector vector = new Vector();
16     private static Stack stack = new Stack();
17 
18     public static void main(String[] args) {
19         // 换行符
20         System.out.println();
21         // 插入
22         insertByPosition(stack) ;
23         insertByPosition(vector) ;
24         insertByPosition(linkedList) ;
25         insertByPosition(arrayList) ;
26 
27         // 换行符
28         System.out.println();
29         // 随机读取
30         readByPosition(stack);
31         readByPosition(vector);
32         readByPosition(linkedList);
33         readByPosition(arrayList);
34 
35         // 换行符
36         System.out.println();
37         // 删除 
38         deleteByPosition(stack);
39         deleteByPosition(vector);
40         deleteByPosition(linkedList);
41         deleteByPosition(arrayList);
42     }
43 
44     // 获取list的名称
45     private static String getListName(List list) {
46         if (list instanceof LinkedList) {
47             return "LinkedList";
48         } else if (list instanceof ArrayList) {
49             return "ArrayList";
50         } else if (list instanceof Stack) {
51             return "Stack";
52         } else if (list instanceof Vector) {
53             return "Vector";
54         } else {
55             return "List";
56         }
57     }
58 
59     // 向list的指定位置插入COUNT个元素，并统计时间
60     private static void insertByPosition(List list) {
61         long startTime = System.currentTimeMillis();
62 
63         // 向list的位置0插入COUNT个数
64         for (int i=0; i<COUNT; i++)
65             list.add(0, i);
66 
67         long endTime = System.currentTimeMillis();
68         long interval = endTime - startTime;
69         System.out.println(getListName(list) + " : insert "+COUNT+" elements into the 1st position use time：" + interval+" ms");
70     }
71 
72     // 从list的指定位置删除COUNT个元素，并统计时间
73     private static void deleteByPosition(List list) {
74         long startTime = System.currentTimeMillis();
75 
76         // 删除list第一个位置元素
77         for (int i=0; i<COUNT; i++)
78             list.remove(0);
79 
80         long endTime = System.currentTimeMillis();
81         long interval = endTime - startTime;
82         System.out.println(getListName(list) + " : delete "+COUNT+" elements from the 1st position use time：" + interval+" ms");
83     }
84 
85     // 根据position，不断从list中读取元素，并统计时间
86     private static void readByPosition(List list) {
87         long startTime = System.currentTimeMillis();
88 
89         // 读取list元素
90         for (int i=0; i<COUNT; i++)
91             list.get(i);
92 
93         long endTime = System.currentTimeMillis();
94         long interval = endTime - startTime;
95         System.out.println(getListName(list) + " : read "+COUNT+" elements by position use time：" + interval+" ms");
96     }
97 }

View Code

测试结果：

 1 Stack : insert 100000 elements into the 1st position use time：1640 ms
 2 Vector : insert 100000 elements into the 1st position use time：1607 ms
 3 LinkedList : insert 100000 elements into the 1st position use time：29 ms
 4 ArrayList : insert 100000 elements into the 1st position use time：1617 ms
 5 
 6 Stack : read 100000 elements by position use time：9 ms
 7 Vector : read 100000 elements by position use time：6 ms
 8 LinkedList : read 100000 elements by position use time：10809 ms
 9 ArrayList : read 100000 elements by position use time：5 ms
10 
11 Stack : delete 100000 elements from the 1st position use time：1916 ms
12 Vector : delete 100000 elements from the 1st position use time：1910 ms
13 LinkedList : delete 100000 elements from the 1st position use time：15 ms
14 ArrayList : delete 100000 elements from the 1st position use time：1909 ms

从中，我们可以发现：
插入10万个元素，LinkedList所花时间最短：29ms。
删除10万个元素，LinkedList所花时间最短：15ms。
遍历10万个元素，LinkedList所花时间最长：10809 ms；而ArrayList、Stack和Vector则相差不多，都只用了几秒。

考虑到Vector是支持同步的，而Stack又是继承于Vector的；因此，得出结论：
(01) 对于需要快速插入，删除元素，应该使用LinkedList。
(02) 对于需要快速随机访问元素，应该使用ArrayList。
(03) 对于“单线程环境” 或者 “多线程环境，但List仅仅只会被单个线程操作”，此时应该使用非同步的类。

 3、ArrayList和LinkedList的对比分析

3.1、LinkedList的插入删除元素的效率比ArrayList的效率要高

　　从源代码中我们可以看出：通过add(int index, E element)向LinkedList插入元素时。先是在双向链表中找到要插入节点的位置index；找到之后，再插入一个新节点。双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。而且因为Linked List是通过双向链表实现的，插入删除元素的时候不需要移动大量的元素。

　在ArrayList中，当我们要插入元素的时候，首先要调用ensureCapacity(size+1)函数，它的作用是“确认ArrayList的容量，若容量不够，则增加容量。”但是真正耗时的操作是 System.arraycopy(elementData, index, elementData, index + 1, size – index);

Sun JDK包的java/lang/System.java中的arraycopy()声明如下：

public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

arraycopy()是个JNI函数，它是在JVM中实现的。sunJDK中看不到源码，不过可以在OpenJDK包中看到的源码。网上有对arraycopy()的分析说明，实际上，我们只需要了解： System.arraycopy(elementData, index, elementData, index + 1, size – index); 会移动index之后所有元素即可。这就意味着，ArrayList的add(int index, E element)函数，会引起index之后所有元素的改变！

综上所述，LinkedList的插入删除元素的效率比ArrayList的效率要高。

3.2、ArrayList的随机访问效率比LinkedList的效率要高

　　在LinkedList的源码中我们可以看出：通过get(int index)获取LinkedList第index个元素时。先是在双向链表中找到要index位置的元素；找到之后再返回。
　　虽然双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。但是ArrayList是通过动态数组实现的，本事上还是一个数组，通过get(int index)获取ArrayList第index个元素时，直接返回数组中index位置的元素，而不需要像LinkedList一样进行查找。综上所述，ArrayList的随机访问效率比LinkedList的效率要高

4、Arraylist和Vector的对比分析

4.1、两者的相同之处

两者都是List接口下的具体实现类，都继承与AbstractList，并且实现了List接口
它们都实现了RandomAccess和Cloneable接口
它们都是通过数组实现的，本质上都是动态数组
它们的默认数组容量是10
它们都支持Iterator和listIterator遍历

4.2、两者的不同之处

线程安全性不同：ArrayList是非线程安全；而Vector是线程安全的，它的函数都是synchronized的，即都是支持同步的。ArrayList适用于单线程，Vector适用于多线程。
对序列化支持不同： ArrayList支持序列化，而Vector不支持；即ArrayList有实现java.io.Serializable接口，而Vector没有实现该接口。
构造函数个数不同：ArrayList有3个构造函数，而Vector有4个构造函数。Vector除了包括和ArrayList类似的3个构造函数之外，另外的一个构造函数可以指定容量增加系数。
容量增加方式不同：逐个添加元素时，若ArrayList容量不足时，“新的容量”=“(原始容量x3)/2 + 1”。而Vector的容量增长与“增长系数有关”，若指定了“增长系数”，且“增长系数有效(即，大于0)”；那么，每次容量不足时，“新的容量”=“原始容量+增长系数”。若增长系数无效(即，小于/等于0)，则“新的容量”=“原始容量 x 2”。
对Enumeration的支持不同。Vector支持通过Enumeration去遍历，而List不支持