一、List接口概述
List接口，成为有序的Collection也就是序列。该接口可以对列表中的每一个元素的插入位置进行精确的控制，同时用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。 下图是List接口的框架图：
通过上面的框架图，可以对List的结构了然于心，其各个类、接口如下：
Collection：Collection 层次结构 中的根接口。它表示一组对象，这些对象也称为 collection 的元素。对于Collection而言，它不提供任何直接的实现，所有的实现全部由它的子类负责。
AbstractCollection：提供 Collection 接口的骨干实现，以最大限度地减少了实现此接口所需的工作。对于我们而言要实现一个不可修改的 collection，只需扩展此类，并提供 iterator 和 size 方法的实现。但要实现可修改的 collection，就必须另外重写此类的 add 方法（否则，会抛出 UnsupportedOperationException），iterator 方法返回的迭代器还必须另外实现其 remove 方法。
terator：迭代器。
ListIterator：系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
List：继承于Collection的接口。它代表着有序的队列。
AbstractList：List 接口的骨干实现，以最大限度地减少实现“随机访问”数据存储（如数组）支持的该接口所需的工作。
Queue：队列。提供队列基本的插入、获取、检查操作。
Deque：一个线性 collection，支持在两端插入和移除元素。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。
AbstractSequentialList：提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。从某种意义上说，此类与在列表的列表迭代器上实现“随机访问”方法。
LinkedList：List 接口的链接列表实现。它实现所有可选的列表操作。
ArrayList：List 接口的大小可变数组的实现。它实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。
Vector：实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
Stack：后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。
Enumeration：枚举，实现了该接口的对象，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。
二、使用场景
学习知识的根本目的就是使用它。每个知识点都有它的使用范围。集合也是如此，在Java中集合的家族非常庞大，每个成员都有最适合的使用场景。在刚刚接触List时，LZ就说过如果涉及到“栈”、“队列”、“链表”等操作，请优先考虑用List。至于是那个List则分如下：
1、对于需要快速插入、删除元素，则需使用LinkedList。
2、对于需要快速访问元素，则需使用ArrayList。
3、对于“单线程环境”或者“多线程环境，但是List仅被一个线程操作”，需要考虑使用非同步的类，如果是“多线程环境，切List可能同时被多个线程操作”，考虑使用同步的类（如Vector）。
2.1ArrayList、LinkedList性能分析
在List中我们使用最普遍的就是LinkedList和ArrayList，同时我们也了解了他们两者之间的使用场景和区别。
[java] view plain copy
1. public class ListTest {
2. private static final int COUNT = 100000;
3.
4. private static ArrayList arrayList = new ArrayList<>();
5. private static LinkedList linkedList = new LinkedList<>();
6. private static Vector vector = new Vector<>();
7.
8. public static void insertToList(List list){
9. long startTime = System.currentTimeMillis();
10.
11. for(int i = 0 ; i < COUNT ; i++){
12. 0,i);
13. }
14.
15. long endTime = System.currentTimeMillis();
16. "插入 " + COUNT + "元素" + getName(list) + "花费 " + (endTime - startTime) + " 毫秒");
17. }
18.
19. public static void deleteFromList(List list){
20. long startTime = System.currentTimeMillis();
21.
22. for(int i = 0 ; i < COUNT ; i++){
23. 0);
24. }
25.
26. long endTime = System.currentTimeMillis();
27. "删除" + COUNT + "元素" + getName(list) + "花费 " + (endTime - startTime) + " 毫秒");
28. }
29.
30. public static void readList(List list){
31. long startTime = System.currentTimeMillis();
32.
33. for(int i = 0 ; i < COUNT ; i++){
34. list.get(i);
35. }
36.
37. long endTime = System.currentTimeMillis();
38. "读取" + COUNT + "元素" + getName(list) + "花费 " + (endTime - startTime) + " 毫秒");
39. }
40.
41. private static String getName(List list) {
42. "";
43. if(list instanceof ArrayList){
44. "ArrayList";
45. }
46. else if(list instanceof LinkedList){
47. "LinkedList";
48. }
49. else if(list instanceof Vector){
50. "Vector";
51. }
52. return name;
53. }
54.
55. public static void main(String[] args) {
56. insertToList(arrayList);
57. insertToList(linkedList);
58. insertToList(vector);
59.
60. "--------------------------------------");
61.
62. readList(arrayList);
63. readList(linkedList);
64. readList(vector);
65.
66. "--------------------------------------");
67.
68. deleteFromList(arrayList);
69. deleteFromList(linkedList);
70. deleteFromList(vector);
71. }
72. }
运行结果:
[java] view plain copy
1. 插入 100000元素ArrayList花费 3900 毫秒
2. 插入 100000元素LinkedList花费 15 毫秒
3. 插入 100000元素Vector花费 3933 毫秒
4. --------------------------------------
5. 读取100000元素ArrayList花费 0 毫秒
6. 读取100000元素LinkedList花费 8877 毫秒
7. 读取100000元素Vector花费 16 毫秒
8. --------------------------------------
9. 删除100000元素ArrayList花费 4618 毫秒
10. 删除100000元素LinkedList花费 16 毫秒
11. 删除100000元素Vector花费 4759 毫秒
从上面的运行结果我们可以清晰的看出ArrayList、LinkedList、Vector增加、删除、遍历的效率问题。下面我就插入方法add(int index, E element),delete、get方法各位如有兴趣可以研究研究。
首先我们先看三者之间的源码：
ArrayList
[java] view plain copy
1. public void add(int index, E element) {
2. //检查是否index是否合法
3.
4. 1); //扩容操作
5. 1, size - index); //数组拷贝
6. //插入
7. size++;
8. }
rangeCheckForAdd、ensureCapacityInternal两个方法没有什么影响，真正产生影响的是System.arraycopy方法，该方法是个JNI函数，是在JVM中实现的。声明如下：
[java] view plain copy
1. public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
目前LZ无法看到源码，具体的实现不是很清楚，不过System.arraycopy源码分析对其进行了比较清晰的分析。但事实上我们只需要了解该方法会移动index后面的所有元素即可，这就意味着ArrayList的add(int index, E element)方法会引起index位置之后所有元素的改变，这真是牵一处而动全身。
LinkedList
[java] view plain copy
1. public void add(int index, E element) {
2. checkPositionIndex(index);
3.
4. if (index == size) //插入位置在末尾
5. linkLast(element);
6. else
7. linkBefore(element, node(index));
8. }
该方法比较简单，插入位置在末尾则调用linkLast方法，否则调用linkBefore方法，其实linkLast、linkBefore都是非常简单的实现，就是在index位置插入元素，至于index具体为知则有node方法来解决，同时node对index位置检索还有一个加速作用，如下：
[java] view plain copy
1. Node<E> node(int index) {
2. if (index < (size >> 1)) { //如果index 小于 size/2 则从头开始查找
3. Node<E> x = first;
4. for (int i = 0; i < index; i++)
5. x = x.next;
6. return x;
7. else { //如果index 大于 size/2 则从尾部开始查找
8. Node<E> x = last;
9. for (int i = size - 1; i > index; i--)
10. x = x.prev;
11. return x;
12. }
13. }
所以linkedList的插入动作比ArrayList动作快就在于两个方面。1：linkedList不需要执行元素拷贝动作，没有牵一发而动全身的大动作。2:查找插入位置有加速动作即：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。
Vector
Vector的实现机制和ArrayList一样，同样是使用动态数组来实现的，所以他们两者之间的效率差不多，add的源码也一样，如下：
[java] view plain copy
1. public void add(int index, E element) {
2. insertElementAt(element, index);
3. }
4.
5. public synchronized void insertElementAt(E obj, int index) {
6. modCount++;
7. if (index > elementCount) {
8. throw new ArrayIndexOutOfBoundsException(index
9. " > " + elementCount);
10. }
11. 1);
12. 1, elementCount - index);
13. elementData[index] = obj;
14. elementCount++;
15. }
上面是针对ArrayList、LinkedList、Vector三者之间的add（int index,E element)方法的解释，解释了LinkedList的插入动作要比ArrayList、Vector的插入动作效率为什么要高出这么多！
2.2、ArrayList和LinkedList的比较
数组优于链表的:
1.内存空间占用的少,因为链表节点会附加上一块或两块下一个节点的信息.但是数组在建立时就固定了.所以也有可能会因为建立的数组过大或不足引起内存上的问题
2.数组内的数据可随机访问.但链表不具备随机访问性.这个很容易理解.数组在内存里是连续的空间.比如如果一个数组地址从100到200,且每个元素占用两个字节,那么100-200之间的任何一个偶数都是数组元素的地址.可以直接访问.链表在内存地址可能是分散的.所以必须通过上一节点中的信息找能找到下一个节点.
3.查找速度上.这个也是因为内存地址的连续性的问题.不罗索了.
链表优于数组的:
1.插入与删除的操作.如果数组的中间插入一个元素,那么这个元素后的所有元素的内存地址都要往后移动.删除的话同理.只有对数据的最后一个元素进行插入删除操作时,才比较快.链表只需要更改有必要更改的节点内的节点信息就够了.并不需要更改节点的内存地址.
2.链表的内存利用率更高，不管你内存里还有多少空间,如果没办法一次性给出数组所需的要空间,那就会提示内存不足,磁盘空间整理的原因之一在这里，会产生内存碎片，而链表可以是分散的空间地址.
3.链表的扩展性比数组好.因为一个数组建立后所占用的空间大小就是固定的.如果满了就没法扩展.只能新建一个更大空间的数组.而链表不是固定的,可以很方便的扩展.
使用场景：
1、对于需要快速插入、删除元素，则需使用LinkedList。
2、对于需要快速访问元素，则需使用ArrayList。
2.3、Vector和ArrayList的区别
Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍
