How to determine whether objects are equal in java

1. The role of equals and the difference from ==

equals is used to determine whether two objects are equal.

equals is usually used to compare whether the contents of two objects are equal, and == is used to compare whether the addresses of two objects are equal.

The equals method is equivalent to "==" by default.

The equals method in the Object class is defined to determine whether the addresses of two objects are equal (which can be understood as whether they are the same object). If the addresses are equal, the objects are considered equal. This means that if all the new classes we create do not override the equals method, then judging whether two objects are equal will be equivalent to "==", that is, whether the addresses of the two objects are equal.

The equals method in the Object class is implemented as follows:

public boolean equals(Object obj) {
        return (this == obj);
    }

But in our actual development, it is usually considered that when the contents of two objects are equal, then the two objects are equal, and equals returns true . If the object contents are different, false is returned.

So it can be summarized into two situations

1. The class does not override the equals method. When using the equals method to compare two objects, it is equivalent to == comparison, that is, two objects The addresses are equal. If the addresses are equal, return true; if the addresses are not equal, return false.

2. The class overrides the equals method. When comparing two objects, the judgment method after overwriting is used. Usually, we will rewrite equals as: when the contents of the two objects are the same, equals returns true, and when the contents are different, it returns false.

For example:

public class EqualTest {
public static void main(String[] args) {
Person p1 = new Person(10,"张三");
Person p2 = new Person(10,"张三");
System.out.println(p1.equals(p2));
}
}
class Person{
int age;
String name;
public Person(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

If Person does not override the equals method, the equals in Object is used by default, which is the memory address judgment of the two objects (p1 and p2). p1 and p2 obviously have different memory addresses, so the output result is obviously false.

What if we override the equals method? We think that people with the same name and age are the same person, so p1 and p2 both represent 10-year-old Zhang San, and these two objects should be equal. The overridden equals method is as follows:

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

Similarly, when the above use case is executed, the result is true.

BTW: If the equals method returns true, is == also true?

is not necessarily true. There are two possibilities for equals to return true, one is that the addresses of the two objects are the same, and the other is that the contents of the two objects are the same. When the contents are the same, the addresses may be different, so the result of the == comparison may be false.

We add the judgment of == to the main method, as follows:

public static void main(String[] args) {
Person p1 = new Person(10,"张三");
Person p2 = new Person(10,"张三");
System.out.println(p1.equals(p2));
System.out.println(p1 == p2);
}

The output result is obvious. The result of p1==p2 is false.

Recommended tutorial: java introductory tutorial

The above is the detailed content of How to determine whether objects are equal in java. For more information, please follow other related articles on the PHP Chinese website!