前面已经学习完了list部分的源码，主要是arraylist和linkedlist两部分内容，这一节主要总结下list部分的内容。
先来回顾一下list在collection中的的框架图：
从图中我们可以看出：
1. list是一个接口，它继承与collection接口，代表有序的队列。
2. abstractlist是一个抽象类，它继承与abstractcollection。abstractlist实现了list接口中除了size()、get(int location)之外的方法。
3. abstractsequentiallist是一个抽象类，它继承与abstrctlist。abstractsequentiallist实现了“链表中，根据index索引值操作链表的全部方法”。
4. arraylist、linkedlist、vector和stack是list的四个实现类，其中vector是基于jdk1.0，虽然实现了同步，但是效率低，已经不用了，stack继承与vector，所以不再赘述。
5. linkedlist是个双向链表，它同样可以被当作栈、队列或双端队列来使用。
我们知道，通常情况下，arraylist和linkedlist的区别有以下几点：
2. 对于随机访问get和set，arraylist要优于linkedlist，因为linkedlist要移动指针；
3. 对于添加和删除操作add和remove，一般大家都会说linkedlist要比arraylist快，因为arraylist要移动数据。但是实际情况并非这样，对于添加或删除，linkedlist和arraylist并不能明确说明谁快谁慢，下面会详细分析。
我们结合之前分析的源码，来看看为什么是这样的：
arraylist中的随机访问、添加和删除部分源码如下：
//获取index位置的元素值
public e get(int index) {
rangecheck(index); //首先判断index的范围是否合法
return elementdata(index);
}
//将index位置的值设为element，并返回原来的值
public e set(int index, e element) {
rangecheck(index);
e oldvalue = elementdata(index);
elementdata[index] = element;
return oldvalue;
//将element添加到arraylist的指定位置
public void add(int index, e element) {
rangecheckforadd(index);
ensurecapacityinternal(size + 1); // increments modcount!!
//将index以及index之后的数据复制到index+1的位置往后，即从index开始向后挪了一位
system.arraycopy(elementdata, index, elementdata, index + 1,
size - index);
elementdata[index] = element; //然后在index处插入element
size++;
//删除arraylist指定位置的元素
public e remove(int index) {
modcount++;
int nummoved = size - index - 1;
if (nummoved > 0)
//向左挪一位，index位置原来的数据已经被覆盖了
system.arraycopy(elementdata, index+1, elementdata, index,
nummoved);
//多出来的最后一位删掉
elementdata[--size] = null; // clear to let gc do its work
linkedlist中的随机访问、添加和删除部分源码如下：
//获得第index个节点的值
checkelementindex(index);
return node(index).item;
//设置第index元素的值
node<e> x = node(index);
e oldval = x.item;
x.item = element;
return oldval;
//在index个节点之前添加新的节点
checkpositionindex(index);
if (index == size)
linklast(element);
else
linkbefore(element, node(index));
//删除第index个节点
return unlink(node(index));
//定位index处的节点
node<e> node(int index) {
// assert iselementindex(index);
//index<size/2时，从头开始找
if (index < (size >> 1)) {
node<e> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else { //index>=size/2时，从尾开始找
node<e> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
}
从源码可以看出，arraylist想要get(int index)元素时，直接返回index位置上的元素，而linkedlist需要通过for循环进行查找，虽然linkedlist已经在查找方法上做了优化，比如index < size / 2，则从左边开始查找，反之从右边开始查找，但是还是比arraylist要慢。这点是毋庸置疑的。
arraylist想要在指定位置插入或删除元素时，主要耗时的是system.arraycopy动作，会移动index后面所有的元素；linkedlist主耗时的是要先通过for循环找到index，然后直接插入或删除。这就导致了两者并非一定谁快谁慢，下面通过一个测试程序来测试一下两者插入的速度：
import java.util.arraylist;
import java.util.collections;
import java.util.linkedlist;
import java.util.list;
/*
* @description 测试arraylist和linkedlist插入的效率
* @eson_15
*/
public class arrayorlinked {
static list<integer> array=new arraylist<integer>();
static list<integer> linked=new linkedlist<integer>();
public static void main(string[] args) {
//首先分别给两者插入10000条数据
for(int i=0;i<10000;i++){
array.add(i);
linked.add(i);
}
//获得两者随机访问的时间
system.out.println("array time:"+gettime(array));
system.out.println("linked time:"+gettime(linked));
//获得两者插入数据的时间
system.out.println("array insert time:"+inserttime(array));
system.out.println("linked insert time:"+inserttime(linked));
}
public static long gettime(list<integer> list){
long time=system.currenttimemillis();
for(int i = 0; i < 10000; i++){
int index = collections.binarysearch(list, list.get(i));
if(index != i){
system.out.println("error!");
}
return system.currenttimemillis()-time;
//插入数据
public static long inserttime(list<integer> list){
/*
* 插入的数据量和插入的位置是决定两者性能的主要方面，
* 我们可以通过修改这两个数据，来测试两者的性能
*/
long num = 10000; //表示要插入的数据量
int index = 1000; //表示从哪个位置插入
for(int i = 1; i < num; i++){
list.add(index, i);
}
主要有两个因素决定他们的效率，插入的数据量和插入的位置。我们可以在程序里改变这两个因素来测试它们的效率。
当数据量较小时，测试程序中，大约小于30的时候，两者效率差不多，没有显著区别；当数据量较大时，大约在容量的1/10处开始，linkedlist的效率就开始没有arraylist效率高了，特别到一半以及后半的位置插入时，linkedlist效率明显要低于arraylist，而且数据量越大，越明显。比如我测试了一种情况，在index=1000的位置(容量的1/10)插入10000条数据和在index=5000的位置以及在index=9000的位置插入10000条数据的运行时间如下：
在index=1000出插入结果：
array time:4
linked time:240
array insert time:20
linked insert time:18
在index=5000处插入结果：
linked time:229
array insert time:13
linked insert time:90
在index=9000处插入结果：
linked time:237
array insert time:7
linked insert time:92
从运行结果看，linkedlist的效率是越来越差。
所以当插入的数据量很小时，两者区别不太大，当插入的数据量大时，大约在容量的1/10之前，linkedlist会优于arraylist，在其后就劣与arraylist，且越靠近后面越差。所以个人觉得，一般首选用arraylist，由于linkedlist可以实现栈、队列以及双端队列等数据结构，所以当特定需要时候，使用linkedlist，当然咯，数据量小的时候，两者差不多，视具体情况去选择使用；当数据量大的时候，如果只需要在靠前的部分插入或删除数据，那也可以选用linkedlist，反之选择arraylist反而效率更高。
关于arraylist和linkedlist的比较，就讨论这么多吧，如果有错误之处，请留言指正~
转载：http://blog.csdn.net/eson_15/article/details/51145788