深入探讨java集合类

不同的集合在添加对象时的处理是不同的:
Set:不允许重复,且没有指定顺序,HashSet在添加新对象时,首先比较对象的hashcode值,如果相等再比较两个对象是否相等,如果是则不添加,否则添加,并且按hashCode值排序.
List:允许重复且有指定顺序,ArrayList和Vector都是这样的类,如果你不指定顺序它就默认按先后顺序排序.
下面是两个简单的例子:
(1):
import java.util.*;
public class TestTree  {
    public static void main(String[] args)   {
        TreeSet ts = new TreeSet(new MyComparator());
        ts.add(new Person(33,160));
     ts.add(new Person(23,170));
     ts.add(new Person(45,180));
     Iterator it = ts.iterator();
     while(it.hasNext()){
        System.out.println (it.next());
     }
    }
}
//定义一个比较器类,实现Comparator接口.
class MyComparator implements Comparator  {
    public int compare(Object obj1,Object obj2){
        Person p1 = (Person)obj1;
        Person p2 = (Person)obj2;
        return (p1.age > p2.age ? 1 : (p1.age == p2.age ? 0 : -1));
    }
}

class Person {//implements Comparable
    public int age;
    public int height;
    public Person(int age,int height){
       this.age = age;
       this.height = height;
    }
    public String toString(){
       return (this.age + " : " + this.height);
    }
    
    //重写Comparable接口的compareTo方法
    /*
    public int compareTo(Object obj){
       if(obj instanceof Person){
          Person p = (Person)obj;
          return (this.height > p.height ? 1 : (this.height == p.height ? 0 : -1));
       }
       return 1;
    }*/
}

(2).
import java.util.*;

public class TestHashSet{
    public static void main(String[] args){
        HashMap<String,String> hm = new HashMap<String,String>();
        hm.put("a","aaa");
        hm.put("b","bbb");
        hm.put("c","ccc");
        
        //第一种取值的方法
        Set s = hm.keySet();
        Iterator e = s.iterator();
        while(e.hasNext()){
            Object o = e.next();
            System.out.println (o + ":" + hm.get(o));
        }
        
        //第二种方法
        Set<Map.Entry<String,String>> ss = hm.entrySet();
        for(Map.Entry<String,String> me : ss){
            System.out.println (me.getKey() + ":" + me.getValue());
        }
        
        //jdk1.5 里面新增的泛型使用示例，指明hs集合里面只能存Student对象。
        HashSet<Student> hs = new HashSet<Student>();
        hs.add(new Student("zhangsan",30));
        hs.add(new Student("zhangsan",30));
        
        //hs.add(new String("这样添加一个对象会出错误"));
        
        //尽管调用了两次add方法，但是因为Student类里面重写了equals方法。
        //所以最终hs的大小是1，
        System.out.println (hs.size());
        
        //想取出hs集合里面的对象时可以象下面这样，如此一来在循环里面去数
        //据时就可以指定用Student类型的对象来接收Iterator里面的对象了。
        /*
        Iterator<Student> itr = hs.iterator();
    while(itr.hasNext()){
        Student obj = itr.next();
        System.out.println (obj);
    }
    */
       
    //jdk1.5 里面for循环的增强,此方法和C#里面的foreach语法相似，只不过
    //在java里面是用 ":" ，而在C#里面是用 "in"。":"后面的只能是数组或者集合。如果
    //循环体类的数据对象名或者其他数据类型在外面定义就会报编译错误。
    for(Student stu : hs){
        System.out.println (stu);
    }
       
    //下面打印出两个Student对象的hashCode值，结果是相等的。
    //因为Student类里面重写了hashCode方法。
    System.out.println (new Student("zhangsan",19).hashCode());
    System.out.println (new Student("zhangsan",19).hashCode());
    }
}
 
class Student{
    private String name;
    private int age;
    
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    //jdk1.5里面新增的标注：@Override指明要覆盖父类的方法。注意：@Override的O是大写。
    @Override
    public boolean equals(Object obj)
        //判断传进来的Object对象是不是Student类型的对象
        if(obj instanceof Student) {
            Student stu = (Student)obj;
            return ((this.name.equals(stu.name)) && (this.age == stu.age));
        }
        return false;
    }
    
    public int hashCode(){
        return (this.age + this.name.hashCode());
        //注意基本数据类型没有哈希码值。
    }
    
    public String toString(){
        return (this.name + ":" + this.age);  
    }

}