A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 王震阳老师   /  2014-6-27 15:15  /  23267 人查看  /  347 人回复  /   1 人收藏 转载请遵从CC协议 禁止商业使用本文

请查看附件

Exam2.rar

635 Bytes, 阅读权限: 150, 下载次数: 1

评分

参与人数 1技术分 +1 收起 理由
王震阳老师 + 1 赞一个!

查看全部评分

回复 使用道具 举报

赞一个:
  1. import java.util.*;

  2. /**
  3. * ArrayList对象是一个可以在需要时扩容的数组,把原对象复制到新扩容的数组上,容量是,LinkedList对象是一个链表,容量没有限定
  4. * ArrayList有索引,遍历时可以使用索引,LinkedList遍历时使用必须严格按照从上一个找下一个的顺序执行
  5. * ArrayList适合于查找较多的场合,LinkedList适合于增删更多的 场合
  6. * @author Admin
  7. *
  8. */
  9. public class Exam2 {

  10.         public static void main(String[] args) throws Exception{
  11.                 ArrayList<Integer> al = new ArrayList<Integer>();
  12.                 LinkedList <Integer> ll = new LinkedList<Integer>();
  13.                 long sta=System.currentTimeMillis();
  14.                 for(int i =0;i<1000000;i++){
  15.                         al.add(new Integer(i));
  16.                 }
  17.                 long end=System.currentTimeMillis();
  18.                 System.out.println("ArrayList添加耗时:"+(end-sta));
  19.                 sta=System.currentTimeMillis();
  20.                 for(int i =0;i<1000000;i++){
  21.                         ll.add(new Integer(i));
  22.                 }
  23.                 end=System.currentTimeMillis();
  24.                 System.out.println("LinkedList添加耗时:"+(end-sta));
  25.                 sta=System.currentTimeMillis();
  26.                 for(int i =0;i<1000000;i++){
  27.                         if((i%10000)==0)
  28.                                 al.remove(new Integer(i));
  29.                 }
  30.                 end=System.currentTimeMillis();
  31.                 System.out.println("ArrayList删除耗时:"+(end-sta));
  32.                 sta=System.currentTimeMillis();
  33.                 for(int i =0;i<1000000;i++){
  34.                         if((i%10000)==0)
  35.                                 ll.remove(new Integer(i));
  36.                 }
  37.                 end=System.currentTimeMillis();
  38.                 System.out.println("LinkedList删除耗时:"+(end-sta));
  39.         }

  40. }
复制代码
回复 使用道具 举报
拿题。。。自习做
回复 使用道具 举报
回帖领题
回复 使用道具 举报

Demo2.rar (1.17 KB, 下载次数: 1)

评分

参与人数 1技术分 +1 收起 理由
王震阳老师 + 1 赞一个!

查看全部评分

回复 使用道具 举报

赞一个:
  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  3. import java.util.LinkedList;


  4. public class Demo2 {

  5.         /**
  6.          * 通过编码分别测试ArrayList 和 LinkedList 添加、删除对象时的耗时情况(精确到纳秒),并总结出以上两种集合的数据结构的不同之处。
  7.          * 在大学里学过数组和链表
  8.          * 数组内存是连续的,所以添加数据比较容易,而插入和删除数据就比较麻烦了,如果删除中间的一个数据,那么这个数据的后边内存都得跟着改动,插入同理。
  9.          * 链表结构就像链子一样一环扣一环,只能从这个找到它上一个和下一个,内存如果是连续的,也就和数组一样,如果链表内存是不连续的,那么它插入删除时候比较容易,
  10.          * 只需改一下前一个环和后一个环的指针就行了。链表查找数据也比较麻烦必须从前到后一个一个地查看。所以查看的时候就用HashSet比较好,它的内存地址是根据对象的字段.方法算出来的
  11.          * 所以要查这个数据的有没有的话,只需要拿到对象的信息,简单的算一下就知道地址,直接去目的地查找,如果不存在就代表没有这个数据了。
  12.          *
  13.          */
  14.         public static void main(String[] args) {
  15.                 // TODO Auto-generated method stub
  16.       long fistlistadd= System.nanoTime();
  17.       ArrayList<String> list=listAdd();
  18.       long endlistadd= System.nanoTime();
  19.       long fistlistremove=System.nanoTime();
  20.       listRemove(list);
  21.       long endlistremove=System.nanoTime();
  22.       long fistlinkedadd=System.nanoTime();
  23.        LinkedList<String> link=LinkedAdd();
  24.       long endlinkedadd=System.nanoTime();
  25.       long fistlinkedremove=System.nanoTime();
  26.       LinkedRemove(link);
  27.       long endlinkedremove=System.nanoTime();
  28.       System.out.println("ArrayList  添加对象耗时时间为"+(endlistadd-fistlistadd));
  29.       System.out.println("LinkedList 添加对象耗时时间为"+(endlinkedadd-fistlinkedadd));
  30.       System.out.println("ArrayList  删除对象耗时时间为"+(endlistremove-fistlistremove));
  31.       System.out.println("LinkedList 删除对象耗时时间为"+(endlinkedremove-fistlinkedremove));
  32.         }
  33.       public static ArrayList<String> listAdd(){
  34.               ArrayList<String> list=new ArrayList<String>();
  35.               list.add("1");
  36.               list.add("2");
  37.               list.add("3");
  38.               list.add("4");
  39.               list.add("5");
  40.               list.add("6");
  41.               list.add("7");
  42.               list.add("8");
  43.               list.add("9");
  44.               list.add("10");
  45.              
  46.               return list;
  47.       }
  48.       public static void listRemove(ArrayList<String> list){
  49.               
  50.               for(Iterator<String> it=list.listIterator();it.hasNext();){
  51.                       String s=it.next();
  52.                       it.remove();
  53.               }
  54.       }
  55.       public static LinkedList<String> LinkedAdd(){
  56.               LinkedList<String> link=new LinkedList<String>();
  57.               link.add("1");
  58.               link.add("2");
  59.               link.add("3");
  60.               link.add("4");
  61.               link.add("5");
  62.               link.add("6");
  63.               link.add("7");
  64.               link.add("8");
  65.               link.add("9");
  66.               link.add("10");
  67.               return link;
  68.       }
  69.       public static void LinkedRemove(LinkedList<String> link){
  70.               
  71.               for(Iterator<String> it=link.listIterator();it.hasNext();){
  72.                       String s=it.next();
  73.                       it.remove();
  74.               }
  75.       }
  76. }
复制代码
回复 使用道具 举报
请阳哥过目~~

QQ图片20141223214125.png (95.17 KB, 下载次数: 38)

QQ图片20141223214125.png

ArraylistAndLinkedlist.rar

1.21 KB, 阅读权限: 200, 下载次数: 1

评分

参与人数 1技术分 +1 收起 理由
王震阳老师 + 1 赞一个!

查看全部评分

回复 使用道具 举报

赞一个,好详细的测试:
  1. package gaoxin;

  2. import java.util.ArrayList;
  3. import java.util.LinkedList;

  4. /*ArrayList的添加和删除方法只有一种,而LinkedList中有许多种添加和删除的方法,我都分别测试了。
  5. * 我发现,在LinkedList中用add、push方法添加元素会比ArrayList的更慢,
  6. * 而用offer方法插入元素则比ArrayList添加元素快很多。
  7. * 我认为这是因为在向linkedlist插入元素时,它是无序插入的,只需要记录前后项。
  8. * 这要比arraylist的读取序号后添加元素要快许多
  9. *
  10. * 而在删除元素时,linkedlist的remove、pop、poll方法都要比Arraylist的更块,
  11. * 除了当linkedlist要删除指定元素时,才比arraylist慢。
  12. * 我认为这是因为linkedlist在查找元素时需要遍历每一个元素,这个查找的速度比arraylist要慢许多
  13. *
  14. * 总结:arrayList底层是用数组实现的list,元素是有序的存放在连续的空间里,
  15. *                   在查询时可直接用序号找到元素,但在插入元素时需要移动整个数组中的元素,效率较低。
  16. *            linkedlist底层是用双向链表实现的list,元素独立存放,插入或者删除元素时只需要记录前后项,因此比较快。
  17. *                   但由于元素之间是用节点相连的,在查询时也只能一个一个查找,所以查找效率较低。
  18. * */
  19. public class ArraylistAndLinkedlist {

  20.         public static void main(String[] args) throws Exception {
  21.                 // // TODO Auto-generated method stub
  22.                 ArrayList<String> arrayList = new ArrayList<String>();
  23.                 LinkedList<String> linkedList = new LinkedList<String>();
  24.                 long time;
  25.                 int[] shuzu = new int[10000];

  26.                 // 在添加前用time记住当前时间,精确到纳秒
  27.                 time = System.nanoTime();
  28.                 // 在arrayList中添加一万个元素
  29.                 for (int x : shuzu)
  30.                         arrayList.add("add元素");
  31.                 // 再用现在的时间减去添加前的时间
  32.                 System.out.println("在ArrayList中添加一万个元素耗时:"
  33.                                 + (System.nanoTime() - time)+ "纳秒");

  34.                 // 在linkedList中添加一万个元素
  35.                 time = System.nanoTime();
  36.                 for (int x : shuzu)
  37.                         linkedList.add("add元素");
  38.                 System.out.println("在linkedList中添加一万个元素耗时:"
  39.                                 + (System.nanoTime() - time) + "纳秒");

  40.                 // 用linkedList中push的方法添加一万个元素
  41.                 time = System.nanoTime();
  42.                 for (int x : shuzu)
  43.                         linkedList.push("push元素");
  44.                 System.out.println("在linkedList堆栈中添加一万个元素耗时:"
  45.                                 + (System.nanoTime() - time) + "纳秒");

  46.                 // 用linkedList中offer方法添加一万个元素
  47.                 time = System.nanoTime();
  48.                 for (int x : shuzu)
  49.                         linkedList.offer("offer元素");
  50.                 System.out.println("在linkedList中插入 一万个元素耗时:"
  51.                                 + (System.nanoTime() - time) + "纳秒");

  52.                 // 删除一万个arrayList的指定元素
  53.                 time = System.nanoTime();
  54.                 for (int x : shuzu)
  55.                         arrayList.remove("add元素");
  56.                 System.out.println("在arrayList中删除一万个指定的元素耗时:"
  57.                                 + (System.nanoTime() - time) + "纳秒");

  58.                 // 删除一万个linkedList的指定元素
  59.                 time = System.nanoTime();
  60.                 for (int x : shuzu)
  61.                         linkedList.remove("add元素");
  62.                 System.out.println("在linkedList中删除一万个指定的元素耗时:"
  63.                                 + (System.nanoTime() - time) + "纳秒");

  64.                 // 删除一万个linkedList的随机元素
  65.                 time = System.nanoTime();
  66.                 for (int x : shuzu)
  67.                         linkedList.remove();
  68.                 System.out.println("在linkedList中删除一万个随机元素耗时:"
  69.                                 + (System.nanoTime() - time) + "纳秒");

  70.                 // 用linkedList中pop方法删除一万个元素
  71.                 time = System.nanoTime();
  72.                 for (int x : shuzu)
  73.                         linkedList.pop();
  74.                 System.out.println("在linkedList堆栈中删除 一万个元素耗时:"
  75.                                 + (System.nanoTime() - time) + "纳秒");

  76.                 // 最后用linkedList中poll方法删除一万个元素
  77.                 for (int x : shuzu)
  78.                         linkedList.add("add元素");
  79.                 time = System.nanoTime();
  80.                 for (int x : shuzu)
  81.                         linkedList.poll();
  82.                 System.out.println("在linkedList中用poll删除 一万个元素耗时:"
  83.                                 + (System.nanoTime() - time) + "纳秒");

  84.         }
  85. }
复制代码
回复 使用道具 举报
再领一题
回复 使用道具 举报
领题楼。。。。
回复 使用道具 举报
我来回帖了
回复 使用道具 举报
看看~~~~
回复 使用道具 举报
领题来练练
回复 使用道具 举报
集合操作。领题。
回复 使用道具 举报
看看什么题目
回复 使用道具 举报
领题试试看
回复 使用道具 举报
领题回复
回复 使用道具 举报
回帖领题
回复 使用道具 举报
领以前的题~
回复 使用道具 举报
先看看题,还能领分吗?
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马