> For the complete documentation index, see [llms.txt](https://www.pranaypourkar.co.in/the-programmers-guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/oop-basics/what-is-an-object/equals-and-hashcode/faq.md).

# FAQ

## **1. Is it mandatory to override `equals` and `hashCode`?**

**No, it is not mandatory** to override `equals()` and `hashCode()`, but it is recommended when working with **custom objects** that will be used in **collections like `HashSet`, `HashMap`, or `HashTable`**.

By default, `equals()` and `hashCode()` are inherited from `Object`:

* `equals()` compares object **references** (not values).
* `hashCode()` returns a unique integer for the object instance.

If you don't override them, two objects with the same data may be considered **different** in collections.

## **2. What if I just implement `equals()` and not `hashCode()`?**

If you override `equals()` but do not override `hashCode()`, our object may behave **unexpectedly** in hash-based collections.

Example:

```java
class Employee {
    int id;

    Employee(int id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Employee)) return false;
        Employee emp = (Employee) obj;
        return this.id == emp.id;
    }
}

public class Main {
    public static void main(String[] args) {
        HashSet<Employee> set = new HashSet<>();
        Employee e1 = new Employee(1);
        Employee e2 = new Employee(1);

        set.add(e1);
        set.add(e2);

        System.out.println(set.size()); // Output: 2 ❌ (should be 1)
    }
}
```

**Why?**

* `equals()` considers `e1` and `e2` **equal**.
* But since `hashCode()` is not overridden, `e1` and `e2` may have **different hash codes**, so `HashSet` treats them as different objects.

{% hint style="info" %}
**Best practice:** Always override `hashCode()` when overriding `equals()`
{% endhint %}

## **3. What if I implement `hashCode()` but not `equals()`?**

If we override `hashCode()` but not `equals()`, two objects **may** have the same hash code but still be considered **not equal**.

Example:

```java
class Employee {
    int id;

    Employee(int id) {
        this.id = id;
    }

    @Override
    public int hashCode() {
        return id; // Simple hashCode implementation
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e1 = new Employee(1);
        Employee e2 = new Employee(1);

        System.out.println(e1.hashCode() == e2.hashCode()); // Output: true
        System.out.println(e1.equals(e2)); // Output: false ❌
    }
}
```

**Why?**

* Even though `hashCode()` returns the same value, `equals()` still checks **object references**, which are different.
* This can cause incorrect behavior in `HashMap`, `HashSet`, etc.

{% hint style="info" %}
**Best practice:** Always override `equals()` when overriding `hashCode()`.
{% endhint %}

## **4. Can two objects have the same hash code but not be equal?**

**Yes**, this is called a **hash collision**.

Example:

```java
class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    @Override
    public int hashCode() {
        return 100; // Same hash code for all objects
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Person)) return false;
        Person person = (Person) obj;
        return this.name.equals(person.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice");
        Person p2 = new Person("Bob");

        System.out.println(p1.hashCode() == p2.hashCode()); // Output: true (same hashcode)
        System.out.println(p1.equals(p2)); // Output: false ❌ (different objects)
    }
}
```

**Why?**

* Since we forcefully return `100` for all objects, different objects have the same `hashCode`.
* But `equals()` differentiates them correctly.

{% hint style="info" %}
Two **different** objects can have the **same hashCode**, but they will still be considered **different** if `equals()` returns false. **Good hash functions** reduce collisions but cannot avoid them entirely.
{% endhint %}

## **5. Can two objects be equal but have different hash codes?**

**No, if two objects are equal, they must have the same hash code.**

According to the **contract** of `hashCode()` and `equals()`:

> If `a.equals(b) == true`, then `a.hashCode() == b.hashCode()` **must also be true**.

Example (Incorrect implementation breaking contract):

```java
class Car {
    String model;

    Car(String model) {
        this.model = model;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Car)) return false;
        Car car = (Car) obj;
        return this.model.equals(car.model);
    }

    @Override
    public int hashCode() { 
        return (int) (Math.random() * 1000); // ❌ BAD PRACTICE
    }
}

public class Main {
    public static void main(String[] args) {
        Car c1 = new Car("Toyota");
        Car c2 = new Car("Toyota");

        System.out.println(c1.equals(c2)); // Output: true (same model)
        System.out.println(c1.hashCode() == c2.hashCode()); // ❌ May be false (wrong implementation)
    }
}
```

**Why is this incorrect?**

* Since `equals()` says two cars with the same model are **equal**, their `hashCode()` **must** also be the same.
* But due to random hash generation, they have **different hash codes**, which violates the contract.

{% hint style="info" %}
**Best practice:** Always ensure **equal objects have the same hash code**.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/oop-basics/what-is-an-object/equals-and-hashcode/faq.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.