Collection接口是List,Set和Queue接口的父接口,该接口里定义的方法既可用于操作Set集合,也可用于操作List和Queue集合。

 

 
  
  1. public class TestCollection  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         Collection c = new ArrayList();  
  6.         //添加元素  
  7.         c.add("孙悟空");  
  8.         //虽然集合里不能访基本类型的值,但Java支持自动装箱  
  9.         c.add(6);  
  10.         System.out.println("c集合的元素个数为:" + c.size());  
  11.         //删除指定元素  
  12.         c.remove(6);  
  13.         System.out.println("c集合的元素个数为:" + c.size());  
  14.         //判断是否包含指定字符串  
  15.         System.out.println("c集合的元素是否包含孙悟空字符串:"+ c.contains("孙悟空"));  
  16.         c.add("轻量级J2EE企业应用实战");  
  17.         System.out.println("c集合的元素:"+ c);     
  18.         Collection books = new HashSet();  
  19.         books.add("轻量级J2EE企业应用实战");  
  20.         books.add("Strusts2权威指南");  
  21.         System.out.println("c集合是否包含books集合?"+ c.containsAll(books));  
  22.         //用c集合减去books集合里的元素  
  23.         c.removeAll(books);  
  24.         System.out.println("c集合的元素:"+ c);  
  25.         //删除c集合里所有元素  
  26.         c.clear();  
  27.         System.out.println("c集合的元素:" + c);  
  28.         //books集合里只剩下c集合里也同时包含的元素  
  29.         books.retainAll(c);  
  30.         System.out.println("books集合的元素:"+ books);  
  31.     }     

 Collection的实现类重写了toString()方法,所有Collection集合实现类都重写了toString()方法,

该方法可以一次性输出集合中的所有元素。

 

使用Iterator接口遍历集合元素

Iterator接口也是Java集合框架的成员,但他与Collection系列、Map系列的集合不一样Collection系列集合、Map系列集合主要用于盛装其他对象,而Iterator则主要用于遍历Collection集合中的元素,Iterator对象也被称为迭代器。

Iterator接口里定义如下三个方法:

boolean hasNext():如果迭代的集合元素还没有被遍历,则返回true;

Object next():返回集合里下一个元素。

void remove():删除集合里上一次next方法返回的元素。

 

 
  
  1. public class TestIterator 
  2.     public static void main(String[] args) 
  3.     { 
  4.         //创建一个集合 
  5.         Collection books = new HashSet(); 
  6.         books.add("J2EE企业实战"); 
  7.         books.add("Struts2权威指南"); 
  8.         books.add("J2EE宝典"); 
  9.         //获取books集合对应的迭代器 
  10.         Iterator it = new books.iterator(); 
  11.         while(it.hasNext()) 
  12.         { 
  13.             //it.next()方法返回的数据类型是Object类型,需要强制转换 
  14.             String book = (String)it.next(); 
  15.             System.out.println(book); 
  16.             if(book.equals("Struts2权威指南")) 
  17.             { 
  18.                 //从集合中删除上一次next方法返回的元素 
  19.                 it.remove();     
  20.             } 
  21.             //对book变量赋值,不会改变集合元素本身 
  22.             book = "测试字符串": 
  23.         } 
  24.         System.out.println(books); 
  25.     } 

Iterator仅用于遍历集合,Iterator本身不提供盛装对象的能力。如果需要创建Iterator对象,则必须有一个被迭代的集合。

   Iterator必须依附于Colletion对象。有一个Iterator对象,则必然有一个与之关联的Collection对象。Iterator提供了2个方法来迭代访问Collection集合里的元素,并可通过remove方法来删除集合中上一次next方法返回的集合元素。

 

当使用Iterator对集合元素进行迭代时,Iteratorb并不是把集合元素本身传给了迭代变量,而是把集合元素的值传给了迭代变量,所以修改迭代变量的值对集合元素本身没有任何改变。

    当使用iteratorl来迭代访问Collection集合元素时,Collection集合里的元素不能被改变,只有通过Iterator的remove方法来删除上一次next方法返回的集合元素才可以。否则将会引发java.util.ConcurrentModificationException异常。(程序的一条线程正在迭代访问Collection集合元素时,另一条线程修改了Collection集合,就会导致发生异常)

使用foreach循环遍历集合元素

 
  
  1. public class TestForeach  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         //创建一个集合  
  6.         Collection books = new HashSet();  
  7.         books.add(new String("J2EE企业应用实战"));      
  8.         books.add(new String("struts2权威指南"));  
  9.         books.add(new String("ajax宝典"));  
  10.         for(Object obj : books)  
  11.         {  
  12.             //此处的book变量也不是集合元素本身  
  13.             String book = (String)obj;  
  14.             System.out.println(book);     
  15.             if(book.equals("struts2权威指南"))  
  16.             {  
  17.                 //下面代码会引发ConcurrentModificationException异常  
  18.                 books.remove(book);   
  19.             }  
  20.         }  
  21.         System.out.println(books);  
  22.     }  

      与使用Iterator迭代访问集合元素类似的是,foreach循环中的迭代变量也不是集合元素本身,系统只是依次把集合元素的值付给迭代变量,因此在Foreach循环中修改迭代变量的值也没有任何意义。 同样,当使用foreach循环迭代访问集合元素时,该集合也不能被改变,否则将引发ConcurrentModificationException异常。
 
Set接口


     Set集合与Collection基本上完全一样,只是行为不同(Set不允许包含重复元素)
Set判断两个对象相同不是使用==运算符,而是根据equals方法。
 

 
  
  1. public class TestSet  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         Set books = new HashSet();  
  6.         //添加一个字符串对象  
  7.         books.add(new String("Struts2权威指南"));     
  8.         //再次添加一个字符串对象  
  9.         //因为两个字符串对象通过equals方法比较想当相等,所以添加失败,返回false  
  10.         boolean result = books.add(new String("Struts2权威指南"));  
  11.         //下面输出看到集合只有一个元素  
  12.         System.out.println(books);  
  13.         System.out.println(result);//返回false  
  14.     }     

HashSet类


 HashSet是Set接口的典型实现,大多数时候使用Set集合时就是使用这个实现类。
 HashSet具有以下特点:
 1、不能保证元素的排列顺序,顺序有可能发生变化。
 2、HashSet不是同步的,如果多个线程同时访问一个Set集合,如果多个线程同时访问一个HashSet,如果有2条或者以上线程同时修改HashSet集合时,必须通过代码来保证其同步。
 3、集合元素值可以是null.


HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个对象的hashCode()方法返回值也相等。如果两个元素通过equals方法比较返回true,但他们的hashCode()方法返回值不同,HashSet会将他们添加在不同位置,也可以添加成功。

HashSet访问集合元素时是根据元素的hashCode值来访问的,如果HashSet中包含两个元素有相同的hashCode值,将导致性能下降。

实际上当程序向HashSet集合中添加元素时,HashSet会根据元素的hashCode值来决定他的存储位置---也就是说,每个元素的hashCode就是他的“索引”。然后根据元素的hashCode值来访问元素。当从HashSet中访问元素时,HashSet先计算核对元素的hashCode 值(调用该对象的hashCode()方法的返回值,然后直接到该hashCode对应的位置取取出该元素--多以速度快)。
 

HashSet还有一个子类LinkedHashSet,LinkedHashSet集合也是根据元素hashCode值来决定元素存储位置,但他同时使用链表维护元素的次序,这样使得元素看起来是以插入的顺序来访问集合里的元素。也就是说当遍历LinkedHashSet集合里元素时,HashSet将会按元素的添加顺序来访问集合里的元素。
 

 
  
  1. public class TestLinkedHashSet  
  2. {  
  3.     public static void main(String[] args)    
  4.     {  
  5.         LinkedHashSet books = new LinkedHashSet();  
  6.         books.add("1");  
  7.         books.add("2");  
  8.         //删除books1  
  9.         book.remove("1");  
  10.         //重新添加1  
  11.         books.add("1");  
  12.         System.out.println(books);    
  13.     }  
  14. }  
  15. /*  
  16.     结果:【2,1】  
  17. */ 

 

TreeSet类


 TreeSet可以确保集合元素处于排序状态。(TreeSet中的元素是有序的)
 TreeSet并不是根据元素的插入顺序进行排序,而是根据元素实际值来进行排序的。
 

 
  
  1. public class TestTreeSetCommon  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         TreeSet nums = new TreeSet();  
  6.         nums.add(5);  
  7.         nums.add(2);  
  8.         nums.add(10);  
  9.         nums.add(-9);  
  10.         System.out.println(nums);  
  11.         //输出集合中的第一个元素  
  12.       System.out.println(nums.first());  
  13.       //输出集合中的最后一个元素  
  14.       System.out.println(nums.last());  
  15.     }  
  16. }  
  17. /*  
  18.     结果:[-9, 2, 5, 10]  
  19.                 -9  
  20.                 10  
  21. */ 


TreeSet支持两种排序方法:自然排序和定制排序。默认情况下是自然排序。

自然排序:向TreeSet集合中添加元素时,只有第一个元素可以无须实现Comparable接口,后面添加的所有元素都必须实现Comparable接口(调用compareTo方法来比较两个值)。

定制排序:使用Comparator接口的帮助。该接口里的 int compare(T o1,T o2)方法该方法用来比较o1和o2的大小,返回正数,o1大于o2;返回0,o1等于o1;返回负数,o1小于o2。

不可以向TreeSet中添加类型不同的对象,否则会引发ClassCastException异常。

EnumSet类

略:需要时补充