Java基础【七】 - List集合汇总

List接口特色

List 接口存储一组容许重复，有序（插入顺序）的对象，有下标，插入顺序做为遍历的顺序。

List接口的三个经常使用实现类

使用场景

一、对插入元素数据的速度要求不高，可是要求快速访问元素数据，则使用ArrayList。
二、对访问元素数据速度不作要求不高，可是对插入和删除元素数据速度要求高的状况，则使用LinkedList。
三、有多线程对集合元素进行操做时候，则使用Vector，可是如今通常再也不使用Vector，如需在多线程下使用，能够用CopyOnWriteArrayList，在java.util.concurrent包下。
四、有需求是但愿后保存的数据先读取出来，则使用Stack；基于数组实现的，是栈，它继承与Vector。

List转数组方法

ArrayList<String> list=new ArrayList<String>();
String[] strings = new String[list.size()];
list.toArray(strings);

数组转成List

String[] s = {"a","b","c"};
List list = java.util.Arrays.asList(s);

性能测试

/*
 * 性能测试，经过插入、随机读取和删除对ArrayList、LinkedList、Vector和Stack进行测试！
 * 结论：看LinkedList
 *  插入10万个元素，LinkedList所花时间最短：17 ms。
 *  删除10万个元素，LinkedList所花时间最短： 9 ms。
 *  遍历10万个元素，LinkedList所花时间最长：10255 ms；而ArrayList、Stack和Vector则相差很少，都只用了几秒。
 *  (1) 对于须要快速插入，删除元素，应该使用LinkedList。
 *  (2) 对于须要快速随机访问元素，应该使用ArrayList。
 * 
 */

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("....开始测试读取元素..........");

        // 随机读取元素测试
        readAccessData(arrayList,"ArrayList") ;
        readAccessData(linkedList,"LinkedList") ;
        readAccessData(vector,"Vector") ;
        readAccessData(stack,"Stack") ;

        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元素， 使用的时间是 970 ms
LinkedList : 插入 100000元素， 使用的时间是 17 ms
Vector : 插入 100000元素， 使用的时间是 968 ms
Stack : 插入 100000元素， 使用的时间是 888 ms
....开始测试读取元素..........
ArrayList : 随机读取 100000元素， 使用的时间是 6 ms
LinkedList : 随机读取 100000元素， 使用的时间是 10255 ms
Vector : 随机读取 100000元素， 使用的时间是 8 ms
Stack : 随机读取 100000元素， 使用的时间是 4 ms
....开始测试删除元素..........
ArrayList : 删除 100000元素， 使用的时间是 1460 ms
LinkedList : 删除 100000元素， 使用的时间是 9 ms
Vector : 删除 100000元素， 使用的时间是 1472 ms
Stack : 删除 100000元素， 使用的时间是 894 ms

若是内容对你有帮助但愿点赞收藏谢谢！！！