黑马程序员

import java.util.*;
public class BArrayListTest{
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList ();  //定义原容器，并向里面存入元素
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");
        a1.add("java05");
        a1.add("java01");
        sopCH.sop("原集合"+a1);
        a1 = ArrayTool.SingleElement(a1); //调用编写的去重复元素静态方法
        sopCH.sop("去除重复元素后集合："+a1);
    }
}
class sop{
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
class ArrayTool{                              //定义一个工具类
    static ArrayList a2 = new ArrayList ();   //定义一个新集合a2用于存储去掉重复元素后的集合
    public static ArrayList SingleElement(ArrayList  a1){ //定义去重复元素的静态方法(方便通过类名调用)
        for (int x=0;x<a1.size() ;x++ ){      //通过for循环遍历集合a1
            if (!(a2.contains(a1.get(x))))    //判断a2中是否存在该元素，没有就将该元素存入a2
                a2.add(a1.get(x));
        }
        return a2;                            //返回a2
    }
}

import java.util.*;
class PersonTS implements Comparable{           //定义类实现Comparable接口，使其具有比较性
    private    String name;                        //定义成员变量
    private int age;
    PersonTS(String name,int age){              //构造函数
        this.name=name;
        this.age=age;
    }
    public int compareTo(Object obj){           //覆写compareTo方法，定义排序规则为先按年龄再按姓名排序
        if (!(obj instanceof PersonTS))         //判断对比对象是否为Person
            throw new RuntimeException("不是Person对象");
        PersonTS p = (PersonTS)obj;                //向下转型为Person
        sop.sop(this.name+":compareto:"+p.name);//显示具体对比的元素
        if (this.age>p.age)                     //判断年龄大小
            return 1;
        else if(this.age==p.age)                //年龄相同时判断姓名
            return this.name.compareTo(p.name);
        else
            return -1;
    }
    public String getName(){                    //定义获取姓名方法
        return name;
    }
    public int getAge(){                        //定义获取年龄方法
        return age;
    }
}
public class CTreeSet{
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();             //定义ts集合并存入元素，用以演示按元素本身的排序规则排序
        ts.add(new PersonTS("a1",11));
        ts.add(new PersonTS("a2",12));
        ts.add(new PersonTS("a3",13));
        ts.add(new PersonTS("b2",12));
        ts.add(new PersonTS("b2",12));
        
        TreeSet ts2 = new TreeSet(new MyComparePerson());   //定义ts2集合并存入元素，并将比较器作为参数传给集合
        ts2.add(new PersonTS("a1",11));               //用以演示按定义的比较器的排序规则排序
        ts2.add(new PersonTS("a4",12));
        ts2.add(new PersonTS("a1",13));
        ts2.add(new PersonTS("b2",12));
        ts2.add(new PersonTS("b2",12));
        
        for (Iterator it=ts.iterator();it.hasNext() ; ){
            PersonTS p = (PersonTS)it.next();
            sop.sop("元素本身排序方式"+p.getName()+":"+p.getAge());
        } 
        for (Iterator it=ts2.iterator();it.hasNext() ; ){
            PersonTS p = (PersonTS)it.next();
            sop.sop("自定义比较器排序方式"+p.getName()+":"+p.getAge());
        }         
    }
}
class MyComparePerson implements Comparator{                  //定义类实现Comparator，使其具备比较器的功能
    public int compare(Object o1,Object o2){            //覆写compare方法，定义先按照姓名再按照年龄排序
        if (!(o1 instanceof PersonTS)&&!(o2 instanceof PersonTS))//判断对比对象是否为Person
            throw new RuntimeException("不是Person对象");
        PersonTS p1= (PersonTS)o1;                      //将对比元素向下转型为PersonTS
        PersonTS p2= (PersonTS)o2;
        int num = p1.getName().compareTo(p2.getName()); //先按照姓名排序
        if(num==0){                                     //判断姓名是否相同，如果相同再对比其年龄
            if(p1.getAge() > p2.getAge())
                return 1;
            else if (p1.getAge() == p2.getAge())
                return 0;
            else
                return -1;
        }
        else
            return num;
    }
}

import java.util.*;
class Student implements Comparable<Student>{      //定义类实现Comparable接口，使其具备比较性
    private String name;                           //定义成员变量
    private int age;
    Student(String name,int age){                  //定义带参数构造函数
        this.name = name;
        this.age = age;
    }
    public int hashCode(){                         //覆写hashCode方法，自定义获取hashcode方式
        return name.hashCode()+age*13;
    }
    public boolean equals(Object obj){             //自定义比较类型
        if(!(obj instanceof Student))              //判断对比对象是否是Student
            throw new ClassCastException("类型不匹配");
        Student s = (Student)obj;                  //将对比对象向下转型为Student
        sop.sop(this.name+":equals:"+s.name);     
        return this.name.equals(s.name) && this.age==(s.age);//定义相同条件为姓名年龄均相同
    }
    public int compareTo(Student s){               //默认排序方式为按照年龄排序    
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if(num == 0)
            return this.name.compareTo(s.name);
        else
            return num;
    }
        public String getName(){                   //定义获取姓名方法
        return name;
    }
    public int getAge(){                           //定义获取年龄方法
        return age;
    }
}

public class DmapDemo{
    public static void main(String[] args){
        HashMap<Student,String> hm = new HashMap<Student,String>();
        hm.put(new Student("mike1",12),"shanghai");
        hm.put(new Student("lili1",12),"shanghai");
        hm.put(new Student("mike2",12),"chengdu");
        hm.put(new Student("lili2",11),"chengdu");
        hm.put(new Student("mike3",12),"beijing");
        hm.put(new Student("lili3",13),"beijing");

        TreeMap<Student,String> tm = new TreeMap<Student,String>(/*new MyCompare()*/);
        tm.put(new Student("mike1",12),"shanghai");
        tm.put(new Student("lili1",12),"shanghai");
        tm.put(new Student("mike2",11),"chengdu");
        tm.put(new Student("lili2",11),"chengdu");
        tm.put(new Student("mike3",12),"beijing");
        tm.put(new Student("lili3",13),"beijing");
        
        Set<Student> keySet = hm.keySet();
        Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
        sop.sop("HashMap的键值对为无序排列：");
        for (Iterator <Student>it = keySet.iterator(); it.hasNext();){    
            Student key = it.next();
            sop.sop(key.getName()+":"+key.getAge()+"....."+hm.get(key));
        }
        sop.sop("TreeMap的键值对按照自定规则排序：");
        for (Iterator <Map.Entry<Student,String>> it = entrySet.iterator(); it.hasNext();){    
            Map.Entry key = it.next();
            Student s = (Student)key.getKey();
            sop.sop(s.getName()+":"+s.getAge()+"....."+key.getValue()); 
        }
    }
}
class MyCompareStu implements Comparator<Student>{//定义按照学生姓名排序的比较器。
    public int compare(Student s1,Student s2){
        int num = s1.getName().compareTo(s2.getName());
        if(num==0)
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        else
            return num;
    }
}