LinkedHashMap and LinkedHashSet in Java — Order, Performance and Real-World Patterns

import java.util.LinkedHashMap;
import java.util.Map;

public class InsertionOrderDemo {

    public static void main(String[] args) {

        // Default constructor — uses INSERTION ORDER
        Map<String, Integer> userScores = new LinkedHashMap<>();

        // Adding entries in a deliberate sequence
        userScores.put("alice", 1500);
        userScores.put("bob",   980);
        userScores.put("carol", 2200);
        userScores.put("dave",  750);

        System.out.println("=== Leaderboard (insertion order preserved) ===");

        // Iterating — entries come back in EXACTLY the order we inserted them
        for (Map.Entry<String, Integer> entry : userScores.entrySet()) {
            System.out.printf("  %-8s → %d points%n", entry.getKey(), entry.getValue());
        }

        // Updating an existing key does NOT change its position in the list
        userScores.put("bob", 1100); // bob's score changes but he stays in slot 2

        System.out.println("\n=== After updating bob's score ===");
        userScores.forEach((name, score) ->
            System.out.printf("  %-8s → %d points%n", name, score)
        );

        // Removing and re-adding DOES change position — bob moves to the end
        userScores.remove("bob");
        userScores.put("bob", 1350);

        System.out.println("\n=== After removing and re-adding bob ===");
        userScores.forEach((name, score) ->
            System.out.printf("  %-8s → %d points%n", name, score)
        );
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * A simple LRU cache that holds at most MAX_PAGES recently visited web pages.
 * When the cache is full, the least-recently-accessed page is automatically evicted.
 */
public class LruPageCache {

    private static final int MAX_PAGES = 3;

    // accessOrder = true → get() moves the accessed entry to the tail (most-recently-used)
    // 0.75f is the standard load factor — no need to change this
    private final Map<String, String> cache = new LinkedHashMap<>(MAX_PAGES, 0.75f, true) {

        @Override
        protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
            // Return true when we've exceeded capacity — the map will evict the HEAD
            // (least-recently-used) automatically after each put()
            boolean shouldEvict = size() > MAX_PAGES;
            if (shouldEvict) {
                System.out.println("  [EVICTED] " + eldest.getKey());
            }
            return shouldEvict;
        }
    };

    /** Simulate loading a page — store its title keyed by URL. */
    public void visit(String url, String pageTitle) {
        System.out.println("Visiting: " + url);
        cache.put(url, pageTitle);
    }

    /** Simulate navigating back to a cached page — this refreshes its recency. */
    public String revisit(String url) {
        // get() in access-order mode moves this entry to the tail (most-recently-used)
        return cache.getOrDefault(url, "[not in cache — full page load required]");
    }

    public void printCache() {
        System.out.println("  Cache (LRU → MRU): " + cache.keySet());
    }

    public static void main(String[] args) {

        LruPageCache browserCache = new LruPageCache();

        browserCache.visit("thecodeforge.io/java",        "Java Hub");
        browserCache.visit("thecodeforge.io/collections", "Collections Guide");
        browserCache.visit("thecodeforge.io/streams",     "Streams Deep Dive");
        browserCache.printCache();

        // Re-access the first page — it moves to MRU position, pushing 'collections' to LRU
        System.out.println("\nRevisiting java page: " + browserCache.revisit("thecodeforge.io/java"));
        browserCache.printCache();

        // Adding a 4th page triggers eviction of the current LRU entry ('collections')
        System.out.println();
        browserCache.visit("thecodeforge.io/generics", "Generics Explained");
        browserCache.printCache();
    }
}

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class DeduplicateUserEvents {

    public static void main(String[] args) {

        // Simulates an event stream with retries — same event IDs arrive multiple times
        List<String> incomingEventIds = Arrays.asList(
            "evt-001", "evt-002", "evt-003",
            "evt-002", // retry duplicate
            "evt-004",
            "evt-001", // retry duplicate
            "evt-005"
        );

        // --- Option A: HashSet --- deduplicates but destroys order
        Set<String> unorderedUnique = new HashSet<>(incomingEventIds);
        System.out.println("HashSet result (order undefined):");
        System.out.println("  " + unorderedUnique);
        System.out.println("  Can we rely on this order for processing? NO.");

        // --- Option B: LinkedHashSet --- deduplicates AND preserves first-seen order
        Set<String> orderedUnique = new LinkedHashSet<>();
        for (String eventId : incomingEventIds) {
            boolean isNew = orderedUnique.add(eventId); // add() returns false for duplicates
            if (!isNew) {
                // In a real system you'd log this at DEBUG level and increment a counter
                System.out.println("  [DUPLICATE DROPPED] " + eventId);
            }
        }

        System.out.println("\nLinkedHashSet result (insertion order preserved):");
        System.out.println("  " + orderedUnique);

        System.out.println("\nProcessing events in reliable first-seen order:");
        for (String eventId : orderedUnique) {
            System.out.println("  → Processing " + eventId);
        }
    }
}

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * A practical micro-benchmark to illustrate the performance characteristics
 * of HashMap vs LinkedHashMap. Not a JMH benchmark — for illustration only.
 * Run this to see approximate relative costs on your own JVM.
 */
public class PerformanceComparison {

    private static final int ENTRY_COUNT  = 500_000;
    private static final int WARMUP_RUNS  = 3;
    private static final int TIMED_RUNS   = 5;

    public static void main(String[] args) {

        System.out.println("Warming up JIT compiler...");
        for (int w = 0; w < WARMUP_RUNS; w++) {
            populateAndIterate(new HashMap<>());
            populateAndIterate(new LinkedHashMap<>());
        }

        long hashMapTotal       = 0;
        long linkedHashMapTotal = 0;

        System.out.println("Running timed trials...");
        for (int run = 1; run <= TIMED_RUNS; run++) {
            long hmTime  = populateAndIterate(new HashMap<>());
            long lhmTime = populateAndIterate(new LinkedHashMap<>());

            System.out.printf("  Run %d → HashMap: %,d ms | LinkedHashMap: %,d ms%n",
                run, hmTime, lhmTime);

            hashMapTotal       += hmTime;
            linkedHashMapTotal += lhmTime;
        }

        System.out.printf("%n  Average → HashMap: %,d ms | LinkedHashMap: %,d ms%n",
            hashMapTotal / TIMED_RUNS, linkedHashMapTotal / TIMED_RUNS);
        System.out.println("\n  Overhead is real but rarely the bottleneck.");
        System.out.println("  Choose based on CORRECTNESS needs first, performance second.");
    }

    /** Populates the given map and iterates all entries — returns elapsed ms. */
    private static long populateAndIterate(Map<Integer, String> map) {
        long start = System.currentTimeMillis();

        // Populate phase
        for (int i = 0; i < ENTRY_COUNT; i++) {
            map.put(i, "value-" + i);
        }

        // Iteration phase — sum string lengths to prevent dead-code elimination
        long charCount = 0;
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            charCount += entry.getValue().length();
        }

        return System.currentTimeMillis() - start;
    }
}