总结分享Java比较两个对象大小的三种方法

本篇文章给大家带来了关于java的相关知识，在优先级队列中插入的元素必须能比较大小，如果不能比较大小，如插入两个学生类型的元素，会报ClassCastException异常。下面介绍了Java比较两个对象大小的三种方法，希望对大家有帮助。

推荐学习：《java视频教程》

一. 为什么需要比较对象

上一节介绍了优先级队列，在优先级队列中插入的元素必须能比较大小，如果不能比较大小，如插入两个学生类型的元素，会报ClassCastException异常

示例：

class Student{
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        PriorityQueue<Student> p = new PriorityQueue<>();
        p.offer(s1);
        p.offer(s2);
    }
}

结果：

原因：因为优先级队列底层使用了堆数据结构，往堆中插入元素时，需要进行元素的比较，而Student是没有办法直接比较的，所以抛出异常

二. 元素的比较

1. 基本类型的比较 

Java中，基本类型的元素可以直接进行比较

public class TestCompare {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a>b);
        System.out.println(a==b);
        System.out.println(a<b);
 
        char c1 = &#39;a&#39;;
        char c2 = &#39;b&#39;;
        System.out.println(c1==c2);
        System.out.println(c1>c2);
        System.out.println(c1<c2);
 
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b1==b2);
        System.out.println(b1!=b2);
    }
}

2. 引用类型的比较 

class Student{
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        Student s3 = s1;
        System.out.println(s1==s2);  //false
        System.out.println(s1==s3);  //true
        //System.out.println(s1<s2); 编译报错
        //System.out.println(s1>s3); 编译报错
    }
}

从上述的结果来看，自定义类型不能使用>，470e2c807f5aa958325ee8e07b64dda2，<的方式来进行比较

2. 基于Comparable接口的比较

对于引用类型，如果想按照大小的方式进行比较，在定义类时实现Comparable接口，然后在类中重写compareTo方法

例：比较两个人的大小，一般按照年龄来比较

class Person implements Comparable<Person>{
    String name;
    int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public int compareTo(Person o) {
        if(o == null){
            return 1;
        }
        return this.age-o.age;
    }
}
public class Test1 {
    public static void main(String[] args) {
        Person p1 = new Person("小王",22);
        Person p2 = new Person("小张",21);
        Person p3 = new Person("小方",22);
        System.out.println(p1.compareTo(p2)); //>0表示大于
        System.out.println(p2.compareTo(p3)); //<0表示小于
        System.out.println(p1.compareTo(p3)); //==0表示相等
    }
}

compareTo方法是java.lang中的接口类，可以直接使用

使用Comparable接口使得Student类型的对象可以插入到优先级队列中

import java.util.PriorityQueue;
 
class Student implements Comparable<Student> {
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public int compareTo(Student o) {
        if(o == null){
            return -1;
        }
        return this.age-o.age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        Student s3 = new Student("李四",35);
        PriorityQueue<Student> p = new PriorityQueue<>();
        p.offer(s1);
        p.offer(s2);
        p.offer(s3);
    }
}

结果：Student类型的对象也可以插入优先级队列中

3. 基于Comparator接口的比较

按照比较器的方式比较具体步骤如下：

• 创建一个比较器类，实现Comparator接口
• 重写compare方法 

使用比较器使得Student类型的对象可以插入到优先级队列中 

import java.util.Comparator;
import java.util.PriorityQueue;
 
class Student {
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class StudentComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        if(o1 == o2){
            return 0;
        }
        if(o1 == null){
            return -1;
        }
        if(o2 == null){
            return 1;
        }
        return o1.age-o2.age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        Student s3 = new Student("李四",35);
        PriorityQueue<Student> p = new PriorityQueue<>(new StudentComparator());
        p.offer(s1);
        p.offer(s2);
        p.offer(s3);
    }
}

结果：Student类型的对象可以插入到优先级队列中

Comparator是java.util包中的泛型接口类，使用必须导入相应的包

4. 三种比较方式对比

重写的方法	说明
Object.equals	只能比较两个对象的内容是否相等，不能比较大小
Comparable.compareTo	类要实现接口，对类的侵入性较强，破坏了原来类的结构
Comparator.compare	需实现一个比较器类，对类的侵入性较弱，不破坏原来的类

Comparable，Comparator使用哪种比较方式呢？

如果拿到的是别人定义的类，我们不能对类进行操作，就选用创建类实现Comparator接口的方法

如果类是用户自己定义的类，可以对类进行操作，则采用实现Comparable接口的方法

推荐学习：《java视频教程》

以上是总结分享Java比较两个对象大小的三种方法的详细内容。更多信息请关注PHP中文网其他相关文章！