Java List集合总结

List继承了Collection，是有序的列表.

○ArrayList是基于数组实现的，是一个数组队列。可以动态的降低容量！ ○LinkedList是基于链表实现的，是一个双向循环列表。可以被当作堆栈使用！ ○Vector是基于变量实现的，是一个矢量队列，是线程安全的！ ○Stack是基于变量实现的，是栈，它继承与Vector，特性是FILO（先进后出）！

当集合中对插入元素数据的速率要求不高，但是要求迅速访问元素数据list java 容量，则使用ArrayList。当集合中对访问元素数据速度不做要求不高，但是对插入和删除元素数据速率要求高的状况，则使用LinkedList。

3.当集合中有多线程对集合元素进行操作之后，则使用Vector！但是目前BVector现在通常不再使用，如需在多线程下使用，可以用CopyOnWriteArrayList，在java.util.concurrent包下。

4.当集合中有需求是期望后储存的数据先调用出来，则使用Stack。

package com.company;
import java.util.*;
/**
 * @program JavaLearn3Day
 * @description:
 * @author: Destiny
 * @create: 2018/12/21 14:24
 */
public class ListTest {
    private static final int COUNT = 100000; //十万
    private static ArrayList<Object> arrayList = new ArrayList<Object>();
    private static LinkedList<Object> linkedList = new LinkedList<Object>();
    private static Vector<Object> vector = new Vector<Object>();
    private static Stack<Object> stack = new Stack<Object>();
    public static void main(String[] args) {
        System.out.println("....开始测试插入元素..........");
        // 插入元素测试
        insertData(arrayList,"ArrayList") ;
        insertData(linkedList,"LinkedList") ;
        insertData(vector,"Vector") ;
        insertData(stack,"Stack") ;
        System.out.println("\r");
        System.out.println("....开始测试读取元素..........");
        // 随机读取元素测试
        readAccessData(arrayList,"ArrayList") ;
        readAccessData(linkedList,"LinkedList") ;
        readAccessData(vector,"Vector") ;
        readAccessData(stack,"Stack") ;
        System.out.println("\r");
        System.out.println("....开始测试删除元素..........");
        // 随机读取元素测试
        deleteData(arrayList,"ArrayList") ;
        deleteData(linkedList,"LinkedList") ;
        deleteData(vector,"Vector") ;
        deleteData(stack,"Stack") ;
    }
    /**
     * 指定的List 的子类中插入元素，并统计插入的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void insertData(List<Object> list,String name) {
        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(name + " : 插入 "+COUNT+"元素， 使用的时间是 " + interval+" ms");
    }
    /**
     * 指定的List 的子类中删除元素，并统计删除的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void deleteData(List<Object> list,String name) {
        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(name + " : 删除 "+COUNT+"元素， 使用的时间是 " + interval+" ms");
    }
    /**
     * 指定的List 的子类中读取元素，并统计读取的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void readAccessData(List<Object> list, String name) {
        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(name + " : 随机读取 "+COUNT+"元素， 使用的时间是 " + interval+" ms");
    }
}

打印结果

....开始测试插入元素..........
ArrayList : 插入 100000元素， 使用的时间是 649 ms
LinkedList : 插入 100000元素， 使用的时间是 16 ms
Vector : 插入 100000元素， 使用的时间是 710 ms
Stack : 插入 100000元素， 使用的时间是 508 ms
....开始测试读取元素..........
ArrayList : 随机读取 100000元素， 使用的时间是 3 ms
LinkedList : 随机读取 100000元素， 使用的时间是 5217 ms
Vector : 随机读取 100000元素， 使用的时间是 3 ms
Stack : 随机读取 100000元素， 使用的时间是 3 ms
....开始测试删除元素..........
ArrayList : 删除 100000元素， 使用的时间是 475 ms
LinkedList : 删除 100000元素， 使用的时间是 3 ms
Vector : 删除 100000元素， 使用的时间是 517 ms
Stack : 删除 100000元素， 使用的时间是 515 ms

从运行的结果来看，ArrayList读取速率快于LinkedList，而插入和删除速度既慢于LinkedList。 原因 （1）ArrayList随机读取的之后引入的是get(index),根据选定位置读取元素，而LinkedList则选用size/2 ,二分法去加速一次读取元素。

（2）ArrayList插入之后应判定容量，删除但是的所有元素都应向数组的前端移动。 而LinkedList直接插入，不用判断容量，删除的之后更轻松list java 容量，只应该更新被删除元素附近的链接。（链表将每个对象保存在独立的节点中，每个节点还保存着序列中下一个节点的引用）

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-141785-1.html