集合篇-----ArrayList与LinkedList之间的那些小事

各自特性:

ArrayList  ： 是一由连续的内存块组成的数组，范围大小可变的，当不够时增加为原来1.5倍大小,数组。 ：调用trimToSize方法，使得存储区域的大小调整为当前元素数量所需要的空间大小，垃圾回收器将会回收多余存储空间。
LinkedList
： 是由随机内存块通过指针连接起来的，范围大小可变的，当不够时增加为原来2倍大小,一个双向链表，

 

书上得来： 结论一 ： ArrayList集合访问查找比LinkedList集合速度快，

                  结论二 ： LinkedList集合增删元素比ArrayList集合速度快。

原因：

      
ArrayList是连续的内存地址，访问时根据下标，即与首地址的偏移量来确定元素；LinkedList集合是随机内存地址，查找时需要遍历链表，如果需要查找元素位于链表末尾，也只有老老实实把前面的挨个儿查看比较一番，所以有了结论一。

     
ArrayList集合每删除一个元素，GC会回收没有引用的那块内存地址，所以删除一个元素整个的集合元素要移动一下位置，那么如果删除了第一个元素，很明显需要把后面的n-1个元素向前移动一个单位；LinkedList集合的随机内存地址数据结构使得每增加和删除一个元素，只需要修改前后两个元素的头尾指针即可，所以有了结论二。

 

看上去上面说的很有道理。。但是。。。这是真的吗？？？？？？

 

动手试一试，你会发现神奇之处！！！

 

 

 

public class Collection_ArrayListPK_LinkedList {

 

    public static void main(String[] args)

    {

        // 测试访问比较

        TestLook();

        // 测试添加

//        TestAdd();

 

}

public static void TestLook()

    {

        long [] timeBegin = new long[2];

        long [] timeEnd = new long[2];

        

        Integer [] ia = new Integer[5000];

        for(int i=0;i<ia.length;i++)

            ia[i] = i ;

        

        Random rm  = new Random();

        

        int temp ;

        

        /**

         *  测试对大小为5000 的ArrayList进行100000次随机访问所用时间 

         */

        List alist = new ArrayList(Arrays.asList(ia));

        

        timeBegin[0] = System.currentTimeMillis();

        for(int k=0;k<100000;k++)

        {

            temp = (Integer)alist.get(rm.nextInt(5000));

        }

        timeEnd[0] = System.currentTimeMillis();

        

        /**

         *  测试对大小为5000 的LinkedList进行100000次随机访问所用时间

         */

        List llist = new LinkedList(Arrays.asList(ia));

        

        timeBegin[1] = System.currentTimeMillis();

        for(int k=0;k<100000;k++)

        {

            temp = (Integer)llist.get(rm.nextInt(5000));

        }

        timeEnd[1] = System.currentTimeMillis();

        

        System.out.println("+++分析对大小为5000 的LinkedList类型和ArrayList类型进行的100000次随机访问所用时间比较+++");

        System.out.println("ArrayList的100000次随机访问速度测试:");

        System.out.println("耗时:"+(timeEnd[0]-timeBegin[0])+"ms");

        System.out.println("LinkedList的100000次随机访问速度测试");

        System.out.println("耗时:"+(timeEnd[1]-timeBegin[1])+"ms");

        

        /*

         * 随机修改测试

         */

    }

证明第一条结论：

public static void TestAdd()

    {

        long [] timeBegin = new long[2];

        long [] timeEnd = new long[2];

        Integer [] ia = new Integer[5000];

        Random rm  = new Random();

        

        int temp ;

        

        /**

         *  测试对大小为5000 的ArrayList进行100000次随机访问所用时间 

         */

        List alist = new ArrayList(Arrays.asList(ia));

        

        timeBegin[0] = System.currentTimeMillis();

        for(int k=0;k<10000;k++)

        {

            alist.add(rm.nextInt(5000), 1);

        }

        timeEnd[0] = System.currentTimeMillis();

        

        List llist = new LinkedList(Arrays.asList(ia));

        

        timeBegin[1] = System.currentTimeMillis();

        for(int k=0;k<10000;k++)

        {

            llist.add(rm.nextInt(5000), 1);

        }

        timeEnd[1] = System.currentTimeMillis();

        

        System.out.println("+++分析对大小为5000 的LinkedList类型和ArrayList类型进行的10000次随机添加所用时间比较+++");

        System.out.println("ArrayList的10000次添加速度测试:");

        System.out.println("耗时:"+(timeEnd[0]-timeBegin[0])+"ms");

        System.out.println("LinkedList的10000次添加速度测试");

        System.out.println("耗时:"+(timeEnd[1]-timeBegin[1])+"ms");

}

        

 

public static void TestAdd()

    {

        long [] timeBegin = new long[10];

        long [] timeEnd = new long[10];

        Integer [] ia = new Integer[5000];

        Random rm  = new Random();

        

        int temp ;

        

        /**

         *  测试对大小为5000 的ArrayList进行100000次随机访问所用时间 

         */

        List alist = new ArrayList(Arrays.asList(ia));

// 100    

        timeBegin[0] = System.currentTimeMillis();

        for(int k=0;k<100;k++)

        {

            alist.add(rm.nextInt(5000), 1);

        }

        timeEnd[0] = System.currentTimeMillis();

// 1000

        timeBegin[1] = System.currentTimeMillis();

        for(int k=0;k<1000;k++)

        {

            alist.add(rm.nextInt(5000), 1);

        }

        timeEnd[1] = System.currentTimeMillis();

//10000

        timeBegin[2] = System.currentTimeMillis();

        for(int k=0;k<10000;k++)

        {

            alist.add(rm.nextInt(5000), 1);

        }

        timeEnd[2] = System.currentTimeMillis();

// 50000

        timeBegin[6] = System.currentTimeMillis();

        for(int k=0;k<50000;k++)

        {

            alist.add(rm.nextInt(5000), 1);

        }

        timeEnd[6] = System.currentTimeMillis();

// 100000

        timeBegin[8] = System.currentTimeMillis();

        for(int k=0;k<100000;k++)

        {

            alist.add(rm.nextInt(5000), 1);

        }

        timeEnd[8] = System.currentTimeMillis();

            

        List llist = new LinkedList(Arrays.asList(ia));

// 100        

        timeBegin[3] = System.currentTimeMillis();

        for(int k=0;k<100;k++)

        {

            llist.add(rm.nextInt(5000), 1);

        }

        timeEnd[3] = System.currentTimeMillis();

        

// 1000        

        timeBegin[4] = System.currentTimeMillis();

        for(int k=0;k<1000;k++)

        {

            llist.add(rm.nextInt(5000), 1);

        }

        timeEnd[4] = System.currentTimeMillis();

// 10000        

        timeBegin[5] = System.currentTimeMillis();

        for(int k=0;k<10000;k++)

        {

            llist.add(rm.nextInt(5000), 1);

        }

        timeEnd[5] = System.currentTimeMillis();

// 50000        

        timeBegin[7] = System.currentTimeMillis();

        for(int k=0;k<50000;k++)

        {

            llist.add(rm.nextInt(5000), 1);

        }

        timeEnd[7] = System.currentTimeMillis();

// 100000        

        timeBegin[9] = System.currentTimeMillis();

        for(int k=0;k<100000;k++)

        {

            llist.add(rm.nextInt(5000), 1);

        }

        timeEnd[9] = System.currentTimeMillis();

                        

        System.out.println("+++分析对大小为5000 的LinkedList类型和ArrayList类型进行的10000次随机添加所用时间比较+++");

        

        System.out.println("ArrayList的添加速度测试:");

        System.out.println("100次");

        System.out.println("ArrayList -耗时:"+(timeEnd[0]-timeBegin[0])+"ms");

        System.out.println("LinkedList -耗时:"+(timeEnd[3]-timeBegin[3])+"ms");

        System.out.println("1000次");

        System.out.println("ArrayList -耗时:"+(timeEnd[1]-timeBegin[1])+"ms");

        System.out.println("LinkedList -耗时:"+(timeEnd[4]-timeBegin[4])+"ms");

        System.out.println("10000次");

        System.out.println("ArrayList -耗时:"+(timeEnd[2]-timeBegin[2])+"ms");

        System.out.println("LinkedList -耗时:"+(timeEnd[5]-timeBegin[5])+"ms");

        System.out.println("50000次");

        System.out.println("ArrayList -耗时:"+(timeEnd[6]-timeBegin[6])+"ms");

        System.out.println("LinkedList -耗时:"+(timeEnd[7]-timeBegin[7])+"ms");

        System.out.println("100000次");

        System.out.println("ArrayList -耗时:"+(timeEnd[8]-timeBegin[8])+"ms");

System.out.println("LinkedList -耗时:"+(timeEnd[9]-timeBegin[9])+"ms");

}

 

结果一：

+++分析对大小为5000 的LinkedList类型和ArrayList类型进行的100000次随机访问所用时间比较+++

ArrayList的100000次随机访问速度测试:

耗时:27ms  

LinkedList的100000次随机访问速度测试

耗时:225ms

 

补充： 多次测试证明第一条结论是对的。。。这哈踏实了。

 

结果二：

+++分析对大小为5000 的LinkedList类型和ArrayList类型进行的10000次随机添加所用时间比较+++

ArrayList的添加速度测试:

100次

ArrayList -耗时:2ms

LinkedList -耗时:3ms

1000次

ArrayList -耗时:2ms

LinkedList -耗时:5ms

10000次

ArrayList -耗时:46ms

LinkedList -耗时:91ms

50000次                                 
有没有发现新大陆的感觉？？？

ArrayList -耗时:517ms

LinkedList -耗时:708ms

100000次

ArrayList -耗时:4316ms

LinkedList -耗时:1455ms

 

补充： 看来第二个结论有点问题咯。。说得太绝对了。。。

 

分析后者原因： 得出第二个结论主要是考虑增删元素的处理的时间去了，忽略了一个问题，就是查找到该元素的时间，ArrayList 集合
虽然处理慢，但是查找很快。。有优势的也有弱势之处，当优势和弱势比例不同自然而然结果就不一样。。所以看到新大陆了是应该的。。。