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

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

Java系列文章目录

在这里插入图片描述

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

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

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循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);
    }
}

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

在这里插入图片描述

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

马上回来了
关注
专栏目录
01_JavaSE零基础
07-22
资源名称：01_JavaSE零基础资源目录：000_动力节点_Java零基础_讲义000_动力节点_Java零基础_课堂笔记001_动力节点_Java零基础_安装EditPlus002_动力节点_Java零基础_计算机概述003_动力节点_Java零基础_Java软件...
implements Comparable接口并重写compareTo(T o)方法实现比较与排序
是小光a~
03-12 3059
implements Comparable接口并重写compareTo方法实现比较与排序实现Comparable接口并重写compareTo(T o)方法后实现比较排序：插入排序（它对实现Comparable接口的任何类型的数据进行排序，时间复杂度n^2）：例如我们在counter类中实现comparable接口并实现了CompareTo()方法以期进行比较排序：归并排序（它对实现Comparable接口的任何类型的数据进行排序，时间复杂度nlgn，但空间上需要Comparable[] aux这样一个与原数
利用ArrayList对map进行按key（键）和按value (值) 排序
qq_41487251的博客
09-08 4630
利用ArrayList对map进行按key(键)和按value (值) 排序 总感觉按照值得应该比较少，意义好像也不大，感觉还没有真正懂。 使用比较器 按key（键）排序 通过ArrayList将map.entrySet()，变成list 然后在类外写具体如何比较大小的方法compare()，最后调用 Collections.sort(list, new Comparator<Map.Entry<String, String>>() import java.util.*; pub
对象集合排序（需要implements Comparable）
qq_34723470的博客
01-19 7588
public class Student implements Comparable { /** * 对象的排序方式[升、降],true为升序反之降序 */ private static boolean sortASC = true; /** * 对象的排序属性,根据对象自己设置的id,名字、出生日期 */ private
java基础：9.2 接口implements，Comparable，Cloneable接口
桃子味的梨
01-16 3594
1、接口的定义 接口(interface)用来描述类具有什么功能，而不给出每个功能的具体实现。接口只包含常量和抽象方法，不能含有实例域，也不能在接口中实现方法！接口在许多方面都与抽象类很相似，但是它的目的是指明相关或者不相关类的多个对象的共同行为。 每个类只能拥有一个超类，但能拥有多个接口。接口提供了多继承的好处，且避免了多重继承的复杂性和低效性。 与抽象类相似，不能使用new 操作符创建接...
Comparable接口、Comparator接口、Cloneable接口
zyyy0的博客
09-27 592
Cloneable接口用来克隆一个对象，也就是产生一个对象的副本(对象的内存地址不同)，对象的副本和原对象不是一个对象，也就是它们的内存地址是不同的，新对象只是原对象的一个拷贝，Cloneable接口表面上是浅拷贝，也可以实现深拷贝。普通类实现Cloneable接口时，需要重写clone方法，clone方法中调用并返回父类(Object类)的clone方法，通过重写并调用clone方法得到返回的新对象内存地址(引用地址)来完成克隆。通过重写并调用compareTo方法得到的返回值来判断两个对象属性的大小。
JavaSE之接口概述
07-21
JavaSE中的接口是面向对象编程的一个重要概念，它充当了不同类之间的一种契约，定义了一组公共的方法规范，使得不同的类可以通过实现接口来遵循相同的协议。接口是引用数据类型，与类相似，但它们不能实例化，只能被...
JavaSE从零基础入门文档代码
02-04
这个“JavaSE从零基础入门文档代码”压缩包，包含了学习JavaSE所需的基本概念、语法和实践代码，是初学者踏入Java世界的一份宝贵资料。 文档部分可能涵盖以下知识点： 1. **Java简介**：介绍Java的历史、特点和...
JavaSE 接口
12-21
##javase 接口干货知识点斜体样式 一、接口的概念 1.接口:是- -种标准、规范,接口的使用者和接口的实现者都 必须遵循的约定。 2.语法: (基于 jdk7.0版本) [重点] (1)关键字: interfaceinterface接口名{} (2)接口在...
javaSE基础语法，详细注释和标签，排版整齐
09-14
本文将详细讲解JavaSE中的基础语法，并结合相关标签进行阐述。 1. **Java虚拟机与运行环境** Java程序需要在Java虚拟机（JVM）上运行，它负责解释和执行字节码。Java运行环境（Java Runtime Environment, JRE）...
Java学习笔记（32）-Comparable接口
Jak的博客
05-24 316
package day03; /** * 可比较的点 * 若我们定义的类想在数组或集合中可以排序，我们需要将当前类实现 * Comparable接口，并定义比较规则 * @author Administrator * */ public class ComparablePoint implements Comparable&lt;ComparablePoint&gt;{ /** ...
Comparable & Comparator的区别
weixin_49263647的博客
05-09 1927
Comparable & Comparator接口都可以用来实现集合中元素的比较、排序，Comparator位于包java.util下， Comparable位于包java.lang下 Comparable接口将比较代码嵌入自身类中 Comparator在一个独立的类中实现比较。 像Integer、String等这些基本类型的JAVA封装类都已经实现了Comparable接口，这些类对象本身就支持自比较，直接调用Collections.sort()就可以对集合中元素的排序，无需自己去实现Compar
【java笔记】常用接口：Comparable接口
暮色年华的博客
05-15 6093
在学习数组时，Arrays类中的sort方法可以对对象数组进行排序但是： 对象所属的类必须实现Comparable接口。 Comparable接口的定义： java5之后接口可以加上泛型 对person按年龄排序： public class person implements Comparable<person>{ int age; String name; public person(int age, String name) { ...
来吧，一文彻底搞懂Java中的Comparable和Comparator
沉默王二
01-08 9940
大家好，我是沉默王二，周末在逛 programcreek 的时候，我发现了一些专注细节但价值连城的主题。比如说：Java 的 Comparable 和 Comparator 是兄弟俩吗？像这类灵魂拷问的主题，非常值得深入地研究一下。 另外，我想要告诉大家的是，我越来越喜欢这个系列的文章了，不知道大家有没有同样的感觉？假如有的话，那我就太荣幸了。总之，写的越多，我越发现，散落在海滩上的一颗颗珍珠被...
Comparable和Comparator接口
gswdzh的博客
03-31 308
Comparable接口Comparable可以用于比较的实现，实现了Comparable接口的类可以通过重写它的compareTo方法来定义排序规则public class Student implements Comparable<Student> {private int id;/** * 当前学生对象跟其他学生对象比较的方法（实现Comparable接口重写） * 返回值：-1表示小了
【Java 基础篇】Java 自然排序：使用 Comparable 接口详解
最新发布
繁依Fanyi的博客
09-13 6487
自然排序是一种默认的对象排序方式，它是根据对象的内在特征或属性来排序的。例如，对于整数，自然排序是按照数字的大小进行排序；对于字符串，自然排序是按照字母的字典顺序进行排序。自然排序通常是最直观和常见的排序方式，它使得对象在集合中以一种有序的方式存储和检索。在 Java 中，自然排序是通过Comparable接口来实现的。这个接口定义了一个compareTo方法，允许对象自己来决定如何与其他对象进行比较。Comparable接口是一个泛型接口，通常在类的声明中使用泛型参数来指定需要比较的对象类型。
Java比较器（Comparable接口）
qq_57780419的博客
08-31 1179
Java比较器（Comparable接口）
深度解析Java中的Comparable接口和Comparator接口
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5939
给学生对象数组排序的两种方法——Comparable接口和Comparator接口
【Java】Comparable接口的实现与使用
南花醉笔丶的博客
03-10 6545
Comparable接口的实现与使用1 Comparable接口声明及其作用2 实例 1 Comparable接口声明及其作用 想对某个类的对象之间做比较，就需要实现Comparable 接口。接口中只有一个方法compareTo，这个方法定义了对象之间的比较规则。依据这个“比较规则”，我们就能对所有对象实现排序。 下面是Comparable接口的声明以及作用，可以看到它可以使继承他的类进行比较大小，只需要调用实现类的compareTo方法即可 public interface Comparable &l
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

马上回来了

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

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

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

打赏作者

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

抵扣说明：

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

余额充值