equal() vs “==” | Java

When working with Java, one of the fundamental aspects of programming is comparing values. Java provides two primary mechanisms for comparison: the equals() method and the == operator. While both serve the purpose of comparing objects, they have distinct use cases and behave differently depending on the context. In this article, we will explore the differences between equals() and == in Java, and when to use each of them.

Understanding the equals() Method

In Java, the equals() method is used to compare the contents of objects for equality. It is a method that is inherited from the Object class and can be overridden in custom classes to provide a meaningful comparison for instances of that class.

String comparison

One of the most common use cases for equals() is comparing strings. When comparing two String objects using equals(), you are comparing their contents. For example:

String str1 = "Hello";
String str2 = "Hello";

boolean areEqual = str1.equals(str2); // true

In this case, areEqual will be true because the content of str1 and str2 is the same.

Custom Classes

For custom classes, it is a good practice to override the equals() method to define what it means for two instances of your class to be equal. By default, the equals() method in custom classes behaves the same way as ==, comparing object references rather than their contents.

class Person 
{
    String name;
    
    public Person(String name) 
    {
        this.name = name;
    }
    
    @Override
    public boolean equals(Object obj) 
    {
        if (this == obj) 
        {
            return true;
        }
        
        if (obj == null || getClass() != obj.getClass()) 
        {
            return false;
        }
        
        Person person = (Person) obj;
        return Objects.equals(name, person.name);
    }
}

Person person1 = new Person("Alice");
Person person2 = new Person("Alice");

boolean areEqual = person1.equals(person2); // true

n this example, areEqual will be true because we have overridden the equals() method to compare the name attribute of Person objects.

Understanding the “==” operator

The == operator in Java is used to compare object references. It checks whether two references point to the same object in memory, rather than comparing the contents of the objects.

Reference Comparison

When using ==, you are comparing the memory addresses of the objects. This means that two objects with the same content may not be considered equal when using ==.

String str1 = new String("Hello");
String str2 = new String("Hello");

boolean areEqual = str1 == str2; // false

In this case, areEqual will be false because str1 and str2 are two distinct objects in memory.

Primitive Types

For primitive data types like int, boolean, and char, using == is the appropriate way to compare them, as there is no concept of “content” for these types. For example:

int num1 = 5;
int num2 = 5;

boolean areEqual = num1 == num2; // true

Key Differences

Purpose

equals() is used for content-based comparison, while == is used for reference-based comparison.

Default Behavior

The default behavior of equals() is to compare content (if overridden), while == compares references.

Customization

You can customize the behavior of equals() by overriding it in your classes, whereas == cannot be customized.

Use Cases

Use equals() for comparing objects based on their content, and use == for comparing object references and primitive data types.

Understanding the difference between equals() and == is crucial when working with Java. Using the right comparison method in the appropriate context can prevent unexpected behavior in your code. equals() should be used when comparing the content of objects, especially for custom classes where you want to define your own equality criteria. On the other hand, == is suitable for comparing object references and primitive data types. By using these comparison mechanisms appropriately, you can write Java code that is both accurate and efficient.