Java tutorials > Core Java Fundamentals > Basics and Syntax > What is the difference between `==` and `.equals()`?

What is the difference between `==` and `.equals()`?

Understanding the difference between `==` and `.equals()` in Java is crucial for writing correct and efficient code, especially when dealing with object comparisons. This tutorial will guide you through the nuances of each operator, highlighting their differences, use cases, and potential pitfalls. Whether you're a beginner or an experienced Java developer, this guide will help solidify your understanding of object comparison in Java.

The `==` Operator: Comparing References

The `==` operator compares the *references* of two objects. It checks if two variables point to the same memory location. In the example above, `str1` and `str2` both point to the same string literal in the string pool, hence `str1 == str2` is `true`. However, `str3` is a new object created using the `new` keyword, so it resides in a different memory location, making `str1 == str3` `false`. Therefore, the `==` operator returns `true` only if the references are the same, indicating that the objects are indeed the same instance. For primitive types (`int`, `char`, `boolean`, etc.) `==` compares the actual values.

public class EqualityExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = new String("Hello");

        System.out.println("str1 == str2: " + (str1 == str2)); // Output: true
        System.out.println("str1 == str3: " + (str1 == str3)); // Output: false
    }
}

The `.equals()` Method: Comparing Content

The `.equals()` method, by default (in the `Object` class), also compares references, just like `==`. However, classes can override this method to provide a *logical* comparison based on the object's content or state. The `String` class, for example, overrides `.equals()` to compare the character sequences of the strings. In the `EqualsExample`, `str1.equals(str2)` returns `true` because the content of both strings is the same, even though they are different objects in memory. Similarly, `Integer` class also overrides `.equals()` to compare the integer values they represent.

public class EqualsExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = new String("Hello");

        System.out.println("str1.equals(str2): " + str1.equals(str2)); // Output: true

        Integer num1 = new Integer(5);
        Integer num2 = new Integer(5);

        System.out.println("num1.equals(num2): " + num1.equals(num2)); // Output: true
    }
}

Concepts Behind the Snippet

Understanding the concepts of reference vs. value comparison is essential. Java passes objects by reference, meaning variables hold memory addresses, not the objects themselves. The `==` operator directly compares these memory addresses. The `.equals()` method, when overridden, allows defining a customized notion of equality based on the object's internal state. Without overriding, `.equals()` falls back to reference comparison.

Real-Life Use Case Section

Consider a scenario where you're building a user authentication system. You might have a `User` class with fields like `username` and `password`. When a user attempts to log in, you need to compare the entered username and password with the stored credentials. You would *not* use `==` for this purpose. Instead, you would override the `.equals()` method in the `User` class to compare the `username` and `password` fields. This ensures that two `User` objects are considered equal if their credentials match, regardless of whether they are the same object instance.

Best Practices

  • Always override `.equals()` when you need to compare objects based on their content.
  • If you override `.equals()`, you must also override `hashCode()`. This ensures that objects that are equal according to `.equals()` have the same hash code. This is crucial for the proper functioning of hash-based collections like `HashMap` and `HashSet`.
  • Follow the contract of `.equals()`: It should be reflexive, symmetric, transitive, consistent, and return `false` when comparing to `null`.
  • Use `Objects.equals()` (Java 7+) to avoid NullPointerExceptions when comparing potentially null objects. It handles the null check for you.

Interview Tip

Be prepared to explain the subtle differences between `==` and `.equals()`, including the importance of overriding `.equals()` and `hashCode()` together. Demonstrate an understanding of object references and value comparison. Give concrete examples of when each operator is appropriate. Explain the consequences of not overriding `.equals()` when it's logically necessary.

When to Use Them

  • Use `==` when you want to check if two variables point to the exact same object in memory, or when comparing primitive types.
  • Use `.equals()` when you want to check if two objects are logically equivalent based on their content or state (and the `.equals()` method has been properly overridden).

Alternatives

While `.equals()` is the standard way to compare objects for equality, some libraries provide alternative methods that can be useful in specific situations. For example, the Apache Commons Lang library provides `EqualsBuilder` and `HashCodeBuilder` classes that can simplify the process of implementing `.equals()` and `hashCode()` methods. Another approach is to use a library like Lombok, which can automatically generate `.equals()` and `hashCode()` methods based on the fields in your class using annotations. However, it's important to understand the underlying principles and implications of using these alternatives.

Pros of `.equals()`

  • Logical Comparison: Allows for defining a custom notion of equality based on object content.
  • Flexibility: Can be adapted to different object types and comparison criteria.

Cons of `.equals()`

  • Requires Overriding: Must be overridden in custom classes to provide meaningful comparisons.
  • Potential for Errors: Incorrect implementation can lead to unexpected behavior.
  • Performance Overhead: Can be slower than `==` due to the method call and potentially complex comparison logic.

← What is the difference between `==` and `.equals()`? What is the difference between `List`, `Set`, and `Map`? →

FAQ

  • Why should I override `hashCode()` when I override `.equals()`?

    The contract of `hashCode()` states that if two objects are equal according to `.equals()`, then they must have the same hash code value. This is crucial for the proper functioning of hash-based collections like `HashMap` and `HashSet`. If you override `.equals()` but not `hashCode()`, you risk violating this contract, which can lead to unpredictable behavior when using these collections. For example, you might not be able to retrieve objects from a `HashMap` even if they are logically equal.
  • What happens if I don't override `.equals()`?

    If you don't override `.equals()`, the default implementation from the `Object` class will be used, which simply compares object references using `==`. This means that two objects will only be considered equal if they are the exact same instance in memory. This might be acceptable for some classes, but for many classes, it's important to compare objects based on their content.
  • Can I use `==` to compare strings?

    While it *can* work in some cases, using `==` to compare strings is generally not recommended. String literals in the string pool are often interned, so `==` might return `true` for strings with the same content. However, strings created using the `new String()` constructor will not be interned, and `==` will return `false` even if the content is the same. Always use `.equals()` to compare the content of strings.