• 技术文章 >Java >java教程

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

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

    php入门到就业线上直播课:进入学习

    推荐学习:《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 = 'a';
            char c2 = 'b';
            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); 编译报错
        }
    }

    从上述的结果来看,自定义类型不能使用>,<来比较,为什么可以使用==来比较?

    ==比较自定义类型时,比较的是对象的地址是否相同

    但是我们往往需要比较对象的内容,如往优先级队列中插入某个对象,需要按照对象的内容来调整堆,那如何比较呢?

    三. 对象比较的方法

    1. equals方法比较

    Object类是每一个类的基类,其提供了equals()方法来进行比较内容是否相同

    但是Object中的equals方法默认是用==来比较的,也就是比较两个对象的地址 ,所以想让自定义类型可以比较,可以重写基类的equals()方法

    例:

    class Student{
        String name;
        int age;
     
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
     
        @Override
        public boolean equals(Object obj) {
            if(this == obj){
                return true;
            }
            if(obj==null || !(obj instanceof Student)){
                return false;
            }
            Student s = (Student) obj;
            return this.age==s.age && this.name.equals(s.name);
        }
    }
    public class Test {
        public static void main(String[] args) {
            Student s1 = new Student("张三",25);
            Student s2 = new Student("李四",31);
            Student s3 = new Student("李四",31);
            System.out.println(s1.equals(s2));
            System.out.println(s2.equals(s3));
        }
    }

    结果:可以比较内容是否相同

    重写equals方法的步骤

    注意事项

    equals()方法只能比较两个对象是否相同,不能按照>,<的方式来进行比较

    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接口的比较

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

    使用比较器使得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中文网其它相关文章!

    声明:本文转载于:脚本之家,如有侵犯,请联系admin@php.cn删除
    专题推荐:java
    上一篇:一起聊聊Java Valhalla Project项目 下一篇:图解Java经典算法折半查找的原理与实现
    VIP课程(WEB全栈开发)

    相关文章推荐

    • ❤️‍🔥共22门课程,总价3725元,会员免费学• Java Web动态网站开发教程• Java数据结构之最小堆和最大堆的原理及实现详解• 归纳总结JavaScript条件判断使用技巧• 一起聊聊Java封装、继承、多态特性• 一起聊聊Java Valhalla Project项目
    1/1

    PHP中文网