CodingbootBlog

Why Object Comparison in java matters

In Java, when comparing objects, we often expect two objects with the same content to be equal. However, due to how object references work, == and .equals() behave differently. Let’s explore this step by step.

Problem: Objects Are Not Equal by Default

Consider the following code snippet:

Employee e1 = new Employee(121, "Raj");
Employee e2 = new Employee(121, "Raj");
System.out.println(e1 == e2);  <em>// false</em>
System.out.println(e1.equals(e2));  <em>// false (before overriding equals)</em>

Employee e1 = new Employee(121, "Raj");
Employee e2 = new Employee(121, "Raj");
System.out.println(e1 == e2);  <em>// false</em>
System.out.println(e1.equals(e2));  <em>// false (before overriding equals)</em>

Explanation:

• e1 and e2 are two different objects stored at different memory locations.
• == compares memory addresses, not content. Since they point to different objects, e1 == e2 returns false.
• The default equals() method (inherited from Object) also checks memory addresses, so it returns false.

Memory Representation:

Heap Memory:
 e1 --> [ Employee@1a2b3c ]
 e2 --> [ Employee@4d5e6f ]

Even though both objects have the same empId and name, Java treats them as different.

Solution: Overriding equals()

To compare object content instead of memory references, we must override equals():

@Override
public boolean equals(Object obj) {
    if (this == obj) return true; <em>// Check if both references are same</em>
    if (obj == null || getClass() != obj.getClass()) return false; <em>// Type check</em>
    Employee employee = (Employee) obj; <em>// Cast to Employee</em>
    return this.empId == employee.empId && this.name.equalsIgnoreCase(employee.name);
}

@Override
public boolean equals(Object obj) {
    if (this == obj) return true; <em>// Check if both references are same</em>
    if (obj == null || getClass() != obj.getClass()) return false; <em>// Type check</em>
    Employee employee = (Employee) obj; <em>// Cast to Employee</em>
    return this.empId == employee.empId && this.name.equalsIgnoreCase(employee.name);
}

How It Works:

1. this == obj → If both references point to the same object, return true.
2. obj == null || getClass() != obj.getClass() → Ensures we are comparing the same type of objects.
3. Type Casting → Converts obj into an Employee object.
4. Content Comparison → Checks if empId and name (ignoring case) are equal.

Updated Comparison:

Employee e1 = new Employee(121, "Raj");
Employee e2 = new Employee(121, "Raj");
System.out.println(e1.equals(e2)); <em>// Now returns true</em>

Employee e1 = new Employee(121, "Raj");
Employee e2 = new Employee(121, "Raj");
System.out.println(e1.equals(e2)); <em>// Now returns true</em>

Object Comparison in Collections

Even after overriding equals(), ArrayList methods like contains() and indexOf() rely on it:

List<Employee> list = new ArrayList<>();
list.add(new Employee(121, "E1"));
list.add(new Employee(122, "E2"));
list.add(new Employee(123, "E3"));
list.add(new Employee(124, "E4"));

Employee employee = new Employee(124, "E4");
System.out.println(list.contains(employee)); <em>// true (after overriding equals)</em>
System.out.println(list.indexOf(employee)); <em>// Correct index returned</em>
list.remove(employee);
System.out.println(list); <em>// Employee removed successfully</em>

List<Employee> list = new ArrayList<>();
list.add(new Employee(121, "E1"));
list.add(new Employee(122, "E2"));
list.add(new Employee(123, "E3"));
list.add(new Employee(124, "E4"));

Employee employee = new Employee(124, "E4");
System.out.println(list.contains(employee)); <em>// true (after overriding equals)</em>
System.out.println(list.indexOf(employee)); <em>// Correct index returned</em>
list.remove(employee);
System.out.println(list); <em>// Employee removed successfully</em>

Why Does This Work?

• contains() and indexOf() use equals() to check equality.
• Without overriding equals(), these methods check memory addresses and return false.
• After overriding, they correctly identify the employee based on empId and name.

Summary

By overriding equals(), we ensure objects are compared based on meaningful data rather than memory locations. 🚀