ਜਦੋਂ ਤੁਸੀਂ ਲਾਜਿਕਲ ਬਰਾਬਰਤਾ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ equals() ਨੂੰ override ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ hashCode() ਨੂੰ ਵੀ override ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ — ਕਿਉਂਕਿ hash-based collections (, ) ਇਸ contract 'ਤੇ ਨਿਰਭਰ ਹਨ ਕਿ । ਇਸ ਨੂੰ ਤੋੜਨ ਨਾਲ subtle, ਅਤੇ ਲੱਭਣ ਲਈ ਮੁਸ਼ਕਲ bugs ਪੈਦਾ ਹੁੰਦੇ ਹਨ।
HashMapHashSet// by default, equals() compares IDENTITY (same object?), hashCode() is based on memory address
Person p1 = new Person("Ann", 30);
Person p2 = new Person("Ann", 30);
p1.equals(p2); // false by default — different objects, even with same data
ਬਿਨਾਂ override ਕੀਤੇ, ਦਾ ਸਮਾਨ content ਵਾਲੇ ਦੋ objects "ਬਰਾਬਰ ਨਹੀਂ" ਹਨ — ਆਮ ਤੌਰ 'ਤੇ value objects ਲਈ ਤੁਹਾਡੀ ਇੱਛਾ ਨਹੀਂ।
equals() ਨੂੰ Override ਕਰਨਾ@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person p = (Person) o;
return age == p.age && Objects.equals(name, p.name); // compare by CONTENT
}
hashCode() ਨੂੰ ਵੀ override ਕਰੋ@Override
public int hashCode() {
return Objects.hash(name, age); // MUST be consistent with equals()
}
Contract: ਜੇਕਰ a.equals(b) true ਹੈ, ਤਾਂ a.hashCode() == b.hashCode() ਲਾਜ਼ਮੀ ਰੂਪ ਨਾਲ true ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
equals() ਨੂੰ override ਕਰੋ ਪਰ hashCode() ਨੂੰ ਨਹੀਂPerson p1 = new Person("Ann", 30);
Person p2 = new Person("Ann", 30); // equal by our equals()
Set<Person> set = new HashSet<>();
set.add(p1);
set.contains(p2); // ❌ likely FALSE — even though p1.equals(p2)!
ਕਿਉਂ? HashMap/HashSet ਪਹਿਲਾਂ hashCode() ਨੂੰ ਸਹੀ bucket ਲੱਭਣ ਲਈ ਵਰਤਦੇ ਹਨ, ਫਿਰ ਇਸ ਵਿੱਚ equals() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਡਿਫਾਲਟ (identity-based) hashCode() ਨਾਲ, p1 ਅਤੇ p2 ਵੱਖ-ਵੱਖ buckets ਵਿੱਚ ਜਾਂਦੇ ਹਨ, ਇਸ ਲਈ contains ਉਨ੍ਹਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦੇ ਸਮੇਂ ਕਦੀ ਨਹੀਂ — set ਸੋਚਦਾ ਹੈ ਕਿ ਉਹ ਵੱਖ-ਵੱਖ ਹਨ। ਇਹ ਚਮਤਕਾਰੀ bugs ਪੈਦਾ ਕਰਦਾ ਹੈ: Set ਵਿੱਚ duplicates, ਅਸਫ਼ਲ map lookups, ਆਦਿ।
1. equal objects → equal hash codes (REQUIRED for correctness)
2. unequal objects MAY have the same hash (collisions are allowed)
3. hashCode() must be consistent (same object → same code, unchanged)
4. equals() must be reflexive, symmetric, transitive, consistent
record Person(String name, int age) {} // records auto-generate equals/hashCode/toString!
Java records (ਅਤੇ IDE generation / Lombok) ਤੁਹਾਡੇ ਲਈ ਸਹੀ, ਇਕਸਾਰ equals/hashCode ਪੈਦਾ ਕਰਦੇ ਹਨ।
equals/hashCode contract Java ਦੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ — ਅਤੇ ਸਭ ਤੋਂ ਵਧੀਆ violated — ਨਿਯਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ।
equals() ਨੂੰ hashCode() ਤੋਂ ਬਿਨਾ override ਕਰਨਾ hash-based collections ਨੂੰ ਉਨ੍ਹਾਂ ਤਰੀਕਿਆਂ ਨੂੰ ਤੋੜਦਾ ਹੈ ਜੋ debug ਕਰਨੇ ਮੁਸ਼ਕਲ ਹਨ: objects ਜੋ ਤੁਸੀਂ ਬਰਾਬਰ ਸਮਝਦੇ ਹੋ, HashMap/HashSet ਵਿੱਚ "ਖੋ" ਜਾਂਦੇ ਹਨ (ਅਸਫ਼ਲ lookups, phantom duplicates) ਕਿਉਂਕਿ ਉਹ ਵੱਖ-ਵੱਖ buckets ਵਿੱਚ hash ਹੋਂਦੇ ਹਨ।
ਕਿਉਂਕਿ ਇਹ collections ਹਰ ਥਾਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਹਰ value-type class ਜੋ ਕਿ key ਜਾਂ set element ਵਜੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਨੂੰ ਦੋਵਾਂ ਨੂੰ ਇਕਸਾਰ ਰੂਪ ਨਾਲ override ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ।
ਕਿਉਂ ਨੂੰ ਸਮਝਣਾ (bucket-then-equals lookup mechanism) — ਅਤੇ records ਜਾਂ ਉਤਪੰਨ code ਨੂੰ ਸਹੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸਤੇਮਾਲ ਕਰਨਾ — ਸਹੀ ਵਿਵਹਾਰ ਅਤੇ Java collections ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਇਸ ਦੀ ਸਪੱਸ਼ਟ ਸਮਝ ਦੀ ਨੁਮਾਇਸ਼ ਕਰਨ ਵਾਲਾ ਇੱਕ ਕਲਾਸਿਕ interview topic ਲਈ ਜ਼ਰੂਰੀ ਹੈ।