Object Reference Equality

In Java, object reference equality is a fundamental concept that distinguishes between the comparison of object references and the comparison of the contents or state of the objects. Understanding this concept is crucial for developers to avoid common pitfalls in object comparisons, especially when working with collections, custom classes, and in scenarios where object identity versus object equality matters.

What is Object Reference Equality?

Object reference equality refers to the comparison of memory addresses (references) of two objects to determine if they point to the same location in memory. This is different from object value equality, which checks if two objects are equivalent in terms of their state or content.

Comparison Mechanisms in Java

1. Using == Operator

The == operator checks if two reference variables refer to the same object in memory.
It does not consider the content or state of the objects.

Example:

String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1 == str2); // Output: false   

Here, str1 and str2 are different objects in memory, thus str1 == str2 evaluates to false.

2. Using equals() Method

The equals() method, defined in the Object class, is intended for checking object value equality.
By default, equals() method in the Object class checks reference equality (similar to ==).
Many classes, including String, Integer, etc., override equals() to compare the content/state of objects.

Example:

String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1.equals(str2)); // Output: true   

Here, str1.equals(str2) evaluates to true because the String class overrides equals() to compare the content.

Practical Scenarios

1. Custom Classes

When creating custom classes, it is often necessary to override equals() (and hashCode()) methods to provide meaningful value equality.

Example:

File Name: Person.java

import java.util.Objects;
public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Alice", 30);
        Person person3 = new Person("Bob", 25);
        System.out.println(person1.equals(person2)); // true
        System.out.println(person1.equals(person3)); // false
    }
}   

Output:

 
true
false

2. Collections

Collections such as HashSet and HashMap rely on equals() and hashCode() for storing and retrieving objects.
Ensuring correct implementation of these methods is crucial for the correct behavior of these collections.

Example:

File Name: Person.java

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    public static void main(String[] args) {
        Set<Person> people = new HashSet<>();
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Alice", 30);
        Person person3 = new Person("Bob", 25);
        people.add(person1);
        people.add(person2);
        people.add(person3);
        System.out.println(people.size()); // Output: 2, because person1 and person2 are considered equal
    }
}   

Output:

3. Singleton Pattern

In the Singleton pattern, reference equality is often used to ensure that only one instance of a class is created.

Example:

File Name: Singleton.java

public class Singleton {
    private static Singleton instance;
    private Singleton() {
        // Private constructor to prevent instantiation
    }
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // Output: true, both references point to the same instance
        singleton1.showMessage(); // Output: Hello from Singleton!
    }
}   

Output:

 
true
Hello from Singleton!

Conclusion

Understanding object reference equality and how it differs from object value equality is essential for Java developers. The == operator should be used for reference comparisons, while the equals() method should be used for content comparisons.

Properly overriding equals() (and hashCode()) in custom classes ensures the correct functionality of collections and other Java mechanisms that rely on these methods. By mastering these concepts, developers can avoid common bugs and write more reliable, maintainable code.

Next TopicReflect-array-in-java

← prev next →