Summary and sharing of three ways to compare the sizes of two objects in Java

This article brings you relevant knowledge about java. The elements inserted in the priority queue must be comparable in size. If the size cannot be compared, such as inserting two student type elements, A ClassCastException exception will be reported. The following introduces three methods for comparing the sizes of two objects in Java. I hope it will be helpful to everyone.

Recommended study: "java video tutorial"

1. Why comparison objects are needed

Previous section The priority queue is introduced. The elements inserted in the priority queue must be comparable in size. If the size cannot be compared, such as inserting two student type elements, a ClassCastException will be reported.

Example:

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);
    }
}

Result:

Cause: Because the bottom layer of the priority queue uses a heap data structure, when inserting elements into the heap, elements need to be compared, and Student has no way Direct comparison, so an exception is thrown

2. Comparison of elements

1. Comparison of basic types

In Java, elements of basic types can be compared directly

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. Comparison of reference types

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); 编译报错
    }
}

Judging from the above results, custom types cannot be compared using >, <. Why can they be compared using ==?

==When comparing custom types, what is compared is whether the addresses of the objects are the same

But we often need to compare the contents of the objects, such as inserting an object into the priority queue, you need to follow The content of the object is used to adjust the heap, so how to compare?

3. Object comparison methods

1. equals method comparison

The Object class is the base class of each class, which provides the equals() method to compare content Are they the same

#But the equals method in Object uses == to compare by default, which is to compare the addresses of two objects, so I want to make custom types comparable, You can override the equals() method of the base class

Example:

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));
    }
}

Result: You can compare whether the contents are the same

Steps to override the equals method

• If the addresses of the two objects are the same, return true
• If the incoming object is null, return false
• If the incoming object and the calling object are not of the same type, return false
• If the contents are the same, return true, otherwise return false

Notes

The equals() method can only compare whether two objects are the same, and cannot compare according to >, <

2. Comparison based on the Comparable interface

For reference types, if you want to compare based on size, implement the Comparable interface when defining the class, and then override the compareTo method in the class

Example: Compare the size of two people, usually based on age

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表示相等
    }
}

The compareTo method is an interface class in java.lang and can be used directly

Using the Comparable interface allows objects of type Student to be inserted into the priority queue

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);
    }
}

Result: Student Type objects can also be inserted into the priority queue

3. Comparison based on the Comparator interface

The specific steps for comparison according to the comparator are as follows:

• Create a comparator class and implement the Comparator interface
• Override the compare method

Use the comparator so that Student type objects can be inserted into the priority queue

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);
    }
}

Result: Student type objects can be inserted into the priority queue

Comparator is a generic interface class in the java.util package. It must be used Import the corresponding package

4. Three comparison methods

Rewriting method	Explanation
Object.equals	Can only compare whether the contents of two objects are equal, not the size
Comparable.compareTo	Class To implement the interface, it is highly intrusive to the class and destroys the structure of the original class
Comparator.compare	It is necessary to implement a comparator class, which is intrusive to the class Weak, does not destroy the original class

Comparable, what comparison method does Comparator use?

If we get a class defined by others, we cannot operate on the class, so we can use the method of creating a class to implement the Comparator interface

If the class is a class defined by the user, we can operate on the class To operate, use the method of implementing the Comparable interface

Recommended learning: "java video tutorial"

The above is the detailed content of Summary and sharing of three ways to compare the sizes of two objects in Java. For more information, please follow other related articles on the PHP Chinese website!