ArraryList和LinkeList

集合（list）与数组的区别：
1.集合长度不固定，数组长度固定；换句话说，集合是动态的，数组是静态的。（重点）
2.集合可以指定下标索引，并且会自动给插入位置向后挪位置，而不是像数组那样覆盖。

按照ArraryList 和 LinkedList特性，，，发现ArraryList 以数组数据结构方式保存，LinkedList以数据链表方式保存、。。。上面的场景遇到问题了，既要add也需要get，这样的话，哪个都不适合了。。。

     现在如何抉择使用哪个呢？ （先提出问题，后面有答案）

遇到这样的问题，我就想到掌握的这些概念都是出于理论层面，没有从实际代码性能中查看，到底差距有多大，下面就已实际代码性能上面分析问题，然后看看add的性能差距多大，get的性能差距多大，然后作为我们选择使用的一个参考。。。

ArrayList是动态扩展的数组，LinkedList是双向链表的数据结构。

所以大多数人持有这样观点：

AL易于查找；有频繁的插入、删除使用AL不合适，因涉及到其他元素左右移动问题；

LL不易于查找；有频繁的插入、删除操作使用LL比较合适，因只涉及修改前后连接；

这里先不对以上观点给出我的结论，也没有非常仔细跟踪过java源码。这里给出一个测试样例及测试结果。测试结果的结论似乎不支持以上说法。当然，可能有涉及到测试样例的合理性、数据量是否足够大的问题，但个人认为这个例子还是合理的。大家有疑问的可以提出。欢迎大家多多交流。

[java]  view plain  copy

1. @SuppressWarnings("all")  
2.     static final class ArrayListAndLinkedArrayList{  
3.         static final int N=100000;  
4.         static long timeList(List list){  
5.             long start=System.currentTimeMillis();  
6.             Object o = new Object();  
7.             for(int i=0;i<N;i++) {  
8.                 int id = (int) new java.util.Random().nextInt((i==0)?(i+1):i);  
9. //              System.out.println(id);  
10.                 list.add(id, o);  
11.             }  
12.             return System.currentTimeMillis()-start;  
13.         }  
14.         static long readList(List list){  
15.             long start=System.currentTimeMillis();  
16.             for(int i=0,j=list.size();i<j;i++){  
17.                 int id = (int) new java.util.Random().nextInt((i==0)?(i+1):i);  
18.                 list.get(id);  
19.             }  
20.             return System.currentTimeMillis()-start;  
21.         }  
22.   
23.         static List addList(List list){  
24.             Object o = new Object();  
25.             for(int i=0;i<N;i++) {  
26.                 int id = (int) new java.util.Random().nextInt((i==0)?(i+1):i);  
27.                 list.add(id, o);  
28.             }  
29.             return list;  
30.         }  
31.           
32.         static long removeList(List list){  
33.             list=addList(list);  
34.             long start=System.currentTimeMillis();  
35.             for(int i=0;i<N;i++) {  
36.                 int id = (int) new java.util.Random().nextInt((N-i)==0?(1):N-i);  
37.                 list.remove(id);  
38.             }  
39.             return System.currentTimeMillis()-start;  
40.         }  
41.           
42.         public static void main(String[] args) {  
43.             System.out.println("ArrayList添加"+N+"条耗时："+timeList(new ArrayList()));  
44.             System.out.println("LinkedList添加"+N+"条耗时："+timeList(new LinkedList()));  
45.   
46.             List list1=addList(new ArrayList<>());  
47.             List list2=addList(new LinkedList<>());  
48.             System.out.println("ArrayList查找"+N+"条耗时："+readList(list1));  
49.             System.out.println("LinkedList查找"+N+"条耗时："+readList(list2));  
50.               
51.             System.out.println("ArrayList删除"+N+"条耗时："+removeList(new ArrayList()));  
52.             System.out.println("LinkedList删除"+N+"条耗时："+removeList(new LinkedList()));  
53.               
54.         }  
55.     }  

测试结果

[java]  view plain  copy

1.   

[html]  view plain  copy

1.   

[java]  view plain  copy

1. 100000条  
2.   
3. ArrayList添加100000条耗时：1719  
4. LinkedList添加100000条耗时：56433  
5. ArrayList查找100000条耗时：22  
6. LinkedList查找100000条耗时：4968  
7. ArrayList删除100000条耗时：641  
8. LinkedList删除100000条耗时：57121  

[html]  view plain  copy

1.   

[java]  view plain  copy

1. 5000条  
2.   
3. ArrayList添加5000条耗时：25  
4. LinkedList添加5000条耗时：77  
5. ArrayList查找5000条耗时：5  
6. LinkedList查找5000条耗时：136  
7. ArrayList删除5000条耗时：13  
8. LinkedList删除5000条耗时：62  

当然，这里random会耗费一些时间，但这对两者是相等的，所以可以忽略。

以上的测试结果，似乎总是支持AL比LL的各方面都要好。

所以在这里大家可以探讨下这个问题：

是

AL易于查找；有频繁的插入、删除使用AL不合适，因涉及到其他元素左右移动问题；

LL不易于查找；有频繁的插入、删除操作使用LL比较合适，因只涉及修改前后连接；

还是

AL比LL的各方面都要好。