How to Compare Two Objects of Same Class in Java

Comparing objects in Java involves determining if two objects are equivalent based on their content rather than just their memory addresses. This is crucial for various tasks, like searching, sorting, and data manipulation. This article explores different methods for comparing two objects of the same class in Java.

Understanding Object Comparison in Java

In Java, simply using the == operator checks if two references point to the same memory location. For comparing object content, you need to implement comparison logic. There are two primary approaches:

1. Overriding the equals() Method

The equals() method, inherited from the Object class, provides a default comparison based on memory addresses. To compare object content, you must override this method within your class. A proper equals() implementation should adhere to these principles:

• Reflexivity: An object should be equal to itself.
• Symmetry: If object A is equal to object B, then object B should be equal to object A.
• Transitivity: If object A is equal to object B, and object B is equal to object C, then object A should be equal to object C.
• Consistency: Multiple invocations of equals() should return the same result as long as the objects haven’t changed.
• Non-nullity: Comparing an object to null should always return false.

Here’s an example:

class Pet {
    String name;
    int age;
    String breed;

    Pet(String name, int age, String breed) {
        this.name = name;
        this.age = age;
        this.breed = breed;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Pet p1 = (Pet) obj;
        return this.name.equals(p1.name) && this.age == p1.age && this.breed.equals(p1.breed);
    }
}

This code overrides equals() to compare Pet objects based on the equality of their name, age, and breed attributes.

2. Using hashCode() along with equals()

The hashCode() method returns an integer representation of an object. Overriding hashCode() in conjunction with equals() is highly recommended. The contract between these methods states:

• If two objects are equal according to equals(), their hashCode() values must be the same.
• If two objects have different hashCode() values, they are not equal according to equals(). However, the reverse is not necessarily true.

Implementing hashCode() improves the performance of hash-based collections like HashMap and HashSet.

@Override
public int hashCode() {
    return Objects.hash(name, age, breed);
}

This code utilizes Objects.hash() to generate a hash code based on the name, age, and breed fields.

Customized Comparison Logic

You can tailor the equals() method to implement specific comparison criteria. For instance, you might only compare objects based on a subset of their attributes:

@Override
public boolean equals(Object obj) {
    // ... (previous checks) ...
    Pet p1 = (Pet) obj;
    return this.name.equals(p1.name) && this.age == p1.age; 
}

This modified equals() only considers name and age for equality.

Conclusion

Comparing objects of the same class in Java requires overriding the equals() method, and ideally, the hashCode() method as well. Ensure your equals() implementation adheres to the established contracts for predictable and reliable object comparisons. You can customize comparison logic to suit specific requirements, such as comparing only specific attributes. Understanding these techniques is essential for effective object manipulation in Java.