Difference between == and equals().

Interviewers love this because one tiny symbol hides a huge Java idea: identity vs value.

Question: Difference between == and equals().

Answer: == checks whether two references point to the same object, and for primitives it compares the actual values. equals() is a method for logical equality; by default in Object it behaves like ==, but many classes such as String override it to compare content. The big idea is: use == for identity and primitives, and use equals() for value comparison.

Interview-Ready Answer: In Java, == compares primitive values directly, but for objects it compares whether both references point to the exact same object. equals() is meant for logical equality; for example, String.equals() compares text content even when the two string objects are different. My rule is: use == for primitives and identity checks, and use equals() for meaningful value comparison, ideally with hashCode() overridden too when I create my own class.

Core mental model

Think of objects as boxes. == asks whether it is the same box; equals() asks whether the contents should be considered the same.

What each one means

How it works under the hood

1. For primitives, the JVM compares the raw values bit for bit, so int a = 5; and int b = 5; make a == b true.
2. For objects, == checks whether both references point to the same object in memory.
3. equals() is a normal instance method. If a class does not override it, Object.equals() simply falls back to identity, which is effectively the same as ==.
4. Classes such as String, wrapper types, and many value classes override equals() to compare contents instead of reference identity.
5. Hash-based collections call equals() only after a bucket is chosen by hashCode(), so the equals() and hashCode() contract must stay consistent.

When to use which one

• Use == for primitives and intentional identity checks.
• Use equals() for IDs, names, dates, money objects, and any value object.
• Use Objects.equals(a, b) when either side may be null.
• For arrays, use Arrays.equals or Arrays.deepEquals; array equals() is inherited from Object.

Performance and edge cases

== is constant time, O(1). equals() is also O(1) for many simple objects, but can be O(n) when it scans content, like strings, lists, or large byte arrays. If two strings have 1,000 characters, the comparison may need to check many of them, so it is still fast but not free. A subtle bug is writing equals(Person p) instead of equals(Object o): that creates an overload, not an override, so collections and framework code ignore it.

Real-World Example: In an e-commerce checkout service, order IDs came from a database query in one path and from an HTTP request in another. A developer compared them with == because the values looked identical in logs, but the references were different, so the service incorrectly treated valid orders as missing. Customers saw 404 or order-not-found errors right after payment, and logs showed the same characters with different identity hashes. The fix was to use equals() for the ID and to add tests that create the same text through different code paths. A similar bug can happen with equals() on custom objects that never override it: the code silently falls back to identity comparison and duplicates appear in sets and maps.

Follow-up & Tricky Questions:

• What does Object.equals() do by default? It behaves like ==, so it returns true only when both references point to the same object. That is why custom classes usually need their own override.
• Why should equals() and hashCode() be overridden together? Hash-based collections such as HashMap and HashSet use hashCode() first and then equals() for collisions. If equal objects have different hash codes, they can end up in different buckets and look unequal to the collection.
• Can equals() compare primitive types? No, primitives do not have methods. You compare primitives with ==; if they are boxed into wrapper objects, then you can call equals().
• How does HashMap use equality? It computes the key's hash to find a bucket, then uses equals() to find the exact matching key inside that bucket. So a bad equals() implementation can make lookups fail even when the data looks correct.
• What is Objects.equals(a, b) for? It is a null-safe helper that returns true if both are null, false if only one is null, and otherwise delegates to a.equals(b). It is a good default when either side might be missing.

• Why can Integer a = 127; Integer b = 127; a == b be true? Java usually caches wrapper objects for small values, so both variables may point to the same cached object. That is a trap: the result is about caching, not about numeric equality.
• Does new String("java").equals("java") return true? Yes, because equals() compares the characters, not the object identity. But == is false because they are two different objects.
• Do arrays compare with equals() by contents? No, arrays inherit Object.equals(), so == and equals() both check identity unless you use Arrays.equals or Arrays.deepEquals.

Common Mistakes

• Using == for Strings. Correction: use equals() for text content; == only tells you whether both references are the same object.
• Overriding equals() but forgetting hashCode(). Correction: always override both together so hash-based collections behave correctly.
• Calling equals() on a possibly null reference. Correction: use Objects.equals(a, b) or check for null first.
• Thinking arrays are deep-compared by equals(). Correction: use Arrays.equals or Arrays.deepEquals for array content comparison.

Memory Hook

== asks, 'Is this the same house?' equals() asks, 'Do these two houses have the same layout and contents?'

Cheat Sheet

• == on primitives means value comparison.
• == on objects means reference identity.
• equals() is for logical equality.
• Default Object.equals() behaves like identity.
• If you override equals(), also override hashCode().
• For null-safe checks, use Objects.equals.

Practice Tasks

• Compare a String literal with new String and print == and equals().
• Create a value class like Money or Point, override equals() and hashCode(), and test it inside a HashSet.
• Write one example where == is correct, one where equals() is correct, and one where Objects.equals() is safest.