Java中的比较器Comparable/Comparator

Java实现比较器

比较器总结：
java中提供了两个比较器接口,一个是java.lang. Comparable接口,另一个java.util. Comparator接口;
Comparable用于定义默认比较器(1个)，Comparator用于定义扩展比较器(多个)

1.使用Comparable实现比较器必须实现其中的compareTo(T o)方法，在该方法中定义比较规则,该方法的返回值为一个整数(int),如果当前对象大于指定对象返回正整数，如果小于指定对象返回负整数，如果两个对象相等返回零​

让类去实现Comparable接口，重写其中的compareTo(T o)方法，当使用排序的集合（TreeSet,TreeList）,要求存入的对象是可排序的，那么这个对象就必须实现Comparable接口，这样就可以排序了（不然运行会报错）

 public class Test {​   
  public static void main(String[] args) {        
  Student s1 = new Student(1);//Student类实现了Comparable接口     
     Student s2 =  new Student(2);       
     Teacher t1 = new Teacher(1,"李老师");//Teacher类没有实现了Comparable接口             Teacher t2 = new Teacher(2,"朱老师");​
     System.out.println(s1.compareTo(s2));//基本使用方法根据指定的排序规则返回对比后的值        
     TreeSet treeSet = new TreeSet();        
     treeSet.add(t1);        
     treeSet.add(t2);        
     for (Object teacher: treeSet) {             
     System.out.println(teacher); //运行时报错，
     //异常：Teacher cannot be cast to java.lang.Comparable（向集合中添加Student则不会出现异常）      
       }   
    }

–Comparable 只能在类中定义一套比较规则,一般我们会使用**Comparable定义默认的比较规则（比较常用的比较规则）

2.实现Comparator接口​

第一种：使用静态内部类的方法可以多次调用，可以有多个比较的规则

/***
         * 使用内部类定义按照年龄降序的比较器
         */
        public static class AgeDesc implements Comparator<Student>{
        /***
             * 比较方法
             * @param stu1:参与比较的对象
             * @param stu2:参与比较的对象
             * @return
             */
            @Override
            public int compare(Student stu1, Student stu2) {
                if(stu1.getStuAge() < stu2.getStuAge()){
                    return -1;
                }
                if(stu1.getStuAge() > stu2.getStuAge()){
                    return 1;
                }
                return 0;
            }
        }
----------------------------------使用内部静态类的方式
 public static void main(String[] args) {
        Student s1 = new Student(1,15);//Student类实现了Comparable接口
        Student s2 =  new Student(2,18);
        Teacher t1 = new Teacher(1,"李老师");//Teacher类没有实现了Comparable接口
        Teacher t2 = new Teacher(2,"朱老师")；
        TreeSet treeSet = new TreeSet(new Student.AgeDesc());
        treeSet.add(s1);
        treeSet.add(s2);
        for (Object student: treeSet) {
            System.out.println(student);
        }
        ---------------------------------对象之间使用静态内部类的排序
        Student.AgeDesc ageDesc = new Student.AgeDesc();//静态内部类对象的声明方式
        System.out.println(ageDesc.compare(stus.get(1),stus.get(2)));

默认的排序规则：

return 1 （升序） （降序）反转升序排序规则​
< return -1​
= return 0

第二种：使用匿名类实现
（一次使用,如果需要多次被调用不建议此方式)一般用于Collections.sort方法

         List<Student> stus = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Student stu = new Student(i+1,"姓名"+i,18%2==0?16+i:18+i,175+i,120+i);
            stus.add(stu);
        }
                 //静态内部类对象的声明方式
               Student.AgeDesc ageDesc = new Student.AgeDesc();
              System.out.println(ageDesc.compare(stus.get(1),stus.get(2)));
                Collections.sort(stus, new Comparator<Student>() {//通常使用的位置
                    @Override
                    public int compare(Student t1, Student t2) {
                        if(t1.getStuHeight()<t2.getStuHeight()){
                                return  1;
                        }
                        if(t1.getStuHeight()>t2.getStuHeight()){
                            return  -1;
                        }
                        return  0;
                    }
                });
        for (Student stu: stus
        ) {
            System.out.println(stu);
        }
    }

比较用的类

public class Student implements Serializable, Comparable<Student> {
       private  static  final  long serialVersionUID =1l;
        private int stuId;
        private String stuName;
        private int stuAge;
        private int stuHeight;
        private int stuWeight;
        private int num;


    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
        public int getStuId() {
            return stuId;
        }

        public void setStuId(int stuId) {
            this.stuId = stuId;
        }

        public String getStuName() {
            return stuName;
        }

        public void setStuName(String stuName) {
            this.stuName = stuName;
        }

        public int getStuAge() {
            return stuAge;
        }

        public void setStuAge(int stuAge) {
            this.stuAge = stuAge;
        }

        public int getStuHeight() {
            return stuHeight;
        }

        public void setStuHeight(int stuHeight) {
            this.stuHeight = stuHeight;
        }

        public int getStuWeight() {
            return stuWeight;
        }

        public void setStuWeight(int stuWeight) {
            this.stuWeight = stuWeight;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "stuId=" + stuId +
                    ", stuName='" + stuName + '\'' +
                    ", stuAge=" + stuAge +
                    ", stuHeight=" + stuHeight +
                    ", stuWeight=" + stuWeight +
                    '}';
        }

        /***
         * 比较方法
         * @param student
         * @return
         * 在此方法中定义默认比较规则(按照学号升序比较)
         */
        @Override
        public int compareTo(Student student) {
            if(this.stuId>student.getStuId()){
                return 1;
            }
            if(this.stuId < student.getStuId()){
                return  -1;
            }
            return 0;
//        return this.stuId>student.getStuId()?1:this.stuId<student.getStuId()?-1:0;

        }

        /***
         * 使用内部类定义按照年龄降序的比较器
         */
        public static class AgeDesc implements Comparator<Student>{

            /***
             * 比较方法
             * @param stu1:参与比较的对象
             * @param stu2:参与比较的对象
             * @return
             */
            @Override
            public int compare(Student stu1, Student stu2) {
                if(stu1.getStuAge() < stu2.getStuAge()){
                    return -1;
                }
                if(stu1.getStuAge() > stu2.getStuAge()){
                    return 1;
                }
                return 0;
            }
        }


        /***
         * 使用内部类定义按照身高降序的比较器
         */
        public static class HeightDesc implements Comparator<Student> {

            /***
             * 比较方法
             * @param stu1:参与比较的对象
             * @param stu2:参与比较的对象
             * @return
             */
            @Override
            public int compare(Student stu1, Student stu2) {
                if(stu1.getStuHeight() > stu2.getStuHeight()){
                    return -1;
                }
                if(stu1.getStuHeight() < stu2.getStuHeight()){
                    return 1;
                }
                return 0;
            }
        }
    }