JAVA LinkedList和ArrayList的使用及性能分析

第1部分 list概括
list的框架图

list 是一个接口，它继承于collection的接口。它代表着有序的队列。
abstractlist 是一个抽象类，它继承于abstractcollection。abstractlist实现list接口中除size()、get(int location)之外的函数。
abstractsequentiallist 是一个抽象类，它继承于abstractlist。abstractsequentiallist 实现了“链表中，根据index索引值操作链表的全部函数”。
arraylist, linkedlist, vector, stack是list的4个实现类。
arraylist 是一个数组队列，相当于动态数组。它由数组实现，随机访问效率高，随机插入、随机删除效率低。
linkedlist 是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。linkedlist随机访问效率低，但随机插入、随机删除效率低。
vector 是矢量队列，和arraylist一样，它也是一个动态数组，由数组实现。但是arraylist是非线程安全的，而vector是线程安全的。
stack 是栈，它继承于vector。它的特性是：先进后出(filo, first in last out)。

第2部分 list使用场景
学东西的最终目的是为了能够理解、使用它。下面先概括的说明一下各个list的使用场景，后面再分析原因。
如果涉及到“栈”、“队列”、“链表”等操作，应该考虑用list，具体的选择哪个list，根据下面的标准来取舍。
(01) 对于需要快速插入，删除元素，应该使用linkedlist。
(02) 对于需要快速随机访问元素，应该使用arraylist。
(03)
对于“单线程环境” 或者 “多线程环境，但list仅仅只会被单个线程操作”，此时应该使用非同步的类(如arraylist)。
对于“多线程环境，且list可能同时被多个线程操作”，此时，应该使用同步的类(如vector)。

通过下面的测试程序，我们来验证上面的(01)和(02)结论。参考代码如下：

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 ms
stack : 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 ms
stack : 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则相差不多，都只用了几秒。
考虑到vector是支持同步的，而stack又是继承于vector的；因此，得出结论：
(01) 对于需要快速插入，删除元素，应该使用linkedlist。
(02) 对于需要快速随机访问元素，应该使用arraylist。
(03)
对于“单线程环境” 或者 “多线程环境，但list仅仅只会被单个线程操作”，此时应该使用非同步的类。

 
第3部分 linkedlist和arraylist性能差异分析
下面我们看看为什么linkedlist中插入元素很快，而arraylist中插入元素很慢！
linkedlist.java中向指定位置插入元素的代码如下：

// 在index前添加节点，且节点的值为element
public void add(int index, e element) {
    addbefore(element, (index==size ? header : entry(index)));
}
// 获取双向链表中指定位置的节点
private entry<e> entry(int index) {
    if (index < 0 || index >= size)
        throw new indexoutofboundsexception("index: "+index+
                                            ", size: "+size);
    entry<e> e = header;
    // 获取index处的节点。
    // 若index < 双向链表长度的1/2,则从前向后查找;
    // 否则，从后向前查找。
    if (index < (size >> 1)) {
        for (int i = 0; i <= index; i++)
            e = e.next;
    } else {
        for (int i = size; i > index; i--)
            e = e.previous;
    }
    return e;
}
// 将节点(节点数据是e)添加到entry节点之前。
private entry<e> addbefore(e e, entry<e> entry) {
    // 新建节点newentry，将newentry插入到节点e之前；并且设置newentry的数据是e
    entry<e> newentry = new entry<e>(e, entry, entry.previous);
    // 插入newentry到链表中
    newentry.previous.next = newentry;
    newentry.next.previous = newentry;
    size++;
    modcount++;
    return newentry;
}

从中，我们可以看出：通过add(int index, e element)向linkedlist插入元素时。先是在双向链表中找到要插入节点的位置index；找到之后，再插入一个新节点。
双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。
接着，我们看看arraylist.java中向指定位置插入元素的代码。如下：

// 将e添加到arraylist的指定位置
public void add(int index, e element) {
    if (index > size || index < 0)
        throw new indexoutofboundsexception(
        "index: "+index+", size: "+size);
    ensurecapacity(size+1);  // increments modcount!!
    system.arraycopy(elementdata, index, elementdata, index + 1,
         size - index);
    elementdata[index] = element;
    size++;
}

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源码分析
实际上，我们只需要了解： system.arraycopy(elementdata, index, elementdata, index + 1, size - index); 会移动index之后所有元素即可。这就意味着，arraylist的add(int index, e element)函数，会引起index之后所有元素的改变！

通过上面的分析，我们就能理解为什么linkedlist中插入元素很快，而arraylist中插入元素很慢。
“删除元素”与“插入元素”的原理类似，这里就不再过多说明。

接下来，我们看看 “为什么linkedlist中随机访问很慢，而arraylist中随机访问很快”。
先看看linkedlist随机访问的代码

// 返回linkedlist指定位置的元素
public e get(int index) {
    return entry(index).element;
}
// 获取双向链表中指定位置的节点
private entry<e> entry(int index) {
    if (index < 0 || index >= size)
        throw new indexoutofboundsexception("index: "+index+
                                            ", size: "+size);
    entry<e> e = header;
    // 获取index处的节点。
    // 若index < 双向链表长度的1/2,则从前先后查找;
    // 否则，从后向前查找。
    if (index < (size >> 1)) {
        for (int i = 0; i <= index; i++)
            e = e.next;
    } else {
        for (int i = size; i > index; i--)
            e = e.previous;
    }
    return e;
}

从中，我们可以看出：通过get(int index)获取linkedlist第index个元素时。先是在双向链表中找到要index位置的元素；找到之后再返回。
双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。
下面看看arraylist随机访问的代码

// 获取index位置的元素值
public e get(int index) {
    rangecheck(index);
    return (e) elementdata[index];
}
private void rangecheck(int index) {
    if (index >= size)
        throw new indexoutofboundsexception(
        "index: "+index+", size: "+size);
}

从中，我们可以看出：通过get(int index)获取arraylist第index个元素时。直接返回数组中index位置的元素，而不需要像linkedlist一样进行查找。
第3部分 vector和arraylist比较
相同之处
1 它们都是list
它们都继承于abstractlist，并且实现list接口。
arraylist和vector的类定义如下：

// arraylist的定义
public class arraylist<e> extends abstractlist<e>
        implements list<e>, randomaccess, cloneable, java.io.serializable
// vector的定义
public class vector<e> extends abstractlist<e>
    implements list<e>, randomaccess, cloneable, java.io.serializable {}

2 它们都实现了randomaccess和cloneable接口
实现randomaccess接口，意味着它们都支持快速随机访问；
实现cloneable接口，意味着它们能克隆自己。

3 它们都是通过数组实现的，本质上都是动态数组
arraylist.java中定义数组elementdata用于保存元素
// 保存arraylist中数据的数组
private transient object[] elementdata;
vector.java中也定义了数组elementdata用于保存元素
// 保存vector中数据的数组
protected object[] elementdata;

4 它们的默认数组容量是10
 若创建arraylist或vector时，没指定容量大小；则使用默认容量大小10。
arraylist的默认构造函数如下：

// arraylist构造函数。默认容量是10。
public arraylist() {
    this(10);
}
vector的默认构造函数如下：
// vector构造函数。默认容量是10。
public vector() {
    this(10);
}

5 它们都支持iterator和listiterator遍历
它们都继承于abstractlist，而abstractlist中分别实现了 “iterator()接口返回iterator迭代器” 和 “listiterator()返回listiterator迭代器”。

 
不同之处
1 线程安全性不一样
arraylist是非线程安全；
而vector是线程安全的，它的函数都是synchronized的，即都是支持同步的。
arraylist适用于单线程，vector适用于多线程。
2 对序列化支持不同
 arraylist支持序列化，而vector不支持；即arraylist有实现java.io.serializable接口，而vector没有实现该接口。
3 构造函数个数不同
arraylist有3个构造函数，而vector有4个构造函数。vector除了包括和arraylist类似的3个构造函数之外，另外的一个构造函数可以指定容量增加系数。
arraylist的构造函数如下：

// 默认构造函数
arraylist()
// capacity是arraylist的默认容量大小。当由于增加数据导致容量不足时，容量会添加上一次容量大小的一半。
arraylist(int capacity)
// 创建一个包含collection的arraylist
arraylist(collection<? extends e> collection)
vector的构造函数如下：
// 默认构造函数
vector()
// capacity是vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。
vector(int capacity)
// 创建一个包含collection的vector
vector(collection<? extends e> collection)
// capacity是vector的默认容量大小，capacityincrement是每次vector容量增加时的增量值。
vector(int capacity, int capacityincrement)

4 容量增加方式不同
逐个添加元素时，若arraylist容量不足时，“新的容量”=“(原始容量x3)/2 + 1”。
而vector的容量增长与“增长系数有关”，若指定了“增长系数”，且“增长系数有效(即，大于0)”；那么，每次容量不足时，“新的容量”=“原始容量+增长系数”。若增长系数无效(即，小于/等于0)，则“新的容量”=“原始容量 x 2”。
arraylist中容量增长的主要函数如下：

public void ensurecapacity(int mincapacity) {
    // 将“修改统计数”+1
    modcount++;
    int oldcapacity = elementdata.length;
    // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”
    if (mincapacity > oldcapacity) {
        object olddata[] = elementdata;
        int newcapacity = (oldcapacity * 3)/2 + 1;
        if (newcapacity < mincapacity)
            newcapacity = mincapacity;
        elementdata = arrays.copyof(elementdata, newcapacity);
    }
}

vector中容量增长的主要函数如下：

private void ensurecapacityhelper(int mincapacity) {
    int oldcapacity = elementdata.length;
    // 当vector的容量不足以容纳当前的全部元素，增加容量大小。
    // 若 容量增量系数>0(即capacityincrement>0)，则将容量增大当capacityincrement
    // 否则，将容量增大一倍。
    if (mincapacity > oldcapacity) {
        object[] olddata = elementdata;
        int newcapacity = (capacityincrement > 0) ?
            (oldcapacity + capacityincrement) : (oldcapacity * 2);
        if (newcapacity < mincapacity) {
            newcapacity = mincapacity;
        }
        elementdata = arrays.copyof(elementdata, newcapacity);
    }
}

5 对enumeration的支持不同。vector支持通过enumeration去遍历，而list不支持
vector中实现enumeration的代码如下：

public enumeration<e> elements() {
    // 通过匿名类实现enumeration
    return new enumeration<e>() {
        int count = 0;
        // 是否存在下一个元素
        public boolean hasmoreelements() {
            return count < elementcount;
        }
        // 获取下一个元素
        public e nextelement() {
            synchronized (vector.this) {
                if (count < elementcount) {
                    return (e)elementdata[count++];
                }
            }
            throw new nosuchelementexception("vector enumeration");
        }
    };
}