How to Compare 2 Objects in Java

Java, being an object-oriented programming language, often requires comparing objects. However, directly using the == operator only checks if two references point to the same memory location, not if the objects’ values are equal. This article explores different ways to effectively compare two objects in Java.

Understanding Object Comparison

In Java, an object is an instance of a class. Each object has its own state (represented by instance variables) and behavior (defined by methods). When comparing objects, you typically want to determine if their states are identical, regardless of whether they reside in the same memory location.

Methods for Comparing Objects

1. Using the equals() Method

The equals() method, inherited from the Object class, provides a default comparison mechanism. By default, it behaves the same as the == operator. However, you can override this method within your custom classes to define a comparison logic based on the objects’ attributes.

Example without Overriding:

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

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

public class Main {
    public static void main(String[] args) {
        Pet dog1 = new Pet("Snow", 3, "German Shepherd");
        Pet dog2 = new Pet("Snow", 3, "German Shepherd");
        System.out.println(dog1.equals(dog2)); // Output: false
    }
}

Example with Overriding:

class Pet {
    // ... (previous code) ...

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

public class Main {
    public static void main(String[] args) {
        // ... (previous code) ...
        System.out.println(dog1.equals(dog2)); // Output: true
    }
}

2. Using the hashCode() Method with equals()

The hashCode() method returns an integer representation of an object. When overriding equals(), it’s crucial to also override hashCode(). Objects considered equal by equals() should have the same hashCode(). This ensures consistency when using objects in hash-based collections like HashMap and HashSet. Checking hash codes before calling equals() can improve performance by quickly eliminating unequal objects.

Example:

class Pet {
    // ... (previous code) ...

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

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


public class Main {
     public static void main(String[] args) {
        // ... (previous code) ...
         if (dog1.hashCode() == dog2.hashCode() && dog1.equals(dog2)) {
            System.out.println("Objects are equal."); //This will print
        } else {
           System.out.println("Objects are not equal.");
        }
    }
}

Conclusion

Comparing objects in Java requires understanding the difference between reference equality and value equality. Overriding the equals() method allows you to define custom comparison logic based on the object’s attributes. Implementing hashCode() in conjunction with equals() ensures consistency and efficiency, especially when using hash-based collections. Choosing the right comparison method depends on the specific requirements of your application.