Difference Between == and equals() in Java

1. Overview

Understanding how Java evaluates equality is important when working with both primitive values and objects. Different mechanisms apply depending on whether the comparison checks references or the internal state of an object, and these differences influence how equality behaves in common scenarios.

In this tutorial, we examine reference equality and value equality. The discussion includes their behavior with primitives and objects, and highlights how each mechanism handles null.

2. Reference Equality

Reference comparison uses the equality operator (==) and occurs when two references point to the same object in memory.

2.1. Equality Operator With Primitive Types

The primitive types in Java are simple, non-class raw values. When the equality operator is used with primitive types, it compares their values directly:

int a = 10;
int b = 15;
assertFalse(a == b);

int c = 10;
assertTrue(a == c);

int d = a;
assertTrue(a == d);

In this example, equality and reference checking work identically for primitives. When we initialize a new primitive with the same value, the check returns true. In addition, the operator returns the same result if we reassign the original value to the new variable and compare it.

So, let’s examine how null behaves with primitive types:

int e = null; // compilation error
assertFalse(a == null); // compilation error
assertFalse(10 == null); // compilation error

Java doesn’t allow assigning or comparing null with primitive values.

2.2. Equality Operator With Object Types

For object types, the equality operator performs a referential equality comparison only, ignoring the object values.

Let’s consider a simple class:

public class Person {
    private String name;
    private int age;

    // constructor, getters, setters...
}

With this in place, we can now initialize some class objects and inspect the equality operator results:

Person a = new Person("Bob", 20);
Person b = new Person("Mike", 40);
assertFalse(a == b);

Person c = new Person("Bob", 20);
assertFalse(a == c);

Person d = a;
assertTrue(a == d);

The results are quite different than before. The second check returns false while we got true for the primitives. The equality operator ignores the internal values of the object when comparing references. It only checks that two variables are referencing the same memory address.

Unlike primitives, object references can store null:

assertFalse(a == null);
Person e = null;
assertTrue(e == null);

By using the equality operator and comparing null, we check if the object assigned to the variable is already initialized.

2.3. Reference Equality in the String Pool

String comparison has an additional nuance because Java keeps a pool of immutable string literals in memory, and this pool affects how reference equality behaves.

Let’s show an example to demonstrate this behavior:

@Test
public void givenStrings_whenComparingReferences_thenStringPoolAffectsEquality() {
    String a = "hello";
    String b = "hello";
    assertTrue(a == b); // both point to the same pooled instance

    String c = new String("hello");
    assertFalse(a == c); // c isn't taken from the pool
}

Two string literals with the same content point to the same pooled value, so the == operator returns true when comparing such literals. New String objects created with the constructor don’t use the pool, so they produce different results with reference checks.

3. Value Equality

Value equality applies when two separate objects contain the same values or state. This comparison uses the equals() method from Object and focuses on the values stored inside the object rather than the reference.

3.1. equals() Method With Primitive Types

Primitives are basic types with a single value and don’t implement any methods. Therefore, it’s impossible to call the equals() method directly using primitives:

int a = 10;
assertTrue(a.equals(10)); // compilation error

However, since every primitive has its own wrapper class, we can use the boxing mechanism to cast it into its object representation. Then, we can call the equals() method as if we are using object types:

int a = 10;
Integer b = a;

assertTrue(b.equals(10));

This approach compares the wrapped value instead of the reference.

3.2. equals() Method With Object Types

Using the earlier Person class, the equals() method needs to be overridden so the comparison evaluates field values:

public class Person {
    // other fields and methods omitted

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

First of all, the equals() method returns true if the given value has the same reference, as verified by the reference operator. If not, we start the equality test.

Further, we test the equality of the Class objects for both values. We return false if they’re different. Otherwise, we continue checking for equality. Finally, we return the combined result of comparing each property separately.

Let’s see an example that shows how this changes comparison behavior:

Person a = new Person("Bob", 20);
Person b = new Person("Mike", 40);
assertFalse(a.equals(b));

Person c = new Person("Bob", 20);
assertTrue(a.equals(c));

Person d = a;
assertTrue(a.equals(d));

In this case, the second check returns true as opposed to the reference equality. The overridden equals() method compares the internal values of the objects.

If we don’t override the equals() method, the method from the parent class Object is used. Since the Object.equals() method only does a reference equality check, the behavior might not be what we’d expect when comparing Person objects.

3.3. Relationship Between equals() and hashCode()

Overriding the equals() method changes how objects are compared, so the hashCode() method needs to match that behavior. Both methods belong to the same contract in Object. If two objects are equal according to equals(), they must return the same hash code. When the hash codes don’t match, hash-based collections such as HashMap or HashSet may behave in unexpected ways.

Therefore a Person class that overrides equals() should also override hashCode():

public class Person {
    // other fields and methods omitted
 @Override public int hashCode() { return Objects.hash(name, age); } }

Let’s look at a test that shows how two logically equal objects behave when the hashCode() method is also overridden:

@Test
public void givenEqualObjects_whenHashCodesMatch_thenCollectionsBehaveCorrectly() {
    Person a = new Person("Bob", 20);
    Person b = new Person("Bob", 20);

    assertTrue(a.equals(b));
    assertEquals(a.hashCode(), b.hashCode());
}

In this example, both objects represent the same data, so the equality check passes and their hash codes match.

4. Null Equality

It’s also important to understand how the equals() method behaves when one of the values is null:

Person a = new Person("Bob", 20);
Person e = null;
assertFalse(a.equals(e));
assertThrows(NullPointerException.class, () -> e.equals(a));

These checks produce different outcomes depending on which reference invokes the method. Calling equals() on a null reference throws a NullPointerException, so equality checks should occur on a non-null reference.

To fix the last statement, we should first call the equality operator check:

assertFalse(e != null && e.equals(a));

Now, the left side of the condition returns false, making the entire statement equal to false, preventing the NullPointerException from being thrown. Therefore, we should first check that the value on which we are calling the equals() method is not null, otherwise, it can lead to bugs.

In addition, since Java 7, we can use a null-safe Objects#equals() static method to perform equality checks:

assertFalse(Objects.equals(e, a));
assertTrue(Objects.equals(null, e));

This helper method performs additional checks to prevent throwing the NullPointerException, returning true when both parameters are null.

5. Conclusion

In this article, we discussed reference equality and value equality checks against primitive and object values.

Reference equality uses the == operator and checks whether two references point to the same object. For primitives, the operator compares values, while for objects it compares memory addresses.

On the other hand, value equality relies on the equals() method. Wrapper types support this method for primitive values, and object types can override it to compare internal state.