Java基础之集合框架(一)--Collection、List、LinkedList、HashSet

转载 于 2013-07-27 16:48:18 发布 · 682 阅读 · 1

本文深入解析Java集合框架的核心组件，包括Collection接口及其子类List、Set的基本概念、特性、操作方法以及常用实现类如ArrayList、LinkedList、HashSet等的详细说明。

集合框架图：


Collection接口：

[java]  view plain copy
  1. import java.util.*;  
  2.   
  3. /* 
  4. Collection定义了集合框架的共性功能。 
  5. 1，添加 
  6.     add(e); 
  7.     addAll(collection); 
  8.  
  9. 2，删除 
  10.     remove(e); 
  11.     removeAll(collection); 
  12.     clear(); 
  13.  
  14. 3，判断。 
  15.     contains(e); 
  16.     isEmpty(); 
  17.  
  18. 4，获取 
  19.     iterator(); 
  20.     size(); 
  21.  
  22. 5，获取交集。 
  23.     retainAll(); 
  24.  
  25. 6，集合变数组。 
  26.     toArray(); 
  27.  
  28.  
  29.  
  30. 1，add方法的参数类型是Object。以便于接收任意类型对象。 
  31.  
  32. 2，集合中存储的都是对象的引用(地址) 
  33.  
  34.  
  35. 什么是迭代器呢？ 
  36. 其实就是集合的取出元素的方式。 
  37. 如同抓娃娃游戏机中的夹子。 
  38.  
  39. 迭代器是取出方式，会直接访问集合中的元素。 
  40. 所以将迭代器通过内部类的形式来进行描述。 
  41. 通过容器的iterator()方法获取该内部类的对象。 
  42.  
  43.  
  44. */  
  45. class  CollectionDemo  
  46. {  
  47.     public static void main(String[] args)   
  48.     {  
  49.           
  50.         method_get();  
  51.     }  
  52.     public static void method_get()  
  53.     {  
  54.         ArrayList al = new ArrayList();  
  55.   
  56.         //1，添加元素。  
  57.         al.add("java01");//add(Object obj);  
  58.         al.add("java02");  
  59.         al.add("java03");  
  60.         al.add("java04");  
  61.   
  62.         /* 
  63.         Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。 
  64.  
  65.         while(it.hasNext()) 
  66.         { 
  67.             sop(it.next()); 
  68.         } 
  69.         */  
  70.   
  71.         for(Iterator it = al.iterator(); it.hasNext() ; )  
  72.         {  
  73.             sop(it.next());  
  74.         }  
  75.     }  
  76.   
  77.   
  78.     public static void method_2()  
  79.     {  
  80.         ArrayList al1 = new ArrayList();  
  81.   
  82.         al1.add("java01");  
  83.         al1.add("java02");  
  84.         al1.add("java03");  
  85.         al1.add("java04");  
  86.         ArrayList al2 = new ArrayList();  
  87.   
  88.         al2.add("java03");  
  89.         al2.add("java04");  
  90.         al2.add("java05");  
  91.         al2.add("java06");  
  92.   
  93.           
  94.         //al1.retainAll(al2);//去交集，al1中只会保留和al2中相同的元素。  
  95.         al1.removeAll(al2);  
  96.   
  97.         sop("al1:"+al1);  
  98.         sop("al2:"+al2);  
  99.   
  100.   
  101.   
  102.   
  103.     }  
  104.   
  105.     public static void base_method()  
  106.     {  
  107.         //创建一个集合容器。使用Collection接口的子类。ArrayList  
  108.         ArrayList al = new ArrayList();  
  109.   
  110.         //1，添加元素。  
  111.         al.add("java01");//add(Object obj);  
  112.         al.add("java02");  
  113.         al.add("java03");  
  114.         al.add("java04");  
  115.   
  116.         //打印原集合。  
  117.         sop("原集合:"+al);  
  118.   
  119.   
  120.         //3，删除元素。  
  121.         //al.remove("java02");  
  122.         //al.clear();//清空集合。  
  123.   
  124.   
  125.         //4，判断元素。  
  126.         sop("java03是否存在:"+al.contains("java03"));  
  127.         sop("集合是否为空？"+al.isEmpty());  
  128.   
  129.   
  130.         //2，获取个数。集合长度。  
  131.         sop("size:"+al.size());  
  132.   
  133.         //打印改变后的集合。  
  134.         sop(al);  
  135.   
  136.     }  
  137.   
  138.     public static void sop(Object obj)  
  139.     {  
  140.         System.out.println(obj);  
  141.     }  
  142. }  

List接口：

[java]  view plain copy
  1. /* 
  2. Collection 
  3.     |--List:元素是有序的，元素可以重复。因为该集合体系有索引。 
  4.         |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。 
  5.         |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。 
  6.         |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。 
  7.  
  8.  
  9.     |--Set：元素是无序，元素不可以重复。、 
  10.  
  11.  
  12. List： 
  13.     特有方法。凡是可以操作角标的方法都是该体系特有的方法。 
  14.  
  15. 增 
  16.     add(index,element); 
  17.     addAll(index,Collection); 
  18.  
  19. 删 
  20.     remove(index); 
  21.  
  22. 改 
  23.     set(index,element); 
  24. 查 
  25.     get(index): 
  26.     subList(from,to); 
  27.     listIterator(); 
  28.     int indexOf(obj):获取指定元素的位置。 
  29.     ListIterator listIterator(); 
  30.  
  31.  
  32.  
  33.  
  34.  
  35. List集合特有的迭代器。ListIterator是Iterator的子接口。 
  36.  
  37. 在迭代时，不可以通过集合对象的方法操作集合中的元素。 
  38. 因为会发生ConcurrentModificationException异常。 
  39.  
  40. 所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的， 
  41. 只能对元素进行判断，取出，删除的操作， 
  42. 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。 
  43.  
  44. 该接口只能通过List集合的listIterator方法获取。 
  45.  
  46. */  
  47.   
  48.   
  49. import java.util.*;  
  50. class ListDemo   
  51. {  
  52.     public static void sop(Object obj)  
  53.     {  
  54.         System.out.println(obj);  
  55.     }  
  56.     public static void method()  
  57.     {  
  58.           
  59.         ArrayList al = new ArrayList();  
  60.   
  61.         //添加元素  
  62.         al.add("java01");  
  63.         al.add("java02");  
  64.         al.add("java03");  
  65.           
  66.         sop("原集合是："+al);  
  67.         //在指定位置添加元素。  
  68.         al.add(1,"java09");  
  69.   
  70.         //删除指定位置的元素。  
  71.         //al.remove(2);  
  72.   
  73.         //修改元素。  
  74.         //al.set(2,"java007");  
  75.   
  76.         //通过角标获取元素。  
  77.         sop("get(1):"+al.get(1));  
  78.   
  79.         sop(al);  
  80.   
  81.         //获取所有元素。  
  82.         for(int x=0; x<al.size(); x++)  
  83.         {  
  84.             System.out.println("al("+x+")="+al.get(x));  
  85.         }  
  86.   
  87.         Iterator it = al.iterator();  
  88.   
  89.         while(it.hasNext())  
  90.         {  
  91.             sop("next:"+it.next());  
  92.         }  
  93.   
  94.   
  95.         //通过indexOf获取对象的位置。  
  96.         sop("index="+al.indexOf("java02"));  
  97.   
  98.         List sub = al.subList(1,3);  
  99.   
  100.         sop("sub="+sub);  
  101.     }  
  102.   
  103.       
  104.     public static void main(String[] args)   
  105.     {  
  106.   
  107.         //演示列表迭代器。  
  108.         ArrayList al = new ArrayList();  
  109.   
  110.         //添加元素  
  111.         al.add("java01");  
  112.         al.add("java02");  
  113.         al.add("java03");  
  114.   
  115.         sop(al);  
  116.   
  117.           
  118.         ListIterator li = al.listIterator();  
  119.   
  120.           
  121.         //sop("hasPrevious():"+li.hasPrevious());  
  122.   
  123.         while(li.hasNext())  
  124.         {  
  125.             Object obj = li.next();  
  126.   
  127.             if(obj.equals("java02"))  
  128.                 //li.add("java009");  
  129.                 li.set("java006");  
  130.   
  131.   
  132.         }  
  133.   
  134.         while(li.hasPrevious())  
  135.         {  
  136.             sop("pre::"+li.previous());  
  137.         }  
  138.         //sop("hasNext():"+li.hasNext());  
  139.         //sop("hasPrevious():"+li.hasPrevious());  
  140.   
  141.   
  142.         sop(al);  
  143.   
  144.   
  145.   
  146.         /* 
  147.         //在迭代过程中，准备添加或者删除元素。 
  148.  
  149.         Iterator it = al.iterator(); 
  150.  
  151.         while(it.hasNext()) 
  152.         { 
  153.             Object obj = it.next(); 
  154.  
  155.             if(obj.equals("java02")) 
  156.                 //al.add("java008"); 
  157.                 it.remove();//将java02的引用从集合中删除了。 
  158.  
  159.             sop("obj="+obj); 
  160.  
  161.  
  162.         } 
  163.         sop(al); 
  164.         */  
  165.           
  166.   
  167.   
  168.     }  
  169. }  

LinkedList类：

[java]  view plain copy
  1. import java.util.*;  
  2.   
  3. /* 
  4. LinkedList:特有方法： 
  5. addFirst(); 
  6. addLast(); 
  7.  
  8. getFirst(); 
  9. getLast(); 
  10. 获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException 
  11.  
  12. removeFirst(); 
  13. removeLast(); 
  14. 获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException 
  15.  
  16.  
  17. 在JDK1.6出现了替代方法。 
  18.  
  19. offerFirst(); 
  20. offerLast(); 
  21.  
  22.  
  23. peekFirst(); 
  24. peekLast(); 
  25. 获取元素，但不删除元素。如果集合中没有元素，会返回null。 
  26.  
  27. pollFirst(); 
  28. pollLast(); 
  29. 获取元素，但是元素被删除。如果集合中没有元素，会返回null。 
  30.  
  31.  
  32.  
  33.  
  34. */  
  35.   
  36. class LinkedListDemo   
  37. {  
  38.     public static void main(String[] args)   
  39.     {  
  40.         LinkedList link = new LinkedList();  
  41.   
  42.         link.addLast("java01");  
  43.         link.addLast("java02");  
  44.         link.addLast("java03");  
  45.         link.addLast("java04");  
  46.   
  47.         //sop(link);  
  48. //      sop(link.getFirst());  
  49. //      sop(link.getFirst());  
  50.         //sop(link.getLast());  
  51.         //sop(link.removeFirst());  
  52.         //sop(link.removeFirst());  
  53.   
  54.         //sop("size="+link.size());  
  55.   
  56.         while(!link.isEmpty())  
  57.         {  
  58.             sop(link.removeLast());  
  59.         }  
  60.   
  61.     }  
  62.   
  63.     public static void sop(Object obj)  
  64.     {  
  65.         System.out.println(obj);  
  66.     }  
  67. }  
  68. /* 
  69.  
  70. --- 
  71. java01 
  72. java02 
  73. java03 
  74. java04 
  75.  
  76. ---- 
  77. java04 
  78. java03 
  79. java02 
  80. java01 
  81. --- 
  82. */  

Vector类：

[java]  view plain copy
  1. import java.util.*;  
  2.   
  3. /* 
  4. 枚举就是Vector特有的取出方式。 
  5. 发现枚举和迭代器很像。 
  6. 其实枚举和迭代是一样的。 
  7.  
  8. 因为枚举的名称以及方法的名称都过长。 
  9. 所以被迭代器取代了。 
  10. 枚举郁郁而终了。 
  11.  
  12.  
  13.  
  14. */  
  15. class VectorDemo   
  16. {  
  17.     public static void main(String[] args)   
  18.     {  
  19.         Vector v = new Vector();  
  20.   
  21.         v.add("java01");  
  22.         v.add("java02");  
  23.         v.add("java03");  
  24.         v.add("java04");  
  25.   
  26.         Enumeration en = v.elements();  
  27.   
  28.         while(en.hasMoreElements())  
  29.         {  
  30.             System.out.println(en.nextElement());  
  31.         }  
  32.     }  
  33. }  

HashSet类：

[java]  view plain copy
  1. import java.util.*;  
  2. /* 
  3. |--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、 
  4.     |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。 
  5.             HashSet是如何保证元素唯一性的呢？ 
  6.             是通过元素的两个方法，hashCode和equals来完成。 
  7.             如果元素的HashCode值相同，才会判断equals是否为true。 
  8.             如果元素的hashcode值不同，不会调用equals。 
  9.  
  10.             注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。 
  11.  
  12.  
  13.     |--TreeSet： 
  14.  
  15. Set集合的功能和Collection是一致的。 
  16.  
  17.  
  18.  
  19.  
  20. */  
  21.   
  22.   
  23. class HashSetDemo   
  24. {  
  25.     public static void sop(Object obj)  
  26.     {  
  27.         System.out.println(obj);  
  28.     }  
  29.     public static void main(String[] args)   
  30.     {  
  31.           
  32.         HashSet hs = new HashSet();  
  33.   
  34.         sop(hs.add("java01"));  
  35.         sop(hs.add("java01"));  
  36.         hs.add("java02");  
  37.         hs.add("java03");  
  38.         hs.add("java03");  
  39.         hs.add("java04");  
  40.   
  41.         Iterator it = hs.iterator();  
  42.   
  43.         while(it.hasNext())  
  44.         {  
  45.             sop(it.next());  
  46.         }  
  47.     }  
  48. }  

[java]  view plain copy
  1. import java.util.*;  
  2.   
  3. /* 
  4. 往hashSet集合中存入自定对象 
  5. 姓名和年龄相同为同一个人，重复元素。 
  6.  
  7. */  
  8. class HashSetTest   
  9. {  
  10.     public static void sop(Object obj)  
  11.     {  
  12.         System.out.println(obj);  
  13.     }  
  14.     public static void main(String[] args)   
  15.     {  
  16.         HashSet hs = new HashSet();  
  17.   
  18.         hs.add(new Person("a1",11));  
  19.         hs.add(new Person("a2",12));  
  20.         hs.add(new Person("a3",13));  
  21. //      hs.add(new Person("a2",12));  
  22. //      hs.add(new Person("a4",14));  
  23.   
  24.         //sop("a1:"+hs.contains(new Person("a2",12)));  
  25.               
  26. //      hs.remove(new Person("a4",13));  
  27.           
  28.   
  29.         Iterator it = hs.iterator();  
  30.   
  31.         while(it.hasNext())  
  32.         {  
  33.             Person p = (Person)it.next();  
  34.             sop(p.getName()+"::"+p.getAge());  
  35.         }  
  36.     }  
  37. }  
  38. class Person  
  39. {  
  40.     private String name;  
  41.     private int age;  
  42.     Person(String name,int age)  
  43.     {  
  44.         this.name = name;  
  45.         this.age = age;  
  46.     }  
  47.       
  48.     public int hashCode()  
  49.     {  
  50.         System.out.println(this.name+"....hashCode");  
  51.         return name.hashCode()+age*37;  
  52.     }  
  53.   
  54.     public boolean equals(Object obj)  
  55.     {  
  56.   
  57.         if(!(obj instanceof Person))  
  58.             return false;  
  59.   
  60.         Person p = (Person)obj;  
  61.         System.out.println(this.name+"...equals.."+p.name);  
  62.   
  63.         return this.name.equals(p.name) && this.age == p.age;  
  64.     }  
  65.   
  66.       
  67.     public String getName()  
  68.     {  
  69.         return name;  
  70.     }  
  71.     public int getAge()  
  72.     {  
  73.         return age;  
  74.     }  
  75. }  
  76.   
  77. /* 
  78.  
  79.  
  80. */  

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值