Java对象的比较——equals方法，Comparable接口，Comparator接口

已于 2024-06-02 17:21:13 修改
阅读量1.1k 收藏 29
点赞数 12
分类专栏： Java 文章标签： java 开发语言 jvm
于 2024-06-01 11:01:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ijj_zZ/article/details/139299949
版权

Java对象的比较——equals方法，Comparable接口，Comparator接口

1. equals方法

在判断两个整数是否相同时，我们可以使用以下方式：

System.out.println(1 == 2);
System.out.println(1 == 1);

如果输出true，则说明这两个整数相同；如果输出false，则说明这两个整数不相同

那么，如果将==用于判断两个对象，又会是怎样的情况呢？我们直接敲代码来看看！

public class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test1 {
    public static void main(String[] args) {
        Dog dog1 = new Dog("zhangsan",1);
        Dog dog2 = new Dog("zhangsan",1);
        System.out.println(dog1 == dog2);
    }
}

运行结果：
在这里插入图片描述
当运行这段代码时，我们发现输出的是false。明明dog1和dog2的属性都一模一样，为什么输出false呢？莫慌，且听我慢慢道来！
在这里插入图片描述
画图来分析，dog1和dog2中存放的值并不相同，因此dog1 != dog2。而你之所以认为输出的应该是true，是因为你认为，两个对象的属性完全一致，所以dog1 == dog2.其实，并不是这样的，==判断的并不是对象的属性是否一致，而是判断两个引用指向的是否是同一个对象！

在Java中，一切皆对象。而dog1和dog2是对象的引用。==判断的并不是对象的属性是否一致，而是判断两个引用指向的是否是同一个对象！

因此，只有当两个引用指向同一对象才返回true；而如果两个引用指向不同的对象，即使两个对象的属性完全相同，返回依旧是false！

总结：

  • 如果==左右两边是基本数据类型变量，比较的是变量中的值是否相同
  • 如果==左右两边是引用数据类型变量，比较的是引用变量中的值是否相同，而引用变量中存放的是对象的地址，所以比较的就是引用变量中存放的地址是否相同（即判断两个引用指向的是否是同一个对象！）

理解了这一点，学习equals方法就简单多了！我们先来看看equals方法的原型，equals方法在Object类中
在这里插入图片描述
有没有发现，equals方法，返回正是刚刚所讲的内容，说明equals方法默认就是判断两个引用指向的是否是同一个对象！

注意： equals方法的返回值是boolean类型！

再来尝试运行这段代码：

public class Test1 {
    public static void main(String[] args) {
        Dog dog1 = new Dog("zhangsan",1);
        Dog dog2 = new Dog("zhangsan",1);
        System.out.println(dog1.equals(dog2));
    }
}

运行结果依旧是false

那么，问题来了，如果我们想通过比较两个对象的属性是否相等，如果相等，从逻辑上就说明他们就是相等的，该怎么办呢？

我们知道Object类是一切类的父类，而equals方法在Object类中，是不是就通过可以重写equals方法，从而达到自定义比较方式的目的！

下面就演示重写equals方法，规则：如果两个对象的属性完全一致，则返回true；否则放回false

public class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj) {
        Dog tmp = (Dog)obj;
        return this.name.equals(tmp.name) && this.age == tmp.age;
    }
}

public class Test1 {
    public static void main(String[] args) {
        Dog dog1 = new Dog("zhangsan",1);
        Dog dog2 = new Dog("zhangsan",1);
        System.out.println(dog1.equals(dog2));
    }
}

这时运行代码，输出的就是true！

这时，有人可能就有疑问了，为什么名字比较要用equals方法，其实这里的equals方法并非Dog类中的equals方法，而是String类中的equals方法，用来判断两个字符串是否相等

String类中的equals方法原型：
在这里插入图片描述
注意： 对比String类中equals方法和Object类中equals方法的区别，Object类中的equals方法默认是判断两个对象的地址是否一致，如果想从逻辑上判断两个对象相等（即属性完全一致）就需要重写equals方法，而String类中equals方法直接就是从逻辑上判断两个字符串是否相同的（即判断两个字符串内容是否相同）
在这里插入图片描述

  • 第3行代码是判断两个字符串内容是否一致，因此会执行第4行代码
  • 第5行代码是判断两个字符串的地址是否一致，因此不会执行第6行代码

另外，编译器可以帮我们自动生成equals方法，第一步按住alt+insert
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
一路点下去，就可以生成equals方法，除此之外，还生成了hashCode方法
在这里插入图片描述

2. Comparable接口

通过重写equals方法，我们可以从逻辑上去判断两个对象是否相同。但是如果要去比较两个对象的大小，又该怎么去比较呢？对象的属性那么多，通过什么属性去比较呢？这时就需要讲到Comparable接口！

在这里插入图片描述
当我们在Student类后加上Comparable接口时，发现会报错，这是为什么呢？我们按住CTRL键，再鼠标左击Comparable，进入源码
在这里插入图片描述
我们发现，Comparable接口中还有个compareTo抽象方法，因此当我们在Student类要实现这个方法，除此之外，Comparable接口后还有个，这是泛型，我们需要比较什么类型的对象，就在实现接口时把T改成什么
在这里插入图片描述
由编译器自动生成实现compareTo方法的代码后：
在这里插入图片描述
我们就需要书写compareTo的方法体，那怎么书写呢？你想根据哪个对象的属性进行比较，就怎么书写。

比如，我现在想根据对象的年龄进行比较
在这里插入图片描述
下面进行测试：

public 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 Test {
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan", 18);
        Student student2 = new Student("lisi", 10);
        System.out.println(student1.compareTo(student2));
    }
}

运行结果：
在这里插入图片描述
返回的是一个正数，说明根据年龄比较，student1大于student2

再比如，我不想根据年龄比较了，我想根据姓名比较，这时就不能用简单的this.name-o.name了，因为name是一个String类型，不能通过这样的方式进行比较
在这里插入图片描述
方法里的compareTo指并不是在Student类中具体实现的这个compareTo，而是String类中的conpareTo，用于字符串的比较，它的底层是和C语言的strcmp是一样的，返回的是两个字母的ASCII 码的差值
String类中的compareTo方法

那么，问题来了，前面我们比较的只有两个对象，如果需要比较多个对象呢，改怎么办呢？这时候就需要用到数组来存放对象，用Arrays里的排序方法进行排序

当我们写下以下代码：

public class Student {
    private String name;
    private int age;

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

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

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("zhangsan",18),
                new Student("lisi", 10),
                new Student("wangwu", 20)};
        System.out.println("排序前：" + Arrays.toString(students));
        Arrays.sort(students);
        System.out.println("排序后：" + Arrays.toString(students));
    }
}

当我们运行代码后，发现会出现异常
在这里插入图片描述
在这里插入图片描述

这里需要用到强转，而Student类并没有去实现Comparable接口，因此会导致强转失败！这就是异常所在！所以，我们需要在Student类中实现Comparable接口

public 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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
}

在这里插入图片描述

当我们再次去运行代码时，会发现排序后是根据年龄从小到大排序的，这和Student类中实现的compareTo难道有关系？答案是正确的

假如我们想按照年龄从大到小去排序，就做出如下更改
在这里插入图片描述
调换顺序即可，再次运行代码：
在这里插入图片描述

假如想根据年龄去比呢？

public 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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }
}

public class Test1 {
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("zhangsan",10),
                new Student("lisi", 18),
                new Student("wangwu", 9)};
        System.out.println("排序前：" + Arrays.toString(students));
        Arrays.sort(students);
        System.out.println("排序后：" + Arrays.toString(students));
    }
}

3. Comparator接口

在前面使用Comparable接口来实现对象的比较时，我们不难发现，这个比较方法并不灵活，只能固定地通过一种方式去比较，那么如果我们有的时候想通过年龄比较，有的时候想通过姓名比较，这个接口就无法实现了，这时地解决办法就是，换一个接口，用Comparator接口来实现！

这时，我们分别写两个类——NameComparator和AgeComparator，代表分别通过姓名比较和通过年龄比较。并且这两个类都要实现Comparator接口！

import java.util.Comparator;

public class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().compareTo(o2.getName());//姓名通过compareTo方法进行比较
    }
}

import java.util.Comparator;

public class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge() - o2.getAge();
    }
}

注意： 实现Comparator接口需要重写的时compare方法，不是compareTo方法！实现Comparable接口重写的才是compareTo方法！

学生类如下：

public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

测试一下代码：

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //两个对象的比较
        AgeComparator ageComparator = new AgeComparator();
        NameComparator nameComparator = new NameComparator();
        Student student1 = new Student("zhangsan", 20);
        Student student2 = new Student("lisi", 30);
        System.out.println("根据年龄比：" + ageComparator.compare(student1, student2));
        System.out.println("根据姓名比：" + nameComparator.compare(student1, student2));

        //一组对象的比较
        Student[] students = new Student[]{
                new Student("zhangsan", 10),
                new Student("lisi", 18),
                new Student("wangwu", 9)};
        System.out.println("排序前：" + Arrays.toString(students));
        Arrays.sort(students, ageComparator);
        System.out.println("根据年龄排序后：" + Arrays.toString(students));
        Arrays.sort(students, nameComparator);
        System.out.println("根据姓名排序后：" + Arrays.toString(students));
    }
}

分析两个对象的比较：
在这里插入图片描述
这里，我们创建了一个AgeComparator和一个NameComparator对象，用来表示是通过年龄比较还是通过姓名比较。注意最后两个Student类对象的比较方法

分析一组对象的比较：
在这里插入图片描述
我们发现，在用Arrays.sort排序时，里面还加上了一个ageComparator对象（或NameComparator对象），通过这个对象，可以控制通过什么方式去比较，当使用Arrays对数组进行排序时，就会调用ageComparator（或NameComparator）里的compare方法依次将数组里的对象进行比较

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

请添加图片描述

阿杰来学编程
关注
专栏目录
Java 判断两个对象是否相等
weixin_44262126的博客
04-10 5249
1 使用 == 与 equals 判断 == : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。其中，对于基本数据类型 ，它比较的是值；对于引用数据类型，它比较的是内存地址。 equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况： 情况一：当类没有重写equals()方法时，通过equals()来比较该类的两个对象时就等价于通过==比较这两个对象。 情况二：当类重写了equals()方法时，这是我们比较常用的方式。此时，我们通常通过重写equal
Java五十七：比较接口（Comparable、Comparator）
开发者
11-18 1908
比较类 引入 Java中的对象，正常情况下，只能进行比较：== 或 != , 不能进行 > 或 < 的比较。 ​ 但在开发场景中，我们需要对多个对象进行排序，即需要比较对象的大小。 ​ 如何实现：需要两个接口中的任意一个：Comparable 或 Comparator 一、Comparable接口 自然排序 像String、包装类等实现了Comparable接口，重写了compareTo( ) 方法，给出了比较两个对象大小的方式，方式是从小到大。 实现Compa
Java中如何判断两个对象是否相等
最新发布
lin1151211427的博客
08-30 1084
Java中如何判断两个对象是否相等
java实现比较的接口_java – 实现接口比较器
weixin_42139460的博客
02-17 312
我不确定你打算把比较器放在哪里.既然你希望你的班级实现Comparable< Organism>,我会假设你正在寻找像class Bacteria implements Organism {enum Shape {ROD, ROUND, SPIRAL};private final Shape shape;Comparator comparator =Comparator.compari...
java compareable接口_Java中实现对象的比较：Comparable接口和Comparator接口
weixin_32256355的博客
02-16 453
在实际应用中，我们往往有需要比较两个自定义对象大小的地方。而这些自定义对象的比较，就不像简单的整型数据那么简单，它们往往包含有许多的属性，我们一般都是根据这些属性对自定义对象进行比较的。所以Java中要比较对象的大小或者要对对象的集合进行排序，需要通过比较这些对象的某些属性的大小来确定它们之间的大小关系。一般，Java中通过接口实现两个对象的比较，比较常用就是Comparable接口和Compar...
Java对象的比较：Comparable接口和Comparator接口
吃透Java
05-08 377
在实际应用中，我们往往有需要比较两个自定义对象大小的地方。而这些自定义对象的比较，就不像简单的整型数据那么简单，它们往往包含有许多的属性，我们一般都是根据这些属性对自定义对象进行比较的。所以Java中要比较对象的大小或者要对对象的集合进行排序，需要通过比较这些对象的某些属性的大小来确定它们之间的大小关系。一般，Java中通过接口实现两个对象的比较，比较常用就是Comparable接口和Compara
Java 比较接口comparable与comparator区别解析
08-25
Java 语言中提供了两个比较接口： Comparable 和 Comparator，这两个接口都是用于比较对象的大小顺序的，但它们有着不同的使用场景和实现方式。在本文中，我们将详细介绍这两个接口的区别和使用方法。 Comparable ...
对比Java中的Comparable排序接口和Comparator比较器接口
09-02
Comparator接口包含两个方法：`compare(T o1, T o2)`用于比较两个对象的大小，以及`equals(Object obj)`，虽然可以不实现，但为了遵循通用的equals合同，建议在自定义Comparator时重写此方法以确保一致性。...
详解Java中Comparable和Comparator接口的区别
08-29
Java 中的 Comparable 和 Comparator 接口都是用于比较和排序的，但是它们之间存在着一些关键的区别。Comparable 是一个排序接口，若一个类实现了 Comparable 接口，就意味着该类支持排序。Comparable 接口仅包含一...
java 中Comparable与Comparator详解与比较
08-30
在Java编程语言中，Comparable和Comparator接口用于比较对象的顺序，尤其在进行排序操作时非常关键。两者虽然目的相似，但使用方式和应用场景有所区别。 Comparable接口定义在`java.lang`包中，它只有一个方法`...
java比较接口
qq_43898866的博客
12-03 397
【代码】java比较接口。
java 判断 and_Java中如何判断两个对象是否相等（Java equals and ==）
weixin_39807691的博客
02-12 175
本文地址：https://www.dutycode.com/post-140.html除非注明，文章均为 www.dutycode.com 原创，欢迎转载！转载请注明本文地址,谢谢。如何判断两个对象相等，这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。从以下几个点来理解equals和hashCode方法：1、equals的作用及与==的区别。2、hashcode的作用及...
java 可比较接口_java集合比较&接口....
weixin_32484447的博客
03-07 223
若一个类实现了comparable接口，则意味着该类支持排序。如String、Integer自己就实现了Comparable接口，可完成比较大小操作。一个已经实现comparable的类的对象或数据，可以通过Collections.sort(list) 或者Arrays.sort(arr)实现排序Comparable理解为内部比较器，而Comparator是外部比较器实现了Comparable接口...
Java比较器（Comparable接口）
qq_57780419的博客
08-31 1179
Java比较器（Comparable接口）
Java中对象属性的比较详解
DevNinja的博客
10-03 2525
如果重写了equals()方法，还应该同时重写hashCode()方法，并保持两者的一致性。在比较对象属性时，我们可以重写equals()方法，根据属性的值逐个进行比较。在上面的示例中，我们重写了equals()方法，首先判断两个对象的引用是否相等，然后判断对象的类型是否相同，最后比较对象的属性值。在上面的示例中，我们重写了equals()方法，首先判断两个对象的引用是否相等，然后判断对象的类型是否相同，最后比较对象的属性值。比较方法应该保持一致性，即对于相同的对象，每次比较都应该得到相同的结果。
java 比较接口_【Java】【常用类】Comparable 可比较接口 Comparator 比较器接口
weixin_42471893的博客
02-21 297
我们需要对对象进行排序，但是对象不是像基本类型的那样，是具体的数值如果要对对象比较，需要实现两个接口的任意一个即可Comparable 可比较接口 Comparator 比较器接口String包装类等等、实现了Comparable接口，重写CompareTo()方法重写compareto类比equals方法重写，获取属性的内容进行比较自然排序- this.field > obj.field...
Java比较接口 Comparable和Comparator
CstomRita的博客
08-19 663
Comparable package java.lang; import java.util.*; public interface Comparable&amp;lt;T&amp;gt; { public int compareTo(T o); } 致定义了一个compareTo方法，比较此对象和参数对象o的大小，若此对象小则返回负数，若此对象大则返回正数，若相等则为0 实现了Compara...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值