Java：接口应用(Comparable接口与比较器)

1.引例

class Student{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Main {
    public static void main(String[] args) {
        Student student1=new Student("zhangsan",5);
        Student student2=new Student("lisi",10);
        //怎么比较引用类型？
    }
}

通过上面我们实例化了两个对象“student1和student2”，但是他们都属于引用类型，我们该如何比较呢？

student1>student2????

显然使用上面这个比较方法会报错，这时我们就要引入一个接口Comparable，通过这个接口可以实现引用类型的比较。下面跟着我们来详细深入这个接口吧。

2.Comparable接口使用

通过下方代码我们来实现这个接口

class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        return 0;
    }
}

追溯到Comparable的原码我们可以发现一个这样的方法
在这里插入图片描述
我们通过重写comparaTo方法可以实现我们引用类型的比较。
下面我们来举一个例子：
当我们要对student1和student2的年龄来比较就可以使用下方代码。

class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
}
public class Main {
    public static void main(String[] args) {
        Student student1=new Student("zhangsan",5);
        Student student2=new Student("lisi",10);
        if(student1.compareTo(student2)>0){
  //student1调用了comparaTo方法,并传入student2为参数
       //student1年龄比student2年龄大返回大于零的数
       //student1年龄比student2年龄小返回小于零的数
       //student1年龄和student2年龄相等返回0
        }
    }
}

但是，当我们需要比较String类型数据的大小应该怎么办呢？
String也是一个引用类型，当我们追溯到String原码时可以以发现String也实现了Comparable这个接口
在这里插入图片描述
我们在String这个类里面找到重写的comparaTo方法

通过Strig直接调用comparaTo方法就可实现String类型的比较。下面我们来举个例子吧。

public class Main {
    public static void main(String[] args) {
        String str1="abc";
        String str2="def";
        System.out.println(str1.compareTo(str2));
    }
 }

通过上面的结果发现返回一个负值。
因此当str1<str2时，返回小于0的值；当str1>str2时，返回大于0的值；当str1=str2时返回0。（通过ASCII码值进行比较，如果前面字母都一样比较长度）。
通过上面的例子我们就可以实现学生的名字比较了

class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        if(this.name.compareTo(o.name)>0){
            return 1;
        } else if (this.name.compareTo(o.name)==0) {
            return 0;
        } else {
            return -1;
        }
    }
public class Main {
    public static void main1(String[] args) {
        Student student1=new Student("zhangsan",5);
        Student student2=new Student("lisi",10);
        if(student1.compareTo(student2)>0){
            //student1名字比student2名字大返回1
            //student1名字比student2名字小返回-1
            //student1名字和student2名字相等返回0
        }
    }
}

当然comparaTo我们也可以写成下面方式

public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }//返回值随机，但是返回值的正负和上方一样

3.Comparable接口的局限性

一旦这个类写死了什么比较方式（如上面例子年龄和名字的不同比较），后期不能随意进行更改。可以理解为：写死就是一个默认的比较方式。

4.使用comparaTo实现排序

class Student implements Comparable<Student>{
    private int age;
    private String name;
    public Student( String name,int age) {
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Main {
    private static void mySort(Comparable[] students){
        for (int i = 0; i < students.length-1; i++) {
            for (int j = 0; j < students.length-1-i; j++) {
                if(students[j].compareTo(students[j+1])>0){
                    Comparable temp=students[j];
                    students[j]=students[j+1];
                    students[j+1]=temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("zhangsan",10);
        students[1]=new Student("lisi",5);
        students[2]=new Student("wangwu",8);
        mySort(students);
        System.out.println(Arrays.toString(students));
    }
}

我们通过一个冒泡排序以及comparaTo来实现一个简单的排序效果，输出结果如下：
在这里插入图片描述
当然我们也可以使用Arrays的sort方法进行排序，但是这个排序结果跟Student类中重写的comparaTo方法有关，展示如下：

class Student implements Comparable<Student>{
    private int age;
    private String name;
    public Student( String name,int age) {
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Main {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("zhangsan",10);
        students[1]=new Student("lisi",5);
        students[2]=new Student("wangwu",8);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

当comparaTo的返回值为this.age-o.age输出结果为升序排序，结果如下所示
在这里插入图片描述
当comparaTo的返回值为o.age-this.age输出结果为降序排序，结果如下所示

5.比较器（Comparator接口）

通过上面的介绍，我们可以知道Comparable接口具有局限性，那么如果我们想要打破这个局限性我们就引入了比较器（Comparator接口）。接下来，我们来进行具体操作吧。
1.年龄比较器

public class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}
class Student implements Comparable<Student>{
    int age;
    private String name;
    public Student( String name,int age) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return 0;
    }
}
public class Main {
    public static void main(String[] args) {
        Student student1=new Student("zhangsan",10);
        Student student2=new Student("lisi",5);
        AgeComparator ageComparator=new AgeComparator();
        //初始化一个新的比较器来实现年龄的比较
        int ret1=ageComparator.compare(student1,student2);
        System.out.println(ret1);
    }
}

2.姓名比较器

class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
class Student implements Comparable<Student>{
    public int age;
    public String name;
    public Student( String name,int age) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return 0;
    }
}
public class Main {
    public static void main(String[] args) {
        Student student1=new Student("zhangsan",10);
        Student student2=new Student("lisi",5);
        NameComparator nameComparator=new NameComparator();
        实例化一个新的比较器来实现姓名的比较
        int ret1=nameComparator.compare(student1,student2);
        System.out.println(ret1);
    }
}