各自特性:
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 集合 虽然处理慢,但是查找很快。。有优势的也有弱势之处,当优势和弱势比例不同自然而然结果就不一样。。所以看到新大陆了是应该的。。。
posted on 2013-10-19 11:34  Coffee_Guy  阅读(1014)  评论(0编辑  收藏  举报