Wrapper Keys Cause IdentityHashMap Serialization Loss

import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapInternals {

    public static void main(String[] args) {

        // Two String objects with IDENTICAL content but different references.
        // 'new String(...)' deliberately bypasses the string pool so we get
        // two physically separate objects in the heap.
        String keyA = new String("session");
        String keyB = new String("session");

        System.out.println("--- Equality checks ---");
        System.out.println("keyA.equals(keyB) : " + keyA.equals(keyB));  // true  — same content
        System.out.println("keyA == keyB       : " + (keyA == keyB));    // false — different objects
        System.out.println("identityHashCode A : " + System.identityHashCode(keyA));
        System.out.println("identityHashCode B : " + System.identityHashCode(keyB));

        // ------- IdentityHashMap behaviour -------
        IdentityHashMap<String, String> identityMap = new IdentityHashMap<>();

        identityMap.put(keyA, "value-for-A");
        identityMap.put(keyB, "value-for-B");  // keyB != keyA by ==, so this is a SECOND entry

        // Two entries exist even though the keys look identical!
        System.out.println("\n--- IdentityHashMap ---");
        System.out.println("Size (expect 2) : " + identityMap.size());
        System.out.println("Get with keyA   : " + identityMap.get(keyA));  // value-for-A
        System.out.println("Get with keyB   : " + identityMap.get(keyB));  // value-for-B

        // ------- HashMap behaviour for contrast -------
        Map<String, String> hashMap = new java.util.HashMap<>();

        hashMap.put(keyA, "value-for-A");
        hashMap.put(keyB, "value-for-B");  // keyB.equals(keyA) == true, so this OVERWRITES

        System.out.println("\n--- HashMap (for comparison) ---");
        System.out.println("Size (expect 1) : " + hashMap.size());  // only 1 entry survives
        System.out.println("Get with keyA   : " + hashMap.get(keyA)); // value-for-B (overwritten)
        System.out.println("Get with keyB   : " + hashMap.get(keyB)); // value-for-B
    }
}

import java.util.IdentityHashMap;
import java.util.ArrayList;
import java.util.List;

/**
 * Demonstrates IdentityHashMap as a 'visited' tracker during
 * recursive object graph traversal. This is the pattern Java's
 * own serialization engine uses internally.
 */
public class ObjectGraphVisitor {

    // A simple node that deliberately overrides equals() by content.
    // This is the key: two nodes with the same label are 'equal' by value
    // but may be two physically separate objects in a cyclic graph.
    static class GraphNode {
        String label;
        List<GraphNode> neighbours = new ArrayList<>();

        GraphNode(String label) { this.label = label; }

        // equals() and hashCode() are based on label content — NOT reference
        @Override public boolean equals(Object other) {
            if (!(other instanceof GraphNode)) return false;
            return this.label.equals(((GraphNode) other).label);
        }
        @Override public int hashCode() { return label.hashCode(); }
        @Override public String toString() { return "Node(" + label + ")"; }
    }

    // IdentityHashMap as a visited-set. Value is irrelevant; we use Boolean.TRUE
    // as a lightweight placeholder — the key IS the visited tracking mechanism.
    private final IdentityHashMap<GraphNode, Boolean> visited = new IdentityHashMap<>();

    public void traverse(GraphNode startNode) {
        // containsKey uses == internally — correct for cycle detection
        if (visited.containsKey(startNode)) {
            System.out.println("Already visited (by reference): " + startNode);
            return;
        }

        visited.put(startNode, Boolean.TRUE);  // mark this exact object as seen
        System.out.println("Visiting: " + startNode);

        for (GraphNode neighbour : startNode.neighbours) {
            traverse(neighbour);  // recurse into neighbours
        }
    }

    public static void main(String[] args) {
        GraphNode nodeA = new GraphNode("auth-service");
        GraphNode nodeB = new GraphNode("user-service");
        GraphNode nodeC = new GraphNode("auth-service");  // SAME label as nodeA, different object!

        // Build a graph: A -> B -> C -> A (cycle back to A, not C)
        nodeA.neighbours.add(nodeB);
        nodeB.neighbours.add(nodeC);
        nodeC.neighbours.add(nodeA);  // points back to the ORIGINAL nodeA instance

        System.out.println("nodeA.equals(nodeC) = " + nodeA.equals(nodeC)); // true — same label!
        System.out.println("nodeA == nodeC      = " + (nodeA == nodeC));    // false — different objects
        System.out.println();

        // If we used a HashSet<GraphNode> or HashMap<GraphNode,...> for 'visited',
        // visiting nodeC would INCORRECTLY appear as 'already visited' because
        // nodeC.equals(nodeA) == true. IdentityHashMap prevents that false positive.
        new ObjectGraphVisitor().traverse(nodeA);
    }
}

import java.util.IdentityHashMap;

/**
 * Demonstrates the autoboxing trap in IdentityHashMap.
 * This is one of the most surprising bugs you can hit in production
 * when using IdentityHashMap with Integer keys.
 */
public class AutoboxingTrap {

    public static void main(String[] args) {

        IdentityHashMap<Integer, String> sessionMap = new IdentityHashMap<>();

        // Integer.valueOf() caches values from -128 to 127.
        // Both of these calls return THE EXACT SAME cached Integer object.
        Integer sessionIdSmall1 = Integer.valueOf(42);   // returns cached instance
        Integer sessionIdSmall2 = Integer.valueOf(42);   // returns the SAME cached instance

        System.out.println("--- Small Integer (within cache range) ---");
        System.out.println("sessionIdSmall1 == sessionIdSmall2 : " + (sessionIdSmall1 == sessionIdSmall2)); // true!

        sessionMap.put(sessionIdSmall1, "user-alice");
        sessionMap.put(sessionIdSmall2, "user-bob");   // same reference! OVERWRITES, size stays 1

        System.out.println("Map size (expect 1 due to cache): " + sessionMap.size()); // 1
        System.out.println("Value: " + sessionMap.get(Integer.valueOf(42)));           // user-bob

        sessionMap.clear();

        // Integer.valueOf(1000) is OUTSIDE the cache range.
        // Each call creates a brand new Integer object on the heap.
        Integer sessionIdLarge1 = Integer.valueOf(1000); // new object
        Integer sessionIdLarge2 = Integer.valueOf(1000); // another new object

        System.out.println("\n--- Large Integer (outside cache range) ---");
        System.out.println("sessionIdLarge1 == sessionIdLarge2 : " + (sessionIdLarge1 == sessionIdLarge2)); // false!

        sessionMap.put(sessionIdLarge1, "user-charlie");
        sessionMap.put(sessionIdLarge2, "user-diana");  // different reference — TWO entries!

        System.out.println("Map size (expect 2, surprise!): " + sessionMap.size()); // 2

        // Trying to retrieve with a THIRD Integer(1000) won't find anything
        // because it's yet another new reference, unknown to the map.
        Integer lookupAttempt = Integer.valueOf(1000);
        System.out.println("Lookup with new Integer(1000): " + sessionMap.get(lookupAttempt)); // null!

        // FIX: Always hold onto the exact reference you put in, and use it to retrieve.
        System.out.println("Lookup with original ref     : " + sessionMap.get(sessionIdLarge1)); // user-charlie
    }
}

import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Collections;

public class IdentityHashMapThreadSafety {

    public static void main(String[] args) throws InterruptedException {
        // NOT thread-safe — concurrent put may cause infinite loop or lost updates
        IdentityHashMap<String, String> unsafe = new IdentityHashMap<>();
        
        // Thread 1: puts 1000 entries
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // Use new Strings to avoid interning — distinct references
                unsafe.put(new String("key" + i), "value-" + i);
            }
        });
        
        // Thread 2: iterates concurrently
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // May throw ConcurrentModificationException or see inconsistent state
                for (Map.Entry<String, String> e : unsafe.entrySet()) {
                    // simulate read
                    String v = e.getValue();
                }
                Thread.yield();
            }
        });
        
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        
        System.out.println("Final size (expected 1000, but may be less due to lost updates): " + unsafe.size());
        
        // Thread-safe wrapper: external synchronization still required for iteration
        Map<String, String> safe = Collections.synchronizedMap(new IdentityHashMap<>());
        
        // Example of correct iteration with explicit sync
        synchronized (safe) {
            for (Map.Entry<String, String> e : safe.entrySet()) {
                // safe iteration
            }
        }
    }
}

import java.util.*;
import java.util.WeakHashMap;

public class MapSpecializedUsage {

    enum Day { MON, TUE, WED, THU, FRI }

    public static void main(String[] args) {

        // 1. IdentityHashMap for reference-equality tracking
        IdentityHashMap<String, String> identityCache = new IdentityHashMap<>();
        String s1 = new String("unique");
        String s2 = new String("unique");
        identityCache.put(s1, "data1");
        identityCache.put(s2, "data2");
        System.out.println("IdentityHashMap size: " + identityCache.size()); // 2

        // 2. WeakHashMap for memory-sensitive caches (but uses equals!)
        WeakHashMap<Object, String> weakCache = new WeakHashMap<>();
        Object key = new Object();
        weakCache.put(key, "value");
        System.out.println("WeakHashMap before GC: " + weakCache.size()); // 1
        key = null; // make key weakly reachable
        System.gc(); // encourage collection (not guaranteed)
        // After GC, the entry may be removed.
        System.out.println("WeakHashMap after GC (likely 0): " + weakCache.size()); // 0 or 1

        // 3. EnumMap for enum keys — fastest and safest
        EnumMap<Day, String> schedule = new EnumMap<>(Day.class);
        schedule.put(Day.MON, "Work");
        schedule.put(Day.FRI, "Party");
        System.out.println("EnumMap size: " + schedule.size()); // 2

        // Contrast: HashMap with enum keys works but slower
        Map<Day, String> hashMap = new HashMap<>();
        hashMap.put(Day.MON, "Work");
        System.out.println("HashMap with enum keys: " + hashMap.get(Day.MON));
    }
}

// io.thecodeforge
import java.io.*;
import java.util.*;

public class IdentityMapSerializationBug {
    public static void main(String[] args) throws Exception {
        IdentityHashMap<String, String> map = new IdentityHashMap<>();
        map.put(new String("key"), "value1");
        map.put(new String("key"), "value2");
        System.out.println("Before: " + map.size()); // 2

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(map);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        IdentityHashMap<String, String> restored = (IdentityHashMap<String, String>) ois.readObject();
        ois.close();

        System.out.println("After: " + restored.size()); // 1 — different reference now
    }
}

// io.thecodeforge
import java.util.*;

public class IdentityMapConstructorTrap {
    public static void main(String[] args) {
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put("same", "a");
        hashMap.put("same", "b");
        System.out.println("HashMap size: " + hashMap.size()); // 1

        // Copy constructor — strings become distinct by reference
        IdentityHashMap<String, String> identityMap = new IdentityHashMap<>(hashMap);
        System.out.println("IdentityHashMap size: " + identityMap.size()); // 2
        
        // Explicit expected size prevents resize thrashing
        IdentityHashMap<String, String> sizedMap = new IdentityHashMap<>(256);
        System.out.println("Pre-sized map created with optimal capacity");
    }
}

// io.thecodeforge
import java.util.*;

public class IdentityMapReferenceLookup {
    public static void main(String[] args) {
        IdentityHashMap<String, Integer> map = new IdentityHashMap<>();
        String key1 = new String("account");
        String key2 = new String("account");
        
        map.put(key1, 100);
        System.out.println("Get with key1: " + map.get(key1)); // 100
        System.out.println("Get with key2: " + map.get(key2)); // null — different reference

        // Safe pattern: keep the original reference
        map.put(key1, 200);
        System.out.println("After update: " + map.get(key1)); // 200

        // Iteration with safe removal
        Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            it.next();
            it.remove(); // safe
        }
        System.out.println("Size after removal: " + map.size()); // 0
    }
}