Java List容器分析

ArrayList、Vector、LinkedList优缺点

ArrayList：它长于随机访问元素，但是在List的中阅插入和移除元素时较慢。
LinkedList：代价较低的在List中间进行的插入和删除操作（链表的特性），提供了优化的顺序访 问。LinkedList在随机访问方面相对比较慢，但是它的特性集较ArrayList 更大。
Vector：线程安全集合容器

- 1、ArrayList、Vector、LinkedList写入储存顺序测试

/**
     * [List容器写入，读取顺序]
     * @author xiangyong.zeng
     * @param
     * @return void
     * @date 2019-07-26 16:00
     */
    public static void testListSort(){
        List<Map<Object,String>> arrayList = new ArrayList<>();
        List linkedList = new LinkedList();
        List vector = new Vector();

        Random random = new Random();
        for (int i = 0; i < 10 ; i++) {
            Map<Object,String> hashMap = new HashMap<>(1);
            hashMap.put(i,random.toString());

            arrayList.add(hashMap);
            linkedList.add(hashMap);
            vector.add(hashMap);
        }

        System.out.println(arrayList);
        System.out.println(linkedList);
        System.out.println(vector);
    }

结果：
[{0=java.util.Random@c4437c4}, {1=java.util.Random@c4437c4}]
[{0=java.util.Random@c4437c4}, {1=java.util.Random@c4437c4}]
[{0=java.util.Random@c4437c4}, {1=java.util.Random@c4437c4}]

•  可以看出， ArrayList、Vector、LinkedList都是有序集合
  

-2、ArrayList、Vector、LinkedList容器写入，随机访问，随机移除修改耗时测试

  public static void testListMoveModify(){
        List<Map<Object,String>> arrayList = new ArrayList<>();
        List linkedList = new LinkedList();
        List vector = new Vector();

        List list = write(arrayList);
        List list2 = write(linkedList);
        List list3 = write(vector);

        randomGet(list);
        randomGet(list2);
        randomGet(list3);

        randomModifyRemove(list);
        randomModifyRemove(list2);
        randomModifyRemove(list3);
    }


    /**
     * [List容器插入删除]
     * @author xiangyong.zeng
     * @param list
     * @return java.util.List
     * @date 2019-07-26 17:14
     */
    public static List randomModifyRemove(List list){
        long a = System.currentTimeMillis();

        Random random = new Random();
        for (int i = 0; i <100000 ; i++) {
            list.remove(random.nextInt(10000));
            list.set(random.nextInt(10000),i);
        }
        System.out.println(list.getClass()+"随机修改移除耗时："+ (System.currentTimeMillis() - a));
        return null;
    }


    /**
     * [List容器随机访问耗时]
     * @author xiangyong.zeng
     * @param list
     * @return java.util.List
     * @date 2019-07-26 16:18
     */
    public static List randomGet(List list){
        long a = System.currentTimeMillis();

        Random random = new Random();
        for (int i = 0; i <100000 ; i++) {
            list.get(random.nextInt((100000)));
        }

        System.out.println(list.getClass()+"随机访问耗时："+ (System.currentTimeMillis() - a));
        return list;
    }

    /**
     * [List容器写入耗时]
     * @author xiangyong.zeng
     * @param list
     * @return java.util.List
     * @date 2019-07-26 16:12
     */
    public static List write(List list){
        long a = System.currentTimeMillis();

        for (int i = 0; i < 1000000; i++) {
            list.add(i);
        }

        System.out.println(list.getClass()+"写入耗时："+ (System.currentTimeMillis() - a));
        return list;
    }


class java.util.ArrayList写入耗时：140 | 96 | 105
class java.util.LinkedList写入耗时：183 | 182 | 164
class java.util.Vector写入耗时：64 | 61 | 65
class java.util.ArrayList随机访问耗时：18 | 13 | 19
class java.util.LinkedList随机访问耗时：25889 |  42322 | 40269
class java.util.Vector随机访问耗时：12 | 11 | 10
class java.util.ArrayList随机修改移除耗时：62822 | 59981 | 54657
class java.util.LinkedList随机修改移除耗时：7399 | 7852 | 7962
class java.util.Vector随机修改移除耗时：58302 | 60702 | 54133

Process finished with exit code 0

• 连续测试多次取均值

• 通过测试结果可以看出，写入速度Vector > ArrayList > LinkedList
  

• 随机访问速度：Vector > ArrayList > LinkedList
  

• 随机修改移除速度：LinkedList > Vector ~=(约等于)  ArrayList
  

综上：
在对List集合进行大量操作业务的时候，选用LinkedList最佳
在对随机访问，访问速度有要求时，选用ArrayList Vector最佳
在大量写入的业务场景时，选用Vector最佳，ArrayList稍逊
线程安全时选择Vector线程安全集合