[知识整理]Java集合（一） - List

一、实现List的几个类：

ArrayList、LinkedList、CopyOnWriteArrayList、Vector

二、几个List底层的数据结构：

ArrayList - 数组列表

LinkedList - 双链表列表和队列(同时实现List和Queue接口)

Vector - 数组列表(加锁)

CopyOnWriteArrayList - 数组列表(读写分离)

三、List的几种基本操作比较

1、add操作比较

   /**
    * 比较add操作
    * @param minTimes 最小次数
    * @param maxTimes 最大次数
    * @param stepLen 步长
    */
   public static void compareAddMethod(int minTimes, int maxTimes, int stepLen) {
     Date begin = null;
     Date end = null;
     int times = minTimes;
     while(times < maxTimes) {

       //add: Vector
       Vector<Integer> vector = new Vector<Integer>();
       begin = new Date();
       for(int i=0; i<times; i++) {
         vector.add(i);
       }
       end = new Date();
       System.out.println("Vector add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //add: ArrayList
       ArrayList<Integer> arrayList = new ArrayList<Integer>();
       begin = new Date();
       for(int i=0; i<times; i++) {
         arrayList.add(i);
       }
       end = new Date();
       System.out.println("ArrayList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //add: LinkedList
       LinkedList<Integer> linkedList = new LinkedList<Integer>();
       begin = new Date();
       for(int i=0; i<times; i++) {
         linkedList.add(i);
       }
       end = new Date();
       System.out.println("LinkedList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //add: CopyOnWriteArrayList
       if(times<=100000) {
         CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
         begin = new Date();
         for(int i=0; i<times; i++) {
           copyOnWriteArrayList.add(i);
         }
         end = new Date();
         System.out.println("CopyOnWriteArrayList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
       }

       System.out.println("-------------------------------");
       times+=stepLen;
     }

运算结果：

minTimes = 0, maxTimes = 100000, stepLen = 30000

times	Vector(ms)	ArrayList(ms)	LinkedList(ms)	CopyOnWriteArrayList(ms)
0	0	0	0	0
30000	3	2	2	339
60000	3	4	1	992
90000	1	1	0	2257

结果分析：这里可以看出随着增加执行次数的增加CopyOnWriteArrayList所耗时增加较多，这是由于CopyOnWriteArrayList的读写策略造成。CopyOnWriteArrayList进行写操作，先对原底层数组进行复制，然后在复制数组进行写操作，最后复制数组对原数组引进行替换。这里的耗时消耗在复制数组上面，数组元素越多，所消耗的时间就越多。

minTimes = 0, maxTimes = 10000000, stepLen = 1000000

times	Vector(ms)	ArrayList(ms)	LinkedList(ms)
0	0	0	0
1000000	37	20	29
2000000	613	396	603
3000000	80	56	174
4000000	169	27	112
5000000	195	44	91
6000000	235	43	80
7000000	261	56	103
8000000	287	60	226
9000000	362	64	209

结果分析：这里ArrayList的插入比LinkedList快的原因是每次添加元素都是从数组末尾添加，数组直接通过索引在数组末尾添加元素，和LinkedList链表相比省却了寻找节点的时间，若是换成随机添加删除节点的操作，ArrayList就会比LinkedList慢了。而Vector虽然和ArrayList的底层数据结构一样(可变长的数组)，但是由于Vector是线程安全的，这导致执行效率会比较慢。

2、remove操作比较

   /**
    * 比较remove操作
    * @param minTimes 最小次数
    * @param maxTimes 最大次数
    * @param stepLen 步长
    */
   public static void compareRemoveMethod(int minTimes, int maxTimes, int stepLen) {
     Date begin = null;
     Date end = null;
     int times = minTimes;
     while(times < maxTimes) {

       //remove: Vector
       Vector<Integer> vector = new Vector<Integer>();
       for(int i=0; i<times; i++)
         vector.add(i);
       begin = new Date();
       for(int i=0; i<times; i++)
         vector.remove(0);
       end = new Date();
       System.out.println("Vector remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //remove: ArrayList
       ArrayList<Integer> arrayList = new ArrayList<Integer>();
       for(int i=0; i<times; i++)
         arrayList.add(i);
       begin = new Date();
       for(int i=0; i<times; i++)
         arrayList.remove(0);
       end = new Date();
       System.out.println("ArrayList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //remove: LinkedList
       LinkedList<Integer> linkedList = new LinkedList<Integer>();
       for(int i=0; i<times; i++)
         linkedList.add(i);
       begin = new Date();
       for(int i=0; i<times; i++)
         linkedList.remove(0);
       end = new Date();
       System.out.println("LinkedList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //remove: CopyOnWriteArrayList
       if(times<=100000) {
         CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
         for(int i=0; i<times; i++)
           copyOnWriteArrayList.add(i);
         begin = new Date();
         for(int i=0; i<times; i++)
           copyOnWriteArrayList.remove(0);
         end = new Date();
         System.out.println("CopyOnWriteArrayList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
       }

       System.out.println("-------------------------------");
       times+=stepLen;
     }
   }

运算结果：

minTimes = 0, maxTimes = 100000, stepLen = 30000

times	Vector(ms)	ArrayList(ms)	LinkedList(ms)	CopyOnWriteArrayList(ms)
0	0	0	0	0
30000	90	90	5	229
60000	356	351	1	921
90000	832	834	0	3199

结果分析：不出意外，CopyOnWriteArrayList的插入删除操作依旧是耗时最长的。值得注意的是，这里LinkedList的优势体现出来了，删除插入随机节点时链表操作比数组操作是更有效率的。

3、读取操作比较

   /**
    * 比较读取操作
    * @param minTimes 最小次数
    * @param maxTimes 最大次数
    * @param stepLen 步长
    */
   public static void compareReadMethod(int minTimes, int maxTimes, int stepLen) {
     Date begin = null;
     Date end = null;
     int times = minTimes;
     while(times < maxTimes) {

       //remove: Vector
       Vector<Integer> vector = new Vector<Integer>();
       for(int i=0; i<times; i++)
         vector.add(i);
       begin = new Date();
       for(int i=0; i<times; i++)
         vector.get(i);
       end = new Date();
       System.out.println("Vector get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //get: ArrayList
       ArrayList<Integer> arrayList = new ArrayList<Integer>();
       for(int i=0; i<times; i++)
         arrayList.add(i);
       begin = new Date();
       for(int i=0; i<times; i++)
         arrayList.get(i);
       end = new Date();
       System.out.println("ArrayList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       //get: LinkedList
       if(times<=100000) {
         LinkedList<Integer> linkedList = new LinkedList<Integer>();
         for(int i=0; i<times; i++)
           linkedList.add(i);
         begin = new Date();
         for(int i=0; i<times; i++)
           linkedList.get(i);
         end = new Date();
         System.out.println("LinkedList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
       }

       //get: CopyOnWriteArrayList
       CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
       for(int i=0; i<times; i++)
         copyOnWriteArrayList.add(i);
       begin = new Date();
       for(int i=0; i<times; i++)
         copyOnWriteArrayList.get(i);
       end = new Date();
       System.out.println("CopyOnWriteArrayList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");

       System.out.println("-------------------------------");
       times+=stepLen;
     }
   }

运算结果：

minTimes = 0, maxTimes = 100000, stepLen = 30000

times	Vector(ms)	ArrayList(ms)	LinkedList(ms)	CopyOnWriteArrayList(ms)
0	0	0	0	0
30000	2	2	334	0
60000	1	1	1313	0
90000	0	0	2945	0

结果分析：这里为什么LinkedList耗时比较长就不需要说明，这里Vector如果在同时频繁写操作的时候读写耗时便会比较长，而由于CopyOnWriteArrayList使用读写分离测的策略（写操作在复制数组中进行，读操作在原数组里面进行）平衡了线程安全和执行性能的矛盾。

四、小结

1、在List元素数量比较少的时候没必要纠结采用哪个List，因为规模小时根本体现不出什么差别，此时要注意是否选取线程安全的List，一般情况是不采取线程安全的List，而是在ArrayList和LinkedList之间选择。

2、Vector - 底层数据结构为可变长数组，数组长度按100%增长，线程安全，写效率低，读效率在多线程环境下也低。

3、ArrayList - 底层数据结构为可变长数组，数组长度按50%增长，线程不安全，随机插入删除操作效率低，随机读取修改元素效率高。

4、LinkedList - 底层数据结构为双向链表，线程不安全，随机插入删除操作效率高，随机读取修改元素效率低。

5、CopyOnWriteArrayList - 底层数据结构为可变长数组，线程安全，写效率低，读效率在多线程环境下也高，但是由于读写分离，读数据可能出现过时的情况（不可重复读）

6、这里CopyOnWriteArrayList读写分离的思想值得我学习。