通过代码测试发现ArrayList集合在对象的增删方法时间远远多于LinkedList集合所花费的时间，但是ArrayList集合在对象的查询搜索方面时间小于LinkedList集合所花费的时间，然后在结合JavaAPI帮组文档我们我们可以得出ArrayList集合底层使用的数据结构是数组，而LinkedList底层使用数据结构是链表。

佛说 发表于 2014-12-7 22:57
通过代码测试发现ArrayList集合在对象的增删方法时间远远多于LinkedList集合所花费的时间，但是ArrayList集 ...

1. import java.util.*;
   
2. class JavaCollection1_62
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                
   
7.                 ArrayList<Person>al=new ArrayList<Person>();
   
8.                 ArrayListAdd(al);
   
9.                 ArrayListRemove(al);
   
10.                 LinkedList<Person> ll=new LinkedList<Person>();
    
11.                 LinkedListAdd(ll);
    
12.                 LinkedListRemove(ll);
    
13. 
    
14.         }
    
15.         public static void ArrayListAdd(ArrayList<Person> al)
    
16.         {
    
17.                 long timeStart=System.currentTimeMillis();
    
18.                 for(int i=0;i<10000;i++)
    
19.                 {
    
20.            al.add(new Person("xt",12));
    
21.                 }
    
22.                 long timeEnd=System.currentTimeMillis();
    
23.                 long totalTime=timeEnd-timeStart;
    
24.                 System.out.println("使用ArrayList添加对象花费的时间："+totalTime*1000);
    
25.         }
    
26.         public static void ArrayListRemove(ArrayList<Person> al)
    
27.         {
    
28.                 long timeStart=System.currentTimeMillis();
    
29.                 for(Iterator<Person> it=al.iterator();it.hasNext();)
    
30.                 {
    
31.                         it.next();
    
32.                         it.remove();
    
33.                 }
    
34.                 long timeEnd=System.currentTimeMillis();
    
35.                 long totalTime=timeEnd-timeStart;
    
36.                 System.out.println("使用ArrayList删除对象花费的时间："+totalTime*1000);
    
37.         }
    
38.         public static void LinkedListAdd(LinkedList<Person> ll)
    
39.         {
    
40.                 long timeStart=System.currentTimeMillis();
    
41.                 for(int i=0;i<10000;i++)
    
42.                 {
    
43.            ll.addFirst(new Person("aaa",12));
    
44.                 }
    
45.                 long timeEnd=System.currentTimeMillis();
    
46.                 long totalTime=timeEnd-timeStart;
    
47.                 System.out.println("使用LinkedList添加对象花费的时间："+totalTime*1000);
    
48.         }
    
49.         public static void LinkedListRemove(LinkedList<Person> ll)
    
50.         {
    
51.                 long timeStart=System.currentTimeMillis();
    
52.                 for(Iterator<Person> it=ll.iterator();it.hasNext();)
    
53.                 {
    
54.                         it.next();
    
55.                         it.remove();
    
56.                 }
    
57.                 long timeEnd=System.currentTimeMillis();
    
58.                 long totalTime=timeEnd-timeStart;
    
59.                 System.out.println("使用LinkedList删除对象花费的时间："+totalTime*1000);
    
60.         }
    
61. }
    
62. class Person
    
63. {
    
64.         private String name;
    
65.         private int age;
    
66.         Person(String name,int age)
    
67.         {
    
68.                 this.name=name;
    
69.                 this.age=age;
    
70.         }
    
71.         public String getName()
    
72.         {
    
73.                 return name;
    
74.         }
    
75.         public int getAge()
    
76.         {
    
77.                 return age;
    
78.         }
    
79. }
    

复制代码

很给力。

wangzheng406 发表于 2014-12-9 14:26

你写了这么多代码，有没考虑ArrayList和LinkedList底层数据结构的差异?

1. import java.util.*;
   
2. class HeimaCollectionDemo{
   
3.         public static void main (String []args){
   
4.                 ArrayList a = new ArrayList();
   
5.                 LinkedList l = new LinkedList();
   
6.                 for(int x = 1 ;x<20000;x++ ){
   
7.                         a.add(x+"");
   
8.                         l.add(x+"");
   
9.                 }
   
10.                
    
11.                 String x = "15000";
    
12.                 int y = 15000;
    
13.                 System.out.println("ArrayList不指定角标时候添加元素");
    
14.                 add(a,x);
    
15.                 System.out.println("ArrayList删除一个不知道角标的元素");
    
16.                 del(a,x);
    
17.                 System.out.println("ArrayList向指定角标添加元素");
    
18.                 add(a,y);
    
19.                 System.out.println("ArrayList删除指定角标元素");
    
20.                 del(a,y);
    
21. 
    
22.                 System.out.println("=========================================");
    
23.                 System.out.println("LinkedList不指定角标时候添加元素");
    
24.                 add(l,x);
    
25.                 System.out.println("LinkedList删除一个不知道角标的元素");
    
26.                 del(l,x);
    
27.                 System.out.println("LinkedList向指定角标添加元素");
    
28.                 add(l,y);
    
29.                 System.out.println("LinkedList删除指定角标元素");
    
30.                 del(l,y);
    
31.                
    
32.         }
    
33.         public static void del(List list ,int index){
    
34.                 if(list instanceof ArrayList        )
    
35.                         list = (ArrayList)list;
    
36.                 else
    
37.                         list = (LinkedList)list;
    
38.                 long start = System.nanoTime();                                 
    
39.                 list.remove(index);
    
40.                 long end = System.nanoTime();
    
41.                 System.out.println( "  "+ (end - start));
    
42.         }       
    
43.         public static void add(List list ,int index){
    
44.                 if(list instanceof ArrayList        )
    
45.                         list = (ArrayList)list;
    
46.                 else
    
47.                         list = (LinkedList)list;
    
48.                 long start = System.nanoTime();         
    
49.                 list.add(index,1);
    
50.                 long end = System.nanoTime();
    
51.                 System.out.println( "  "+ (end - start));
    
52.         }       
    
53.        
    
54.        
    
55.         public static void del(List list ,String index){
    
56.                 if(list instanceof ArrayList        )
    
57.                         list = (ArrayList)list;
    
58.                 else
    
59.                         list = (LinkedList)list;
    
60.                 long start = System.nanoTime();                                 
    
61.                 list.remove(index);
    
62.                 long end = System.nanoTime();
    
63.                 System.out.println( "  "+ (end - start));
    
64.         }       
    
65.         public static void add(List list ,String index){
    
66.                 if(list instanceof ArrayList        )
    
67.                         list = (ArrayList)list;
    
68.                 else
    
69.                         list = (LinkedList)list;
    
70.                 long start = System.nanoTime();
    
71.                 list.add(index);
    
72.                 long end = System.nanoTime();
    
73.                 System.out.println( "  "+ (end - start));
    
74.         }       
    
75.        
    
76.        
    
77. }   

复制代码

看看是什么题目

看题学习

阳哥交题:)

刚才忘记写上纳秒了

看看题 争分喽

看看  看看   看看题

回帖领题

回帖领题

复习巩固， 来看题啦

谢谢阳哥，指导

领题来了，虽然没有全部完成学习流程，但是学完一个知识点，我就找阳哥领题练习，哈哈。

回帖拿题:lol

领题来啦

刚刚才看过集合的视频，来练下手~

回帖领题

请查看附件