【开开心心学java,快快乐乐写代码】引用类型的比较

欢迎来到【开开心心学java,快快乐乐写代码】此专栏，这是一篇库存，在草稿箱里待了好几个星期了，今天来把它补齐。这篇文章主要是讲解一下关于引用类型的比较的。都学到这里了，大家应该都知道引用类型数据不能用<、>或==符号来作比较吧，那它们究竟是怎样进行比较的呢？引用类型比较一般有两种方法，实现Comparable接口和比较器（实现Comparator接口），具体是怎么实现的呢，看看下文吧，依旧还是写的很详细哦~ 

---

目录

1、使用Comparable中的comparaTo方法

1.1 内置引用类型的比较

1.2 自定义类型的比较

2、使用比较器（即使用Comparator接口中的compare方法）

---

1、使用Comparable中的comparaTo方法

1.1 内置引用类型的比较

内置引用类型包括Interge、Charater、String、Double等等，即一些基本类型的包装类。在jdk中，提供了内置引用类型的排序规则。这些类都是实现了Comparable接口，重写了compareTo方法。因此可直接调用compareTo方法对其进行排序。

内置引用的排序规则如下：

• 整数、浮点数（Interge、Double、Float等）：直接比较基本类型数据的大小。大于返回1，小于返回-1，等于返回0。
• 字符（Character）：返回两个字符unicode之差。
• 字符串（String）：如果一个字符串的起始就是另一个字符串的子串，则返回长度之差,如例如： “abcde” 和 “abc” 返回2;否则返回第一个不相等的unicode码之差。
• 日期类：根据日期对应的的长整型数比较。等于返回0；大于返回1；小于返回-1 。

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        /**
         *整型、浮点型（Integer、Double、Float):直接比较基本类型数据大小
         * 大于：返回1
         * 等于：返回0
         * 小于：返回-1
         */
        Integer a=1;
        Integer b=1;
        System.out.println(a.compareTo(b));//0

        Double num3 = 23.2;
        Double num4 =40.0;
        System.out.println(num3.compareTo(num4));//-1


        /**
         * String引用类型：如果其中一个字符串是另一个字符串的子串时，返回两者长度之差；
         * 否则返回第一个不相同的字符的unicode之差
         */
        String str1="abcd";
        String str2="cc";
        System.out.println(str1.compareTo(str2));//-2

        String str3="abcd";
        String str4="ab";
        System.out.println(str3.compareTo(str4));//2

        /**
         * 返回字符的unicode之差
         */
        Character ch1 = 'A';
        Character ch2 = 'M';
        System.out.println(ch1.compareTo(ch2));//-12


        /**
         * 根据日期对应的的长整型比较大小
         * 大于：返回1
         *  等于：返回0
         * 小于：返回-1
         */
        Date date1 = new Date();
        Date date2 = new Date(System.currentTimeMillis() - 3600000);
        System.out.println(date1.compareTo(date2)); //1 (date1比date2时间新，date1对应的长整型数字比date2大，因此返回1)

    }
}

 运行结果：

---

1.2 自定义类型的比较

jdk中没有提供自定义类型大小的比较，这就需要我们自己去定义如何比较了。文章最开始就说了，自定义类型（也就是引用类型）的比较无非就两种，一是实现Comparable接口，二是实现Comparator接口。这两个接口究竟是什么呢？我们借助一个例子来理解理解。

假设、我现在要对一个学生数组进行排序，每个学生都有姓名、年龄、成绩。

我们知道，对一个基本数据类型的数组进行排序，不就是调用Arrays.sort()方法嘛，这有什么难的？比如：

这非常容易理解，将array这个数组传过去，Arrays.sort()底层会调用默认的compareTo方法进行排序。但是现在我们要比较的是引用类型了，肯定就不能像这样直接给 sort()传一个引用类型数组过去了，就比如果传个学生数组过去，sort()方法怎么知道按照什么来排，是姓名、还是年龄又或者是成绩？在这个不确定的情况下编译器肯定不会给你通过的，直接报错。那究竟怎么比较呢，就需要我们去实现Comparable接口，重写里面的compareTo方法自己来规定了，请看下文。

我们先借助一下API文档看看Comparable里面的方法：

Comparable接口里面只有一个compareTo方法，我们实现它的话就需要重写该方法了。重写后Aarrays.sort()底层就会调用你重写的compareTo方法，所以我们就是通过重写这个方法来告诉Aarrays.ssort()方法我们希望怎么排序。如果按照年龄来排序，就可以写成如下：

import java.util.Arrays;

class Student implements Comparable<Student>{
    String name;
    int age;
    float grade;

    public Student(String name, int age, float grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//按照年龄来排
    }

}
public class Test2 {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("zhangdan",12,72.3f);
        students[1]=new Student("lisi",26,36.8f);
        students[2]=new Student("wangwu",70,98.6f);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

如果按照姓名来的话，就需要重写ComparaTo方法为以下即可：

如果是希望按照成绩来排的话，则可以写成这样：

 看到这里，现在又有看不懂的地方了，这Comparable后面的<Student>是什么鬼？ComaTo里面的this又是什么呢？简单在这里跟大家说一说，这里的Comparable是一个泛型，因为自定义的类型是没有具体的类型的。我们要对Student的对象进行排序，就需要将Student在这个类型传进去，相当于是类型参数化；什么是this呢，就是哪个对象调用这个方法，那个对象就是this，不熟悉的友友可以去看一下我的这两篇文章，了解泛型和this引用，里面都有很详细的讲解。

以上的输出结果分别是：

按照年龄来排：

按照姓名来排：

按照成绩来排：

 如果不是用于数组排序，仅对两个对象来说，也是一样的，比如：

class Student implements Comparable<Student>{
    String name;
    int age;
    float grade;

    public Student(String name, int age, float grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }
    @Override
    public int compareTo(Student o) {
         //return this.age-o.age;//按照年龄来排
        return this.name.compareTo(o.name);//按照姓名来排
        //return (int)(this.grade-o.grade);//按照成绩来排

    }

}
public class Test2 {
    public static void main(String[] args) {

        Student student1=new Student("zhangdan",12,72.3f);
        Student student2=new Student("changdan",28,66.3f);
        System.out.println(student1.compareTo(student2));
        
    }
}

输出结果：

以上就是用实体类来实现Comparable接口来进行引用类型的比较了。

---

2、使用比较器（即使用Comparator接口中的compare方法）

这种方式不同于第一种最大的优点就是解耦。什么意思呢？分析第一个例子的代码，我们是修改了原来的Student类，修改成让它去是实现Comparable接口，并且需要在Student类里面需要重写ComparaTo方法，在业务代码中根据ComparaTo方法完成排序。在一些大项目中，实体类和业务代码通常由不同的人来写，如果你的今天想按成绩来比，明天想按年龄来比，你就需要不停的对这个实体类进行修改，首先写这个实体类的人让不让你改都是个问题，其次你改了这个实体类说不定又会对其他的业务代码有影响。所以一般我们在大型项目中很少在实体类中去写一些具有特殊性、改动性很大的方法，因此比较器就可以帮我们实现不用改Student类就可以完成排序的需求了。

比较器就是通过Comparator接口中的compare方法来进行比较，因此我们需要自己写一个业务类来实现Comparator接口，重写里面的compare方法。以上那个例子可以改为如下：

import java.util.Arrays;
import java.util.Comparator;

class Student{
    String name;
    int age;
    float grade;

    public Student(String name, int age, float grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }

}

//按照年龄排序
class AgeComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.age- o2.age;
    }
}
//按照姓名排序
class StrComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
//按照成绩排序
class GradeComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.grade- o2.grade);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("zhangdan",12,72.3f);
        students[1]=new Student("lisi",16,36.8f);
        students[2]=new Student("wangwu",70,98.6f);

        AgeComparator ageComparator=new AgeComparator();
        StrComparator strComparator=new StrComparator();
        GradeComparator gradeComparator=new GradeComparator();

        //Array.sort()需要传两个参数，一个为对象，一个为比较器
        Arrays.sort(students,ageComparator);
        System.out.println(Arrays.toString(students));

        Arrays.sort(students,strComparator);
        System.out.println(Arrays.toString(students));

        Arrays.sort(students,gradeComparator);
        System.out.println(Arrays.toString(students));
    }
}

 运行结果：

如果是两个单独的对象进行比较时，如下： 

运行结果：

  

以上就是比较器的讲解啦， 比较器的好处就是独立于类而存在，对类的侵入性不强。具有一定的灵活性。

---

 以上就是我要今天分享的内容啦，后续我还会继续更新的哒，常看我的博客会学到很多知识哦