Understanding the Difference Between equals() and == in Java

In Java, the comparison operators and methods serve different purposes depending on what you're comparing. Let's explore how == and equals() work and when to use each.

The == Operator

The == operator performs reference comparison in Java. When applied to objects, it checks whether both operands point to the same memory location. For primitive types such as int, boolean, or char, it compares the actual values instead of references.

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b); // false - different objects in memory
System.out.println(a == a); // true - same reference

The equals() Method

The equals() method, defined in the Object class, provides a way to perform content comparison. By default, the implementation simply delegates to the == operator, as shown in the following implementation:

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

Many Java classes override this method to provide meaningful content-based comparison. The String class is a prime example of this pattern. Here's how String implements equality checking:

public class String {
    private final char[] value;
    
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String other = (String) anObject;
            int length = value.length;
            if (length == other.value.length) {
                char[] thisChars = value;
                char[] otherChars = other.value;
                int index = 0;
                while (length-- != 0) {
                    if (thisChars[index] != otherChars[index]) {
                        return false;
                    }
                    index++;
                }
                return true;
            }
        }
        return false;
    }
}

This implementation compares the actual character sequences rather than memory addresses, which is why two separate String objects with the same content will evaluate as equal.

Understanding hashcode() and Its Purpoce

The hashcode() method generates an integer value from an object, enabling efficient storage and retrieval in hash-based collections. This method is also defined in the Object class and typically uses native implementation to compute the hash value.

Hash functions have an important characteristic: different inputs may occasionally produce the same hash value, known as a collision. However, if two objects have different hash codes, they must be different objects. This one-way relationship is fundamental to hash-based data structures.

How Hash-Based Collections Work

Collections like HashSet and HashMap rely on these methods to ensure element uniqueness. When adding an element, the collection follows this process:

1. Calculate the hash code of the new object
2. Compare it with existing elements in the collection
3. If a matching hash code is found, invoke equals() for precise verification
4. Only add the element if both hash code and equals() return false

This two-step verification significantly improves performance. The hash code comparison acts as a quick filter, avoiding expensive equals() calls in most cases. Only when hash codes match does the collection perform the detailed content comparison.

Contract Between equals() and hashcode()

Java mandates a specific contract: if two objects are equal according to equals(), they must produce identical hash codes. This relationship ensures proper behavior in hash-based collections. Violating this contract can lead to unpredictable results when objects are used as keys in HashMap or stored in HashSet.