JAVASE语法零基础——Comparable接口、Comparator接口

最新推荐文章于 2024-06-06 08:46:39 发布
最新推荐文章于 2024-06-06 08:46:39 发布
阅读量1.2k 收藏 7
点赞数 3
分类专栏： JAVASE 0基础入门 文章标签： java 服务器 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_62160964/article/details/125569735
版权

Java系列文章目录

在这里插入图片描述

Write once,Runanywhere.🔥🔥🔥
这篇文章的接口用于实现自定义类的比较。

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在优快云首发、需要转载请联系博主。
版权声明：本文为优快云博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

在这里插入图片描述

🚀🚀🚀 新的知识开始喽🚀🚀🚀
在这里插入图片描述

文章目录

1.Comparable接口

现在先创建一个学生类，学生类的基本信息：名字、年龄、成绩。

class Student{
//实例成员
    public String name;
    public int age;
    public double score;
    //构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
//对象打印
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

然后实例化两个学生对象：

class Student{
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
public class Test0 {
  public static void main(String[] args) {
        Student student = new Student("小王",19,85.0);
        Student student1 = new Student("小李",18,90.0);
        if(student.compareTo(student1)>0){
            System.out.println("student>student1");
        }
    }
  }

现在要比较这三个学生对象的大小，也就是给这三个对象排序，应该怎么弄呢？
排序的对象是我们自定义的学生类对象，这个学生类引用的对象有三个成员属性，因此我们必须选取一个成员属性来排序，我们选取age然后用Comparable接口实现排序。

class Student implements  Comparable<Student> {//自定义比较类实现Comparable<自定义类>接口
    //实例成员
    public String name;
    public int age;
    public double score;
//构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
//重写对象打印
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    //实现Comparable<自定义类>接口 必须重写compareTo这个方法 来选择自定义类型排序选择的方式，这里选择age
    @Override
    public int compareTo(Student o) {//排升序
        //return this.age - o.age;
        if (this.age > o.age) {
            return 1;
        } else if (this.age == o.age) {
            return 0;
        } else {
            return -1;
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("小王",19,85.0);
        Student student1 = new Student("小李",18,90.0);
        //student引用调用重写的compareTo方法，student1引用作为参数
        if(student.compareTo(student1)>0){
            System.out.println("student>student1");
        }else if(student.compareTo(student1)<0){
            System.out.println("student>student1");
        }else{
            System.out.println("student=student1");
        }
    }
}

运行结果：
在这里插入图片描述
现在创建一个是Student类型的数组进行，也按照age来进行比较：

class Student implements  Comparable<Student> {//自定义比较类实现Comparable<自定义类>接口
    //实例成员
    public String name;
    public int age;
    public double score;
//构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
//重写对象打印
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    实现Comparable<自定义类>接口 必须重写compareTo这个方法 来选择自定义类型排序选择的方式，这里选择age
    @Override
    public int compareTo(Student o) {//排序为升序
        //return this.age - o.age;
        if (this.age > o.age) {
            return 1;
        } else if (this.age == o.age) {
            return 0;
        } else {
            return -1;
        }
//        if (o.age > this.age){
//            return 1;
//        }else if(this.age == o.age){
//            return 0;
//        }else{
//            return -1;
//        }
//    }
    }
}
public class Test {

    public static void main1(String[] args) {
        Student[] student = new Student[3];
        //每一个数组元素都是一个学生对象
        student[0] = new Student("小王",19,85.0);
        student[1] = new Student("小李",17,75.0);
        student[2] = new Student("小刘",18,95.0);
        System.out.println("排序前"+Arrays.toString(student));
        Arrays.sort(student);
        System.out.println("排序后"+Arrays.toString(student));

    }
}

运行结果：
在这里插入图片描述
如果不实现Comparable接口，数组排序直接使用 Arrays.sort：
在这里插入图片描述
compareTo也无法重写，运行报错：
在这里插入图片描述
在这里插入图片描述
可以看到错误提醒我们Comparable接口，并且ComparableTimSort试图强行帮我们进行类型转换和调用compareTo方法。

2.Comparator接口

Comparator接口：比较器。比Comparable接口更为灵活，Comparable接口一般用于设置默认的比较自定义类成员的方式。比较器可以

接着Compara接口那段按年龄大小比较的代码，现在我们又想按照成绩、名字比较大小，这时我们则需要使用CompareTo接口来实现。Comparator接口需要重写compare方法。

class Student implements  Comparable<Student> {//自定义比较类实现Comparable<自定义类>接口
    //实例成员
    public String name;
    public int age;
    public double score;
//构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
//重写对象打印
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    //实现Comparable<自定义类>接口 必须重写compareTo这个方法
    @Override
    public int compareTo(Student o) {
        //return this.age - o.age;
        if (this.age > o.age) {
            return 1;
        } else if (this.age == o.age) {
            return 0;
        } else {
            return -1;
        }
        if (o.age > this.age){
            return 1;
        }else if(this.age == o.age){
            return 0;
        }else{
            return -1;
        }
    }
    }
}
class ScoreComparetor implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score-o2.score);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("小王",19,85.0);
        Student student1 = new Student("小李",18,90.0);
///比较器先实例化出对象，然后调用compare这个比较方法
        ScoreComparetor scoreComparetor = new ScoreComparetor();
        int ret = scoreComparetor.compare(student,student1);
        System.out.println(ret);


  }
}

运行结果：
在这里插入图片描述

数组的比较：

class Student implements  Comparable<Student> {//自定义比较类实现Comparable<自定义类>接口
    //实例成员
    public String name;
    public int age;
    public double score;
//构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
//重写对象打印
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    实现Comparable<自定义类>接口 必须重写compareTo这个方法 来选择自定义类型排序选择的方式，这里选择age
    @Override
    public int compareTo(Student o) {//排序为升序
        //return this.age - o.age;
        if (this.age > o.age) {
            return 1;
        } else if (this.age == o.age) {
            return 0;
        } else {
            return -1;
        }
//        if (o.age > this.age){
//            return 1;
//        }else if(this.age == o.age){
//            return 0;
//        }else{
//            return -1;
//        }
//    }
    }
}
public class Test {

    public static void main1(String[] args) {
        Student[] student = new Student[3];
        //每一个数组元素都是一个学生对象
        student[0] = new Student("小王",19,85.0);
        student[1] = new Student("小李",17,75.0);
        student[2] = new Student("小刘",18,95.0);
         //实例化出比较器的对象
        ScoreComparetor scoreComparetor = new ScoreComparetor();
        System.out.println("排序前"+Arrays.toString(student));
        //自定义对象的引用,比较器的引用
        Arrays.sort(student,scoreComparetor);
        System.out.println("排序后"+Arrays.toString(student));
    }
}

运行结果：
在这里插入图片描述

3.总结

对于自定义类型的比较大小，需要通过Comparable接口、Comparator接口来实现。
Comparab接口需要重写compareTo方法，由于compareTo方法是在自定义类里实现，所以一般用于设置默认规则的比较设置。
Comparator接口又称为比较器，需要重写compare方法，相比Comparable接口Comparator接口更为灵活，通过创建一个新的比较规则类去与自定义类相结合，使比较形式更为灵活。
Comparable接口语法形式：

class 类 implements Comparable<自定义类名>{
.....
 //实现Comparable<自定义类>接口 必须重写compareTo这个方法
    @Override
    public int compareTo(Student o) {
        //return this.age - o.age;
        if (this.age > o.age) {
            return 1;
        } else if (this.age == o.age) {
            return 0;
        } else {
            return -1;
        }
}

Comparator接口语法形式：

//     比较规则类名               接口<自定义类>
class ScoreComparetor implements Comparator<Student>{
//重写compare方法 注意返回值类型
    @Override
    public int compare(Student o1, Student o2) {
    //通过引用来选取比较器要比较的成员属性
        return (int)(o1.score-o2.score);
    }
}

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

在这里插入图片描述

🌔 🌔 🌔下次见喽🌔 🌔 🌔
在这里插入图片描述

Java：接口应用(Comparable接口与比较器)
li_wj6的博客
03-28 883
通过上面的介绍，我们可以知道Comparable接口具有局限性，那么如果我们想要打破这个局限性我们就引入了比较器（Comparator接口）。接下来，我们来进行具体操作吧。String也是一个引用类型，当我们追溯到String原码时可以以发现String也实现了Comparable这个接口。通过上面我们实例化了两个对象“student1和student2”，但是他们都属于引用类型，我们该如何比较呢？，通过这个接口可以实现引用类型的比较。我们通过重写comparaTo方法可以实现我们引用类型的比较。
java基础：9.2 接口implements，Comparable，Cloneable接口
桃子味的梨
01-16 3678
1、接口的定义 接口(interface)用来描述类具有什么功能，而不给出每个功能的具体实现。接口只包含常量和抽象方法，不能含有实例域，也不能在接口中实现方法！接口在许多方面都与抽象类很相似，但是它的目的是指明相关或者不相关类的多个对象的共同行为。 每个类只能拥有一个超类，但能拥有多个接口。接口提供了多继承的好处，且避免了多重继承的复杂性和低效性。 与抽象类相似，不能使用new 操作符创建接...
java中的Comparable接口
weixin_33896726的博客
11-19 716
  类对象之间比较“大小”往往是很有用的操作，比如让对象数组排序时，就需要依赖比较操作。对于不同的类有不同的语义。如Student类，比较2个学生对象可以比较他们的score分数来评判。 Java不支持预算符重载，我们通过实现Comparable接口达到相同的目的。当类实现了Comparable接口，则认为这个类的对象之间是可比较的。   Comparable是java SDK中的一个内置...
Java排序 Comparable（实现Comparable接口）
weixin_41796049的博客
03-24 776
原文地址：https://blog.youkuaiyun.com/lichuangcsdn/article/details/80842223 1、首先新建第一个Student类 /** * 排序测试 通过实现Comprable的compareTo方法进行排序 */ public class Student implements Comparable<Student>{ privat...
JavaSE（十二）——Comparable接口与Comparator接口
最新发布
xiaokuer_的博客
06-06 680
文章介绍了对象比较的方法：基于实现Comparable接口与基于实现Comparator接口的比较器，是JavaSE语法的最后一篇
【JavaSE】抽象类和接口重点语法知识汇总（附有代码）
qq_68993495的博客
09-29 754
JavaSE语法之抽象类和接口，汇总了很多重点知识，很想对大家有帮助！
javaSE - 三个常用的接口（Comparable，Comparator，Cloneable）
ryy1999的博客
12-16 595
但是 Comparable 接口存在着缺陷: 如果我们要以学生的分数或者名字来排序，就需要重新 把 compareTo 方法的实现重写一遍，
javase基础练习代码
05-02
12. **比较与排序**：学习如何使用Comparable和Comparator接口对对象进行比较，以及Arrays.sort()和Collections.sort()方法进行排序。 13. **设计模式**：虽然初学者可能不会立即接触，但了解基本的设计模式（如...
【javaSE】抽象类与接口（3）（接口部分）
Easonmax的博客
04-04 2189
所以这就是我们的抽象类与接口的最后一章，里面涉及的知识点过多，还请大家认真多看几遍，好好消化。一起加油吧！
Java比较器（Comparable接口）
qq_57780419的博客
08-31 1223
Java比较器（Comparable接口）
对象集合排序（需要implements Comparable）
qq_34723470的博客
01-19 7632
public class Student implements Comparable { /** * 对象的排序方式[升、降],true为升序反之降序 */ private static boolean sortASC = true; /** * 对象的排序属性,根据对象自己设置的id,名字、出生日期 */ private
Java基础之【Comparable和Comparator】
黄三yeah的Java技术空间
06-28 922
排序主要分为三种情况 1.【内部排序】使用Comparable通过implements通过implements Comparable<Object>接口override compareTo方法实现 return值 0表示相等 1表示大于 -1表示小于 2.【外部排序】通过Comparator实现 3.以上1 2条针对的都是自定义类，而java对Integer String等已...
Java 基础 扩展接口类 实现Comparable
fengdeweilai的博客
06-06 398
jdk1.8 IDE:IDEA 接口的占位符是 implements，yis
implements Comparable接口并重写compareTo(T o)方法实现比较与排序
是小光a~
03-12 3159
implements Comparable接口并重写compareTo方法实现比较与排序实现Comparable接口并重写compareTo(T o)方法后实现比较排序：插入排序（它对实现Comparable接口的任何类型的数据进行排序，时间复杂度n^2）：例如我们在counter类中实现comparable接口并实现了CompareTo()方法以期进行比较排序：归并排序（它对实现Comparable接口的任何类型的数据进行排序，时间复杂度nlgn，但空间上需要Comparable[] aux这样一个与原数
Java学习笔记（32）-Comparable接口
Jak的博客
05-24 371
package day03; /** * 可比较的点 * 若我们定义的类想在数组或集合中可以排序，我们需要将当前类实现 * Comparable接口，并定义比较规则 * @author Administrator * */ public class ComparablePoint implements Comparable&lt;ComparablePoint&gt;{ /** ...
Java中Comparable接口的使用，匿名内部类的调用
weixin_51733609的博客
07-28 736
Java中Comparable接口的使用，匿名内部类的调用
深度解析Java中的Comparable接口和Comparator接口
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 6305
给学生对象数组排序的两种方法——Comparable接口和Comparator接口
Java示例中的Comparable和Comparator
从零开始的教程世界
07-12 376
Comparable and Comparator in Java are very useful for sorting the collection of objects. Java provides some inbuilt methods to sort primitive types array or Wrapper classes array or list. Here we will...
JavaSE25套题及答案：面试基础巩固利器
- 集合的排序和比较（Comparable和Comparator接口） 5. **Java I/O流：** - 字节流和字符流的使用 - 文件操作（如读取、写入、追加、复制、删除等） - 输入输出流的链式操作和缓冲流的使用 6. **Java多线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

马上回来了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值