Java集合类

Java集合类  

集合中存放的是对象的引用,而非对象本身 ,出于表达上的便利,简称为"集合中的对象".  

Set(集):集合中的对象不按特定方式排列,并且没有重复对象,它的有些实现类能对集合中的对象按特定方式排列. 

     set接口主要有两个实现类HashSet和TreeSet,HashSet类按照哈希算法来存取集合中的对象,存取速度比较快,HashSet类还有一个子类LinkedHashSet类,不仅实现了哈希算法,而且实现了链表数据结构,TreeSet类实现了SortedSet接口,具有排序功能. 

     那么,当一个新的对象加入到Set集合中,Set的add()方法是如何判断这个对象是否已经存在于集合中的呢?

       boolean isExists=false;

       Iterator it=set.iterator();

       while(it.hasNext())       {

            Object oldObject=it.next();

            if(newObject.equals(oldObject)) { 

                  isExists=true;

                   break;

               }

       } 

      可见,Set采用对象的equals()方法比较两个对象是否相等,而不是采用"=="比较运算符,以下程序代码尽管两次调用了Set的add()方法,

       实际上只加入了一个对象: 

      Set set=new HashSet();

      String s1=new String("hello");

      String s2=new String("hello"); 

      set.add(s1); 

      set.add(s2);

       虽然变量s1和s2实际上引用的是两个内存地址不同的字符串对象,但是由于s2.equals(s1)的比较结果为true,因此Set认为他们是相等的对象,当第二次调用Set的add()方法时,add()方法不会把s2引用的字符串对象加入到集合中.

    HashSet类

     按照哈希算法来存取集合中的对象,具有很好的存取性能,当HashSet向集合中加入一个对象时,会调用对象的hashCode()方法获得哈希码,然后根据这个哈希码进一步计算出对象在集合中的存放位置. 

    在Object类中定义了hashCode()和equals()方法,Object类的euqals()方法按照内存地址比较对象是否相等,因此如果object1.equals(object2)为true,表明object1变量和object2变量十九上引用同一个对象.那么object1和object2的哈希码也应该相同.***如果用户定义的类覆盖了Object类的equals()方法,但是没有覆盖Object类的hashCode()方法,就会导致当object1.equals(object2)为true时,而object1和object2的哈希码不一定一样,这样使HashSet无法正常工作.   

TreeSet类:    

实现了SortedSet接口,能够对集合中的对象进行排序. 

       如：

          Set set=new TreeSet();

          set.add(new Integer(7));

           set.add(new Integer(9));

           set.add(new Integer(8)); 

          Iterator it=set.iterator(); 

          while(it.hasNext())           { 

               System.out.println(it.next());

           } 

         输出结果为:6 7 8 

      当TreeSet向集合中加入一个对象时,会把它插入到有序的对象序列中,那么TreeSet是如何对对象进行排序的捏?TreeSet支持两种排序方式:自然排序和客户化排序,默认情况下是自然排序.在JDK中,有一部分类实现了Comparable接口,如Integer,Double和String等,Comparable接口有一个compareTo(Object o)方法,它返回整数类型,对于表达式x.compareTo(y),如果返回值为0,表示x和y相等,如果返回值大于0,表示x大于y,如果小于0,表示x<y. 

       TreeSet调用对象的compareTo()方法比较集合中对象的大小,然后进行升序排序,这种方式称为自然排序. 

   客户化排序: 

       java.util.Comparator接口用于指定具体的排序方式,它有个compare(Object obj1,Object obj2),用于比较两个对象的大小.当表达式compare(x,y)的值大于0,表示x大于y,小于0,表示x小于y,等于0,表示x等于y,如果想让TreeSet进按照Customer对象的name属性进行降序排列,可以先创建实现Comparator接口的类CustomerComparator,如:        import java.util.*;

        public class CustomerComparator implements Comparator         { 

              public int compare(Object o1,Object o2)               {

                      Customer c1=(Custoemr)o1;

                      Customer c2=(Customer)o2;

                     if(c1.getName().compareTo(c2.getName())>0) return -1;

                     if(c1.getName().compareTo(c2.getName())<0) return 1; 

                    return 0; 

              } 

        } 

     接下来在构造TreeSet的实例时,调用它的TreeSet(Comparator comparator)构造方法

              Set set=new TreeSet(new CustomerComparator());

              Customer c1=new Customer("TOM",15);

              Customer c2=new Customer("JACK",20);

              Customer c3=new Customer("MIKE",38);

              set.add(c1);set.add(c2);set.add(c3); 

              Iterator it=set.iterator();

              while(it.hasNext())  {

                   Custoemr customer=(Customer)it.next();

                   System.out.println(customer.getName()+"" +customer.getAge())  ;

              }

          当TreeSet向集合中加入Customer对象时,会调用CustomerComparator类的compare()方法进行排序,以上Tree按照Custoemr对象的name属性进行降序排列,最后输出为:

          TOM 15    MIKE 38 JACK 16

      List(列表):对象以线性方式存储,集合中的对象按索引位置排序,可以有重复对象,允许按照对象在集合中的索引位置检索对象. 实现类有LinkedList,ArrayList和Vector,LinkedList采用链表数据结构,而ArrayList代表大小可变的数组, Vector和 ArrayList比较相似,两者的区别在于Vecotr类的实现采用了同步机制,而ArrayList没有使用同步机制/ List按索引排列:

               List list=new ArrayList();

               list.add(new Integer(3)); 

               list.add(new Integer(4)); 

               list.add(new Integer(3));

               list.add(new Integer(2));

               List的get(int index)方法返回集合中由参数index指定的索引位置的对象,第一个加入到集合中的对象的索引位置为0, 

              for( int i=0,i<list.size;i++)

                 {System.out.println(list.get(i));} 

              输出结果为:3 4 3 2. 

          List只能对集合中的对象按索引位置排序,如果希望对List中的对象按其他特定方式排序,可以借助Comparator接口和Collections类.

           Collections类是Java集合API中的辅助类,它提供了操纵集合的各种静态方法,其中sort()方法用于对List中的对象进行排序:

           sort(List list):对List中的对象进行自然排序.

           sort(List list,Comparator comparator):对List中的对象进行客户化排序,comparator参数指定排序方式.

           对以下List进行自然排序: 

          List list=new ArrayList();

           list.add(new Integer(3)); 

          list.add(new Integer(4)); 

          list.add(new Integer(3));

           list.add(new Integer(2));

           Collections.sort(list); 

          for(int i=0;i<list.size();i++)           {

                  System.out.println(list.get(i)); 

          }          

以上输出结果:2 3 3 4 

  Map(映射):集合中的每一个元素包含一对键对象和一对值对象,集合中没有重复的键对象,值对象可以重复,它的有写实现类能对集合中的键对象进行排序. 

  Map map=new HashMap();

   map.put("1","Mon");

   map.put("1",Monday); 

  map.put("2","monday"); 

  由于第一次和第二次加入到Map中的键对象都是1,所以第一次加入的值对象将被覆盖,而第二个和第三个的值对象虽然相同,但是键对象不一样,所以分配了不同的地址空间,所以不会覆盖,也就是说一共有两个元素在Map集合中. 

    Map有两种比较常用的实现:HashMap和TreeMap.Hashmap按照哈希算法来存取键对象,有很好的存取能力,为了保证HashMap能正常工作,和HashSet一样,要求当两个键对象通过equals()方法比较为true时,这两个键对象的hashCode()方法返回的哈希码也一样.   TreeMap实现了SortedMap接口,能对键对象进行排序,和TreeSet一样,TreeMap也支持自然排序和客户化排序两种方式,以下程序中的TreeMap会对四个字符串类型的键对象"1","3","4","2"进行自然排序: 

  Map map=new TreeMap();

   map.put("1","Monday"); 

  map.put("3","Wendsday");

   map.put("4","Thursday"); 

  map.put("2","Tuesday");   //返回集合中所有键对象的集合

   Set keys=map.keySet();

   Iterator it=keys.iterator();

   while(it.hasNext)   {String key=(String)it.next();    //根据键对象得到值对象

    String value=(String)map.get(key); 

   System.out.println(key+"" +value);

   }  

以上输出结果为:1 Monday  2 Wendsday 3 Thursday 4 Tuesday 

    如果希望TreeMap进行客户化排序,可以调用它的另一个构造方法TreeMap(Comparator comparator),参数comparator指定具体的排序方式.