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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 杨习平 中级黑马   /  2012-8-17 20:05  /  2023 人查看  /  3 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

哪位高手能指点指点说说 ArrayList,vector,LinkedList存储性能和特性?最好是结合你的示例代码讲解一下,,,,我是晕了,

评分

参与人数 1技术分 +1 收起 理由
田建 + 1 加油,自己把集合整体从上到下整理一遍就清.

查看全部评分

3 个回复

正序浏览
看不懂的话再看两遍视频就懂了。
回复 使用道具 举报
本帖最后由 郑枫 于 2012-8-18 00:22 编辑
  1.         List:        元素是有序的,元素可以重复,因为该集合体系有索引
  2.                 |--ArrayList;底层的数据结构使用的是数组结构
  3.                                           特点:查询速度快,但是增删稍慢,线程不同步
  4.                 |--LinkedList:底层使用的是链表数据结构。
  5.                                           特点:增删速度慢,但是查询速度快,线程不同步
  6.                 |--Vector:底层是数据结构,线程同步。
  7.                                    被ArrayList替代了,因为效率低。

  8. ----------------------------------------------------------------------------

  9.         枚举
  10.                
  11.         枚举就是Vector特有的取出方式,发现枚举和迭代器很像,其实枚举和迭代器是一样的
  12. 因为枚举的名称以及方法的名称过长,所以被迭代器取代了,枚举郁郁而终了。
  13. 枚举示例:

  14.         Vector v = new Vector();
  15.                
  16.                 v.add("java01");
  17.                 v.add("java02");
  18.                 v.add("java03");
  19.                 v.add("java04");

  20.                 Enumeration en = v.elements();
  21.                 while(en.hasMoreElements())
  22.                 {
  23.                         sop(en.nextElement());
  24.                         //如果此枚举对象至少还有一个可提供的元素
  25.                         //则返回此枚举的下一个元素。
  26.                 }


  27. --------------------------------------------------------------------
  28.                 LinkedList
  29.         
  30. 特有方法:
  31.                   addFirst();  将指定元素插入此列表的开头
  32.                   addLast();        将指定元素插入此列表的结尾

  33.                   getFirst();        返回列表的第一个元素
  34.                   getLast();        返回此列表的最后一个元素
  35.                   获取元素,但不删除元素,如果集合中没有元素,会出现异常
  36.                   
  37.                   removeFirst();        移除第一个元素
  38.                   removeLast();                移除最后一个元素
  39.                   获取元素,但元素呗删除,如果集合中没有元素。会返回异常

  40. 在1.6出现了替代方法。
  41.                         
  42.                         offerFirst();        在此列表开始插入指定元素
  43.                         offerLast();        在此列表末尾插入指定元素

  44.                         peekFirst();        获取但不移除此别表的第一个元素
  45.                         peekLast();                获取但不移除此列表的最后一个元素
  46.                         获取元素,但不删除元素,如果列表为空,返回null

  47.                         poollFirst();        获取并移出第一个元素
  48.                         poollLast();        获取并移除最后一个元素
  49.                         获取元素,但元素被删除,如果列表为空,返回null

  50.         LikedList list = new LinkedList();

  51.         link.addLast("aaa");//在列表末尾插入指定元素


  52.         whlie(!link.isEmpty())
  53.         {
  54.                 sop(Link.remvoeLast());
  55.                 //移除并返回此列表的最后一个元素
  56.         }

  57. ----------------------------------------------------------
  58.                 LinkedList 练习

  59. 使用LinkedList模拟一个堆栈或者队列数据结构
  60. 堆栈:先进后出 如同一个杯子
  61. 队列:先进先出 如同一个水管



  62. class LinkedListDemo
  63. {
  64.         public static void main(String[] args)
  65.         {
  66.                 LinkedList<String> link = new LinkedList<String>();
  67.                 link.add("java01");
  68.                 link.add("java02");
  69.                 link.add("java03");
  70.                 link.add("java04");
  71.                
  72.                 while (!link.isEmpty())
  73.                 {
  74.                         System.out.println(link.removeLast());
  75.                 }
  76.         }        
  77. }

  78. 堆栈:插首返末  插末返首
  79. 队列:插首返首  插末返末

  80. -------------------------------------------------------------------------

  81. ArrayList 练习

  82. 去除ArrayList集合中的重复元素

  83. 思路,
  84.         1,先定义一个临时容器。
  85.         2,遍历临时容器。
  86.         3,遍历过程中如果历时容器里面没有重复元素就存进去。

  87. import java.util.*;
  88. class ArrayListDemo
  89. {
  90.         public static void main(String[] args)
  91.         {
  92.                 ArrayList al = new ArrayList();

  93.                 al.add("java01");
  94.                 al.add("java02");
  95.                 al.add("java01");
  96.                 al.add("java02");
  97.                 al.add("java03");
  98.                
  99.                 System.out.println(al);
  100.                 //用临时容器接收一个ArrayList赋值到al上
  101.                 al = singleElement(al);

  102.                 System.out.println(al);
  103.         }

  104.         public static ArrayList singleElement(ArrayList al)
  105.         {
  106.                 //定义一个临时容器
  107.                 ArrayList newAl = new ArrayList();
  108.                 //遍历临时容器
  109.                 Iterator it = al.iterator();

  110.                 while (it.hasNext())
  111.                 {
  112.                         //返回迭代的下一个元素 用Object的obj接收一下。
  113.                         Object obj = it.next();
  114.                         //如果临时容器里没有迭代的下一个元素
  115.                         //那么就储存到临时容器里面。
  116.                         if (!newAl.contains(obj))
  117.                                 newAl.add(obj);               
  118.                 }
  119.                 return newAl;
  120.         }
  121. }

  122. ---------------------------------------------------------------------
  123. /*
  124. ArrayList 练习

  125. 将自定义对象为元素存到ArrayList集合中,并去除重复元素。
  126. 比如:存入人对象,同姓名同年龄视为同一个人,为重复元素

  127. List 集合判断元素是否相同,依据是元素的equals方法




  128. import java.util.*;

  129. class person
  130. {
  131.         private String name;
  132.         private int age;
  133.         person(String name,int age)
  134.         {
  135.                 this.name = name;
  136.                 this.age = age;
  137.         }
  138.         
  139.         public boolean equals(Object obj)
  140.         {
  141.                 if (!(obj instanceof person))
  142.                         return false;

  143.                 person p =(person)obj;

  144.                 return this.name.equals(p.name) && this.age == p.age;

  145.                
  146.         }

  147.         public String getName()
  148.         {
  149.                 return name;
  150.         }
  151.         public int getAge()
  152.         {
  153.                 return age;
  154.         }


  155. }
  156. class ArrayListTest
  157. {
  158.         public static void sop(Object obj)
  159.         {
  160.                 System.out.println(obj);
  161.         }
  162.         public static void main(String[] args)
  163.         {
  164.                 ArrayList al = new ArrayList();
  165.                
  166.                 al.add(new person("java01",10));
  167.                 al.add(new person("java04",40));
  168.                 al.add(new person("java03",30));
  169.                 al.add(new person("java02",20));
  170.                 al.add(new person("java02",20));
  171.                         

  172.                 al = singleElement(al);
  173.                

  174.                 Iterator it = al.iterator();

  175.                 while (it.hasNext())
  176.                 {
  177.                         Object obj = it.next();
  178.                         person p =(person)obj;

  179.                         sop(p.getName()+"....."+p.getAge());
  180.                 }
  181.         }


  182.         public static ArrayList singleElement(ArrayList al)
  183.         {
  184.                 //定义一个临时容器。
  185.                 ArrayList newAl = new ArrayList();

  186.                 Iterator it = al.iterator();

  187.                 while(it.hasNext())
  188.                 {
  189.                         Object obj = it.next();

  190.                         if(!newAl.contains(obj))
  191.                                 newAl.add(obj);

  192.                 }

  193.                 return newAl;
  194.         }
  195. }
复制代码
其他参考楼上。
今天刚总结的。
回复 使用道具 举报
ArrayList:底层的数组结构使用的是数组结构。特点:查询速度快。但是增删稍慢,线程不同步。
                         判断元素相同或存储元素是依赖equals
LinkedList:底层使用的是链表数组结构。特点:增删速度快,查询速度慢。
Vector:底层是数组数据结构。线程同步。查询增删都慢。被ArrayList替代了。
Vector是元老级的了,从JDK 1.0就开始有了,那个时候集合框架还没有呢。而ArrayList是JDK 1.2才有的,才出现的集合框架。
这几个代码体现不明显,我仿照视频画了个图给你看,就明白了。
再给你一些开发时的建议:
如果取到的元素特别多,涉及到频繁的增删操作的时候,用LinkedList
涉及到增删操作但是不频繁,用ArrayList或者LinkedList均可。
涉及到增删也涉及到查询,建议使用ArrayList

希望能够帮到你。

无标题.jpg (41.56 KB, 下载次数: 6)

无标题.jpg

评分

参与人数 1技术分 +1 收起 理由
田建 + 1 赞一个!

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马