List概括

List 是一个接口，它继承于Collection的接口。它代表着有序的队列。

AbstractList 是一个抽象类，它继承于AbstractCollection。AbstractList实现List接口中除size()、get(int location)之外的函数。

ArrayList, LinkedList, Vector, Stack是List的4个实现类。

ArrayList 是一个数组队列，相当于动态数组。它由数组实现，随机访问效率高，随机插入、随机删除效率低。

LinkedList 是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList随机访问效率低，但随机插入、随机删除效率低。

Vector 是矢量队列，和ArrayList一样，它也是一个动态数组，由数组实现。但是ArrayList是非线程安全的，而Vector是线程安全的。

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

List使用场景

• 需要快速插入，删除元素，应该使用LinkedList。
• 需要快速随机访问元素，应该使用ArrayList。
• 对于“单线程环境” 或者 “多线程环境，但List仅仅只会被单个线程操作”，此时应该使用非同步的类(如ArrayList)。
• 对于“多线程环境，且List可能同时被多个线程操作”，此时，应该使用同步的类(如Vector)。

import java.util.*;
import java.lang.Class;/** @desc 对比ArrayList和LinkedList的插入、随机读取效率、删除的效率** @author skywang*/
public class ListCompareTest {private static final int COUNT = 100000;private static LinkedList linkedList = new LinkedList();private static ArrayList arrayList = new ArrayList();private static Vector vector = new Vector();private static Stack stack = new Stack();public static void main(String[] args) {// 换行符System.out.println();// 插入insertByPosition(stack) ;insertByPosition(vector) ;insertByPosition(linkedList) ;insertByPosition(arrayList) ;// 换行符System.out.println();// 随机读取readByPosition(stack);readByPosition(vector);readByPosition(linkedList);readByPosition(arrayList);// 换行符System.out.println();// 删除 deleteByPosition(stack);deleteByPosition(vector);deleteByPosition(linkedList);deleteByPosition(arrayList);}// 获取list的名称private static String getListName(List list) {if (list instanceof LinkedList) {return "LinkedList";} else if (list instanceof ArrayList) {return "ArrayList";} else if (list instanceof Stack) {return "Stack";} else if (list instanceof Vector) {return "Vector";} else {return "List";}}// 向list的指定位置插入COUNT个元素，并统计时间private static void insertByPosition(List list) {long startTime = System.currentTimeMillis();// 向list的位置0插入COUNT个数for (int i=0; i<COUNT; i++)list.add(0, i);long endTime = System.currentTimeMillis();long interval = endTime - startTime;System.out.println(getListName(list) + " : insert "+COUNT+" elements into the 1st position use time：" + interval+" ms");}// 从list的指定位置删除COUNT个元素，并统计时间private static void deleteByPosition(List list) {long startTime = System.currentTimeMillis();// 删除list第一个位置元素for (int i=0; i<COUNT; i++)list.remove(0);long endTime = System.currentTimeMillis();long interval = endTime - startTime;System.out.println(getListName(list) + " : delete "+COUNT+" elements from the 1st position use time：" + interval+" ms");}// 根据position，不断从list中读取元素，并统计时间private static void readByPosition(List list) {long startTime = System.currentTimeMillis();// 读取list元素for (int i=0; i<COUNT; i++)list.get(i);long endTime = System.currentTimeMillis();long interval = endTime - startTime;System.out.println(getListName(list) + " : read "+COUNT+" elements by position use time：" + interval+" ms");}
}

输出结果

Stack : insert 100000 elements into the 1st position use time：1640 ms
Vector : insert 100000 elements into the 1st position use time：1607 ms
LinkedList : insert 100000 elements into the 1st position use time：29 ms
ArrayList : insert 100000 elements into the 1st position use time：1617 msStack : read 100000 elements by position use time：9 ms
Vector : read 100000 elements by position use time：6 ms
LinkedList : read 100000 elements by position use time：10809 ms
ArrayList : read 100000 elements by position use time：5 msStack : delete 100000 elements from the 1st position use time：1916 ms
Vector : delete 100000 elements from the 1st position use time：1910 ms
LinkedList : delete 100000 elements from the 1st position use time：15 ms
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则相差不多，都只用了几秒。

LinkedList和ArrayList性能差异分析

LinkedList向指定位置插入元素的代码如下：

public void add(int index, E element) {//检查是否越界checkPositionIndex(index);if (index == size)//向最末尾添加元素linkLast(element);else//向指定位置添加元素linkBefore(element, node(index));}
//检查元素是否越界
private boolean isPositionIndex(int index) {return index >= 0 && index <= size;}
private void checkPositionIndex(int index) {if (!isPositionIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}
//向末尾添加元素
void linkLast(E e) {final Node<E> l = last;final Node<E> newNode = new Node<>(l, e, null);last = newNode;if (l == null)first = newNode;elsel.next = newNode;size++;modCount++;}
private static class Node<E> {E item;Node<E> next;Node<E> prev;Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}}
void linkBefore(E e, Node<E> succ) {// assert succ != null;final Node<E> pred = succ.prev;final Node<E> newNode = new Node<>(pred, e, succ);succ.prev = newNode;if (pred == null)first = newNode;elsepred.next = newNode;size++;modCount++;}
Node<E> node(int index) {// assert isElementIndex(index);//index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。if (index < (size >> 1)) {Node<E> x = first;for (int i = 0; i < index; i++)x = x.next;return x;} else {Node<E> x = last;for (int i = size - 1; i > index; i--)x = x.prev;return x;}}

通过add(int index, E element)向LinkedList插入元素时。先是在双向链表中找到要插入节点的位置index；找到之后，再插入一个新节点。 双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。

我们看看ArrayList中向指定位置插入元素的代码

    private static final int DEFAULT_CAPACITY = 10;public ArrayList() {super();this.elementData = EMPTY_ELEMENTDATA;}public void add(int index, E element) {//用于检查是否越界rangeCheckForAdd(index);//修改次数加一ensureCapacityInternal(size + 1);  // Increments modCount!!System.arraycopy(elementData, index, elementData, index + 1,size - index);elementData[index] = element;size++;}private void rangeCheckForAdd(int index) {if (index > size || index < 0)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}private void ensureCapacityInternal(int minCapacity) {if (elementData == EMPTY_ELEMENTDATA) {minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}ensureExplicitCapacity(minCapacity);}private void ensureExplicitCapacity(int minCapacity) {modCount++;// overflow-conscious codeif (minCapacity - elementData.length > 0)grow(minCapacity);}//数组扩容private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1);if (newCapacity - minCapacity < 0)newCapacity = minCapacity;if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);// minCapacity is usually close to size, so this is a win:elementData = Arrays.copyOf(elementData, newCapacity);}

ensureCapacity(size+1) 的作用是“确认ArrayList的容量，若容量不够，则增加容量。” 真正耗时的操作是 System.arraycopy(elementData, index, elementData, index + 1, size - index);

System.arraycopy(arr,0,copied,1,5);//这里的arr是原数组，0是原数组拷贝的起始地址。而copied是目标数组，1是目标数组开始存放的位置，5则是数组存放的长度。

LinkedList中随机访问很慢，ArrayList中随机访问很快

LinkedList随机访问代码

    public E get(int index) {checkElementIndex(index);return node(index).item;}private void checkElementIndex(int index) {if (!isElementIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}private boolean isElementIndex(int index) {return index >= 0 && index < size;}//对元素进行二分遍历一遍，如果列表很长的时候效率将会非常低下Node<E> node(int index) {// assert isElementIndex(index);if (index < (size >> 1)) {Node<E> x = first;for (int i = 0; i < index; i++)x = x.next;return x;} else {Node<E> x = last;for (int i = size - 1; i > index; i--)x = x.prev;return x;}}

先是在双向链表中找到要index位置的元素；找到之后再返回。双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。

ArrayList随机访问的代码

    public E get(int index) {rangeCheck(index);return elementData(index);}private void rangeCheck(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}//直接访问数组中的位置E elementData(int index) {return (E) elementData[index];}