79:T663,public class IdentityDemo { public static void main(String[] args) { // Create one object, assign to two variables Person alice1 = new Person("Alice", 30); Person alice2 = alice1; // Same reference copied // Create another object with same values Person alice3 = new Person("Alice", 30); // Memory visualization: // // alice1: 0x1A ────┐ // │ // ▼ // ┌─────────────┐ // │ name: Alice │ ◀── ONE object in memory // │ age: 30 │ // └─────────────┘ // ▲ // │ // alice2: 0x1A ────┘ // // alice3: 0x2B ───────────▶ ┌─────────────┐ // │ name: Alice │ ◀── DIFFERENT object // │ age: 30 │ // └─────────────┘ // Identity checks (comparing memory addresses) System.out.println(alice1 == alice2); // true - same object System.out.println(alice1 == alice3); // false - different objects // Proof of identity: mutual modification alice1.setAge(31); System.out.println(alice2.getAge()); // 31 - change visible! System.out.println(alice3.getAge()); // 30 - unchanged } }7a:T479,public class IdentityVsEquality { public static void main(String[] args) { // Scenario 1: Same object (identity implies equality) Money m1 = new Money(100, "USD"); Money m2 = m1; // If identical, always equal assert m1 == m2; // Identity: true assert m1.equals(m2); // Equality: true (trivially) // Scenario 2: Different objects, equal values Money m3 = new Money(100, "USD"); Money m4 = new Money(100, "USD"); // Not identical, but should be equal assert m3 != m4; // Identity: false (different objects) assert m3.equals(m4); // Equality: true (same value) // Scenario 3: Different objects, different values Money m5 = new Money(100, "USD"); Money m6 = new Money(200, "EUR"); assert m5 != m6; // Identity: false assert !m5.equals(m6); // Equality: false // KEY INSIGHT: // Identity IMPLIES equality (same object = same values) // Equality DOES NOT IMPLY identity (same values ≠ same object) } }71:{"json":{"id":"seed_b7c7241c7516af2124d7ea34e2347ee5","slug":"object-identity-equality-hashing","category":"System Design (LLD)","topic":"Object Identity, Equality, and Hashing","title":"Object Identity, Equality, and Hashing","description":"Master the fundamental concepts of object identity, equality, and hashing. Learn to distinguish between same memory location (identity) and same value (equality), implement equals/hashCode correctly, and understand the consistency requirements that prevent subtle bugs in collections and comparisons.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_cfcfd464c9769a0cfbf7e9a0fbc1924a","title":"Object Identity — The Concept of Same Memory Location","order":0,"content":[{"id":"opening-hook","title":"When 'Same' Is Not 'Equal'","content":[{"data":{"content":"Consider this scenario: You create two `Person` objects with identical names, ages, and addresses. Are they the *same* person? In the physical world, two people with identical attributes are clearly different individuals. In software, the answer depends on what you mean by 'same'—and getting this distinction wrong is one of the most common sources of subtle, hard-to-debug errors in object-oriented systems.\n\nThis page explores **object identity**—the concept of two references pointing to the exact same location in memory. It's the first of three fundamental concepts (identity, equality, and hashing) that every software engineer must master to build correct, maintainable systems."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand: (1) What object identity means at the memory level, (2) How identity differs from equality, (3) How different programming languages handle identity checks, (4) Common bugs caused by confusing identity with equality, and (5) When to use identity vs equality comparisons in your code.","variant":"info"},"type":"callout"}]},{"id":"understanding-object-references","title":"Understanding Object References","content":[{"data":{"content":"Before we can understand identity, we need to understand what happens when you create an object in memory. In most object-oriented languages, when you declare an object variable, you're not storing the object itself—you're storing a **reference** (or pointer) to where that object lives in memory.\n\n**The Memory Model:**\n\nThink of computer memory as a vast warehouse with numbered storage bins. When you create an object, the runtime:\n\n1. Finds an empty bin (allocates memory)\n2. Stores the object's data in that bin\n3. Returns the bin's address (the reference)\n4. Your variable holds this address, not the contents\n\nThis reference-based model has profound implications for how we compare objects."},"type":"text"},{"data":{"code":"// When we write this:\nPerson alice = new Person(\"Alice\", 30);\nPerson bob = new Person(\"Bob\", 25);\n\n// Memory looks like this:\n//\n// Stack (Variables) Heap (Objects)\n// ┌─────────────┐ ┌─────────────────────────────┐\n// │ alice: 0x1A │ ──────────▶│ Address: 0x1A │\n// └─────────────┘ │ name: \"Alice\" │\n// │ age: 30 │\n// ┌─────────────┐ └─────────────────────────────┘\n// │ bob: 0x2B │ ──────────▶┌─────────────────────────────┐\n// └─────────────┘ │ Address: 0x2B │\n// │ name: \"Bob\" │\n// │ age: 25 │\n// └─────────────────────────────┘\n//\n// The variables 'alice' and 'bob' hold memory addresses,\n// not the actual Person data.","fileName":"ReferenceDemo.java","language":"java"},"type":"code"},{"data":{"icon":"Lightbulb","title":"The Postal Address Analogy","content":"Think of object references like postal addresses. The address '123 Main Street' isn't the house itself—it's a way to locate the house. Multiple people can have the same address written on different pieces of paper, but there's still only one house. Similarly, multiple variables can reference the same object in memory.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"what-is-object-identity","title":"What Is Object Identity?","content":[{"data":{"content":"**Object identity** answers a specific question: Do these two references point to the *exact same* object in memory?\n\nNot 'Do they have the same values?' or 'Do they represent the same real-world entity?'—but literally, 'Are they the same block of memory?'\n\n**Formal Definition:**\n\nTwo object references `a` and `b` are *identical* if and only if they contain the same memory address—meaning any modification through `a` would be visible through `b`, because they're different names for the same underlying object.\n\nThis is the strictest form of 'sameness.' Objects with exactly the same attribute values are not identical unless they're literally the same object."},"type":"text"},{"data":{"code":"$79","fileName":"IdentityDemo.java","language":"java"},"type":"code"},{"data":{"items":["**Same Memory Address** — Identical objects share the exact same location in the heap.","**Mutual Modification** — Any change through one reference affects all references to that object.","**Reflexive** — An object is always identical to itself (a == a is always true).","**Symmetric** — If a == b, then b == a (identity is bidirectional).","**Transitive** — If a == b and b == c, then a == c (identity chains).","**Consistent** — Identity never changes during an object's lifetime—same address forever."],"title":{"icon":"Target","text":"Key Characteristics of Identity","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"titleType":"number","titleNumber":2},{"id":"identity-operators-across-languages","title":"Identity Operators Across Languages","content":[{"data":{"content":"Different programming languages express identity checks differently. Understanding these differences is essential when working across language boundaries or reviewing unfamiliar code.\n\n**The Common Thread:** All these operators compare memory addresses, not values."},"type":"text"},{"data":{"rows":[["Java","==","obj1 == obj2","For objects only; primitives use value comparison"],["Python","is","obj1 is obj2","Clear distinction from == (equality)"],["C#","object.ReferenceEquals()","ReferenceEquals(a, b)","Can also use == if not overloaded"],["JavaScript","===","obj1 === obj2","Compares references for objects"],["C++","== on pointers","ptr1 == ptr2","Compare pointer addresses directly"],["Ruby","equal?","obj1.equal?(obj2)","Distinct from == and eql?"],["Go","== on pointers","*a == *b","Need to compare pointer values"],["Kotlin","===","obj1 === obj2","Referential equality operator"]],"caption":"Identity Operators by Language","headers":["Language","Identity Operator","Example","Notes"]},"type":"table"},{"data":{"code":"# Python's 'is' operator checks identity\n# Python's '==' operator checks equality\n\nclass Person:\n def __init__(self, name, age):\n self.name = name\n self.age = age\n \n def __eq__(self, other):\n # Equality: same values\n return self.name == other.name and self.age == other.age\n\nalice1 = Person(\"Alice\", 30)\nalice2 = alice1 # Same reference\nalice3 = Person(\"Alice\", 30) # Different object, same values\n\n# Identity checks with 'is'\nprint(alice1 is alice2) # True - same object in memory\nprint(alice1 is alice3) # False - different objects\n\n# Equality checks with '=='\nprint(alice1 == alice2) # True - same values (same object)\nprint(alice1 == alice3) # True - same values (different object)\n\n# The critical difference:\n# 'is' asks: \"Are these the same box?\"\n# '==' asks: \"Do these boxes contain equivalent things?\"","fileName":"identity_python.py","language":"python"},"type":"code"},{"data":{"icon":"AlertCircle","title":"The Java String Trap","content":"In Java, using == on strings can produce confusing results due to string interning. `\"hello\" == \"hello\"` returns true (interned), but `new String(\"hello\") == new String(\"hello\")` returns false. This catches countless developers. Always use .equals() for string comparison in Java.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"identity-vs-equality","title":"Identity vs. Equality — The Fundamental Distinction","content":[{"data":{"content":"This is the central concept of this entire module: **Identity and equality are different concepts that answer different questions.**"},"type":"text"},{"data":{"rows":[["Are these the same box?","Identity","Two labels on one box"],["Do these boxes contain equivalent things?","Equality","Two boxes with identical contents"]],"headers":["Question","Concept","Metaphor"]},"type":"table"},{"data":{"content":"Identity is **physical sameness**—one object viewed through different lenses.\nEquality is **logical equivalence**—different objects that should be treated as interchangeable for some purpose.\n\n**Why This Matters:**\n\nThe distinction directly affects program behavior in collections, caching, comparisons, and virtually every non-trivial software system."},"type":"text"},{"data":{"left":[{"data":{"items":["One object, multiple references","Modifications shared across all references","Fastest possible comparison (address check)","Cannot be overridden or customized","Asks: 'Same physical thing?'"],"title":{"icon":"Key","text":"Identity (Same Memory)","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["Different objects, logically equivalent","Modifications independent","Comparison cost depends on object complexity","Programmer-defined behavior","Asks: 'Logically interchangeable?'"],"title":{"icon":"Scale","text":"Equality (Same Value)","type":"icon","color":"secondary","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"code":"$7a","fileName":"IdentityVsEquality.java","language":"java"},"type":"code"},{"data":{"icon":"Lightbulb","title":"The Mathematical Perspective","content":"In mathematical terms: Identity is to equality as A ⊆ B. If a == b (identity), then a.equals(b) must be true. But if a.equals(b) is true, a == b may still be false. Identity is a stricter condition that guarantees equality, but not vice versa.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"identity-real-world-scenarios","title":"Identity in Real-World Scenarios","content":[{"data":{"content":"Understanding when identity matters versus when equality matters is crucial for correct software design. Let's examine scenarios where the distinction is critical.\n\n**Scenario 1: Object Modification Propagation**\n\nWhen you pass an object to a method, are you passing the same object (identity preserved) or a copy (new identity)? This determines whether modifications are visible to the caller."},"type":"text"},{"data":{"code":"public void demonstrateIdentityAndModification() {\n List originalList = new ArrayList<>();\n originalList.add(\"A\");\n \n // Pass by reference: identity preserved\n modifyList(originalList);\n System.out.println(originalList); // [A, B] - modified!\n \n // Pass a copy: new identity, original unchanged\n List copy = new ArrayList<>(originalList);\n modifyList(copy);\n System.out.println(originalList); // [A, B] - still unchanged!\n}\n\nprivate void modifyList(List list) {\n list.add(\"B\"); // Modifies whichever object 'list' references\n}\n\n// The same reference (identity) means shared fate.\n// A different reference (copy) means independent lives.","fileName":"ModificationScenario.java","language":"java"},"type":"code"},{"data":{"content":"**Scenario 2: Caching and Object Reuse**\n\nCaches often rely on identity to determine if an object is already cached. If you create a new object with the same values, the cache may not recognize it as 'the same' unless you explicitly check equality."},"type":"text"},{"data":{"code":"public class IdentityCache {\n private Set cache = new IdentityHashSet<>(); // Uses identity, not equals\n \n public void cache(T object) {\n cache.add(object);\n }\n \n public boolean isCached(T object) {\n return cache.contains(object); // Checks identity!\n }\n}\n\n// Usage\nUser user1 = new User(\"alice@example.com\");\nUser user2 = new User(\"alice@example.com\"); // Same email, different object\n\nIdentityCache cache = new IdentityCache<>();\ncache.cache(user1);\n\ncache.isCached(user1); // true - same object\ncache.isCached(user2); // false - different object, even though equal!\n\n// When is IdentityCache useful?\n// - Tracking which exact instances are in use\n// - Preventing duplicate processing of the same object reference\n// - Detecting object cycles during serialization","fileName":"CachingScenario.java","language":"java"},"type":"code"},{"data":{"content":"**Scenario 3: Singleton Pattern Verification**\n\nSingletons guarantee exactly one instance exists. Identity checks verify this guarantee."},"type":"text"},{"data":{"code":"public class DatabaseConnection {\n private static DatabaseConnection instance;\n \n private DatabaseConnection() { /* private constructor */ }\n \n public static DatabaseConnection getInstance() {\n if (instance == null) {\n instance = new DatabaseConnection();\n }\n return instance;\n }\n}\n\n// Verify singleton behavior with identity check\nDatabaseConnection conn1 = DatabaseConnection.getInstance();\nDatabaseConnection conn2 = DatabaseConnection.getInstance();\n\n// This MUST be true for a correct singleton\nassert conn1 == conn2; // Identity check confirms one instance\n\n// If a bug created multiple instances, equals might still return true\n// (if poorly implemented), but identity check would catch it.","fileName":"SingletonScenario.java","language":"java"},"type":"code"},{"data":{"icon":"Info","title":"When to Use Identity Checks","content":"Use identity (==) when: (1) Checking for null, (2) Verifying singleton behavior, (3) Optimizing equality checks (if identical, must be equal—fast path), (4) Tracking specific object instances, (5) Detecting reference cycles. Use equality (.equals()) for most logical comparisons.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"common-bugs","title":"Common Bugs From Confusing Identity and Equality","content":[{"data":{"content":"Confusing identity with equality is responsible for countless bugs in production systems. Let's examine the most common patterns and how to avoid them."},"type":"text"},{"data":{"items":["**The Bug:** Using == to compare strings","**Why It Sometimes Works:** String interning caches literals","**Why It Fails:** Runtime-created strings aren't interned","**The Fix:** Always use .equals() for string comparison"],"title":{"icon":"Bug","text":"Bug Pattern 1: String Comparison in Java","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"code":"// BUG: Works by accident, fails unpredictably\nString greeting1 = \"hello\";\nString greeting2 = \"hello\";\nif (greeting1 == greeting2) { // true - but only because of interning!\n System.out.println(\"Same\");\n}\n\n// This WILL fail:\nString userInput = readFromNetwork(); // Returns \"hello\"\nif (greeting1 == userInput) { // false! Different objects\n System.out.println(\"Same\"); // Never prints\n}\n\n// CORRECT approach:\nif (greeting1.equals(userInput)) { // true - compares values\n System.out.println(\"Same\"); // Works correctly\n}","fileName":"StringBug.java","language":"java"},"type":"code"},{"data":{"items":["**The Bug:** Using == on Integer wrapper objects","**Why It Sometimes Works:** Java caches Integer values -128 to 127","**Why It Fails:** Values outside cache create new objects","**The Fix:** Use .equals() or unbox to primitives"],"title":{"icon":"Bug","text":"Bug Pattern 2: Integer Caching Trap","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"code":"// DANGEROUS: Works within cache range\nInteger a = 100;\nInteger b = 100;\nSystem.out.println(a == b); // true - cached!\n\n// FAILS outside cache range\nInteger x = 200;\nInteger y = 200;\nSystem.out.println(x == y); // false! Different objects\n\n// This bug is particularly insidious because:\n// - Tests pass (with small numbers)\n// - Production fails (with real data, larger numbers)\n\n// CORRECT approaches:\nSystem.out.println(a.equals(b)); // true - value comparison\nSystem.out.println(x.equals(y)); // true - value comparison\nSystem.out.println(x.intValue() == y.intValue()); // true - primitives","fileName":"IntegerCacheBug.java","language":"java"},"type":"code"},{"data":{"items":["**The Bug:** Expecting equality-based lookup but getting identity-based","**Cause:** Not overriding equals/hashCode in custom classes","**Symptom:** 'Contains' returns false for logically equal objects","**The Fix:** Override equals and hashCode together"],"title":{"icon":"Bug","text":"Bug Pattern 3: Collection Membership Failure","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"code":"// Class without equals/hashCode override\nclass UserId {\n private final String id;\n \n public UserId(String id) { this.id = id; }\n \n // NO equals() override - uses Object.equals (identity)\n}\n\n// The bug in action:\nSet activeUsers = new HashSet<>();\nactiveUsers.add(new UserId(\"user123\"));\n\nUserId checkId = new UserId(\"user123\"); // Same value, new object\nSystem.out.println(activeUsers.contains(checkId)); // false!\n\n// Why? HashSet uses equals() for contains(), and Object.equals()\n// defaults to identity comparison. Different objects = not found.\n\n// The fix: override equals() and hashCode() in UserId\n// (We'll cover this in detail in later pages)","fileName":"CollectionBug.java","language":"java"},"type":"code"},{"data":{"icon":"AlertCircle","title":"The Silent Failure","content":"These bugs are particularly dangerous because they don't throw exceptions. The code runs, produces wrong results, and you might not notice until users report problems—or until an audit reveals corrupted data.","variant":"error"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"identity-and-null","title":"Identity and Null — The Special Case","content":[{"data":{"content":"Null is the one case where identity checks are not just acceptable but *required*. Calling `.equals()` on null throws a `NullPointerException`, so we must use identity to check for null first.\n\n**The Pattern:**\n\nAlways check for null with identity (==) before using methods like .equals()."},"type":"text"},{"data":{"code":"// WRONG: Throws NullPointerException\nString input = getUserInput(); // might be null\nif (input.equals(\"expected\")) { // CRASH if input is null!\n // ...\n}\n\n// CORRECT: Check null first (identity check)\nString input = getUserInput();\nif (input != null && input.equals(\"expected\")) {\n // Safe - null check prevents the method call\n}\n\n// BETTER: Use Objects.equals() for null-safe comparison\nimport java.util.Objects;\n\nif (Objects.equals(input, \"expected\")) {\n // Works if input is null - returns false, no exception\n}\n\n// How Objects.equals() works internally:\npublic static boolean equals(Object a, Object b) {\n return (a == b) || (a != null && a.equals(b));\n // ↑ identity ↑ null check ↑ equality\n}","fileName":"NullSafety.java","language":"java"},"type":"code"},{"data":{"icon":"Lightbulb","title":"Null as Identity","content":"In most languages, null has no identity—it's the absence of a reference. `null == null` is true (the absence is 'equal' to itself), but null doesn't point to any object. This is why you can't call methods on null—there's no object to receive the message.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"summary-next-steps","title":"Summary: Object Identity","content":[{"data":{"content":"We've explored the foundational concept of object identity—what it means for two references to point to the same memory location. Let's consolidate the key insights:"},"type":"text"},{"data":{"type":"ordered","items":["**Identity = Same Memory Location** — Two references are identical if they point to the exact same object on the heap.","**Identity Is Stricter Than Equality** — If two references are identical, they must be equal. Equal references are not necessarily identical.","**Identity Cannot Be Overridden** — It's determined by memory addresses, not programmer logic.","**Common Bugs Arise From Confusion** — Using == when you mean .equals() (and vice versa) causes subtle, hard-to-find bugs.","**Null Requires Identity Checks** — Always use == for null comparisons to avoid NullPointerException.","**Different Languages, Same Concept** — Whether it's ==, is, or ===, all languages have a way to check identity."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nNow that we understand identity (same memory), we'll explore **equality** (same value) in the next page. You'll learn how to define what 'equal' means for your objects, implement the equals() method correctly, and avoid the treacherous pitfalls that trip up even experienced developers."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand object identity—the concept of same memory location. This foundational knowledge prepares you for the more nuanced concept of equality, where you'll define logical equivalence for your objects. Next: Equality — Same Value.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_cdf5cccf20770591cb728d97b24979cc","title":"Object Equality — The Concept of Same Value","order":1,"content":null,"isLocked":true},{"id":"seed_ebe3740423d293132b965f808120e5c0","title":"Implementing equals() and hashCode()","order":2,"content":null,"isLocked":true},{"id":"seed_ad053f163a5b2d0d237b2b99da9f09e4","title":"Consistency Requirements","order":3,"content":null,"isLocked":true}]}}