java基础——ArrayList、LinkedList、Vector

如果涉及到“栈”、”队列“、”链表“等操作，应该考虑用List。

 

 一、综述

ArrayList接口：

         1.ArrayList内部实现是基于内部数组Object[],所以从概念上讲，它更像数组。

         2.在ArrayList的前面或中间插入数据时，必须将其后的所有数据响应的后移，这样必然要花费较多的时间，所以，当操作是在一列数据的后面添加数据，而不是在前面或中间，并且需要随机地访问其中的元素时，使用ArrayList会提供比较好的性能。

 

LinkedList接口：

         1.LinkedList的内部实现是基于一组连接的记录，所以它更像一个链表结构

         2.访问链表中的某个元素时，需要从链表的一端开始沿着链接的方向一个一个元素的去查找，直到找到所需的元素为止，所以，当操作是在一列数据的前面或中间添加数据或删除数据，并且按照顺武访问其中的元素时，就应该使用LinkedList了。

 

Vector：

        1.支持线程的同步。

 

二、示例分析：

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则相差不多，都只用了几秒。

 

三、总述:

ArrayList：查询效率比较高，增删动作的效率比较差，适合用于查询比较频繁，增删动作较少的元素管理集合。

LinkedList：查询效率低，但是增删效率很高。适用于增删动作的比较频繁，查询次数较少的元素管理集合。

 

ArrayList、LinkedList都是线程不安全的。

 

Vector：

       1.支持线程的同步。即某一个时刻只有一个线程能够写vector，避免多线程同时写而引起的不一致，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。

        2.对于“单线成环境”或者“多线程环境”，如果只会被单个线程操作，此时应该使用非同步的类（如ArrayList）。如果可能被多个线程操作，应该使用同步的类（vector）。

总之：不论什么情况，都应保证某一时刻，只有一个线程被处理，不能同一个资源，多个线程占用。

 

参考：

ArrayList和LinkedList对比：

http://wenku.baidu.com/link?url=iZFh5r9XorzD5-xtnkOpN2zuAuTx_8VA_kCcC5ZthV3hBrMUjTMaqtpJV_aXDLkSJdBVkU041-bAevLJ8dDj0vgqTBrcDpoZgTJ3a12NY_

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

http://www.jb51.net/article/42767.htm

list、set、map粗浅性能对比分析：

http://blog.csdn.net/partner4java/article/details/9214967