Java HashSet — Mutable hashCode Causes 30% Cache Loss

import java.util.HashSet;
import java.util.Set;

public class HashSetInternals {

    public static void main(String[] args) {

        // --- Basic uniqueness guarantee ---
        Set<String> visitedUrls = new HashSet<>();

        visitedUrls.add("https://thecodeforge.io/java");
        visitedUrls.add("https://thecodeforge.io/python");
        visitedUrls.add("https://thecodeforge.io/java"); // duplicate — silently ignored

        // Size is 2, not 3. The duplicate was rejected without any error.
        System.out.println("Unique URLs tracked: " + visitedUrls.size()); // 2

        // --- O(1) membership check ---
        String urlToCheck = "https://thecodeforge.io/java";
        if (visitedUrls.contains(urlToCheck)) {
            // This lookup is near-instant whether the set has 3 or 3 million elements
            System.out.println("Already crawled: " + urlToCheck);
        }

        // --- add() returns a boolean — use it! ---
        boolean wasNew = visitedUrls.add("https://thecodeforge.io/java"); // already exists
        System.out.println("URL was newly added: " + wasNew); // false — tells you it was a duplicate

        boolean isNew = visitedUrls.add("https://thecodeforge.io/go"); // brand new
        System.out.println("URL was newly added: " + isNew); // true

        // --- Order is NOT guaranteed ---
        // Iterating a HashSet gives you elements in an unpredictable order
        System.out.println("\nAll tracked URLs (order not guaranteed):");
        for (String url : visitedUrls) {
            System.out.println("  " + url);
        }
    }
}

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class ProductDeduplication {

    // A product SKU from an e-commerce catalogue
    static class Product {
        private final String sku;
        private final String name;

        Product(String sku, String name) {
            this.sku = sku;
            this.name = name;
        }

        // Without overriding these, two Product objects with the same SKU
        // would be treated as completely different by HashSet.
        @Override
        public boolean equals(Object other) {
            if (this == other) return true; // same reference — definitely equal
            if (!(other instanceof Product)) return false; // wrong type — definitely not equal
            Product otherProduct = (Product) other;
            // Business rule: two Products are the same if their SKUs match
            return Objects.equals(this.sku, otherProduct.sku);
        }

        @Override
        public int hashCode() {
            // Must use the same field(s) as equals() — SKU drives both
            return Objects.hash(sku);
        }

        @Override
        public String toString() {
            return "Product[sku=" + sku + ", name=" + name + "]";
        }
    }

    public static void main(String[] args) {

        Set<Product> catalogue = new HashSet<>();

        // Simulating products loaded from two different data sources
        Product fromDatabaseA = new Product("BOOT-42", "Trail Boot Size 42");
        Product fromDatabaseB = new Product("BOOT-42", "Trail Boot Size 42"); // same SKU, different object
        Product differentProduct = new Product("HAT-01", "Hiking Hat");

        catalogue.add(fromDatabaseA);
        catalogue.add(fromDatabaseB); // rejected — equals() + hashCode() say it's the same product
        catalogue.add(differentProduct);

        // If we had NOT overridden equals/hashCode, size would be 3 (a silent bug!)
        System.out.println("Unique products in catalogue: " + catalogue.size()); // 2

        // contains() also works correctly now
        Product lookupProduct = new Product("HAT-01", "Hiking Hat");
        System.out.println("Catalogue contains hat: " + catalogue.contains(lookupProduct)); // true

        System.out.println("\nCatalogue contents:");
        catalogue.forEach(System.out::println);
    }
}

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetVariantsComparison {

    public static void main(String[] args) {

        // Imagine these are user-selected tags on a blog post, added in this order
        String[] selectedTags = {"java", "backend", "spring", "java", "performance", "backend"};

        // --- HashSet: unique, but order is unpredictable ---
        Set<String> hashTags = new HashSet<>();
        for (String tag : selectedTags) hashTags.add(tag);
        System.out.println("HashSet (no order guarantee): " + hashTags);
        // Output order will vary between JVM runs

        // --- LinkedHashSet: unique AND preserves insertion order ---
        Set<String> linkedTags = new LinkedHashSet<>();
        for (String tag : selectedTags) linkedTags.add(tag);
        System.out.println("LinkedHashSet (insertion order): " + linkedTags);
        // Always: [java, backend, spring, performance] — first occurrence wins

        // --- TreeSet: unique AND always alphabetically sorted ---
        Set<String> sortedTags = new TreeSet<>();
        for (String tag : selectedTags) sortedTags.add(tag);
        System.out.println("TreeSet (sorted order):        " + sortedTags);
        // Always: [backend, java, performance, spring]

        // --- Range query — a TreeSet superpower HashSet can't do ---
        TreeSet<Integer> pageNumbers = new TreeSet<>();
        for (int page = 1; page <= 20; page++) pageNumbers.add(page);

        // Give me all pages from 5 up to (but not including) 10
        System.out.println("\nPages 5 to 9: " + pageNumbers.subSet(5, 10));

        // Give me all pages from 15 onwards
        System.out.println("Pages 15+: " + pageNumbers.tailSet(15));
    }
}

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

public class SetOperationsDemo {

    public static void main(String[] args) {

        // --- Pattern 1: Seen-set for deduplication in a stream ---
        System.out.println("=== Pattern 1: Deduplication Gate ===");
        Set<String> processedOrderIds = new HashSet<>();
        String[] incomingOrders = {"ORD-001", "ORD-002", "ORD-001", "ORD-003", "ORD-002"};

        for (String orderId : incomingOrders) {
            // add() returns false if already present — use that as a skip signal
            if (!processedOrderIds.add(orderId)) {
                System.out.println("Skipping duplicate order: " + orderId);
            } else {
                System.out.println("Processing new order: " + orderId);
            }
        }

        // --- Pattern 2: Set intersection — find common elements ---
        System.out.println("\n=== Pattern 2: Set Operations ===");

        // Permissions assigned to two different user roles
        Set<String> editorPermissions = new HashSet<>(
            Arrays.asList("read", "write", "comment", "upload")
        );
        Set<String> viewerPermissions = new HashSet<>(
            Arrays.asList("read", "comment")
        );

        // INTERSECTION — permissions that both roles share
        Set<String> sharedPermissions = new HashSet<>(editorPermissions);
        sharedPermissions.retainAll(viewerPermissions); // modifies in place — keep only what's in both
        System.out.println("Shared permissions: " + sharedPermissions); // [read, comment]

        // DIFFERENCE — permissions only editors have (not viewers)
        Set<String> editorOnlyPermissions = new HashSet<>(editorPermissions);
        editorOnlyPermissions.removeAll(viewerPermissions); // remove anything viewers also have
        System.out.println("Editor-only permissions: " + editorOnlyPermissions); // [write, upload]

        // UNION — all permissions across both roles combined (no duplicates)
        Set<String> allPermissions = new HashSet<>(editorPermissions);
        allPermissions.addAll(viewerPermissions); // adds only what's not already present
        System.out.println("All permissions (union): " + allPermissions); // [read, write, comment, upload]
    }
}

import java.util.HashSet;
import java.util.Set;

public class HashSetPreSizing {

    public static void main(String[] args) {
        int expectedSize = 1_000_000;
        // Calculate optimal initial capacity to avoid resizing
        int initialCapacity = (int)(expectedSize / 0.75f) + 1;
        
        long start = System.nanoTime();
        Set<Integer> sizedSet = new HashSet<>(initialCapacity);
        for (int i = 0; i < expectedSize; i++) {
            sizedSet.add(i);
        }
        long durationSized = System.nanoTime() - start;
        
        start = System.nanoTime();
        Set<Integer> defaultSet = new HashSet<>();
        for (int i = 0; i < expectedSize; i++) {
            defaultSet.add(i);
        }
        long durationDefault = System.nanoTime() - start;
        
        System.out.println("Pre-sized HashSet: " + durationSized / 1_000_000 + " ms");
        System.out.println("Default HashSet: " + durationDefault / 1_000_000 + " ms");
        // Pre-sizing typically cuts insertion time by 30-50% for large sets
    }
}

import java.util.*;

public class LoadFactorDemo {
    public static void main(String[] args) {
        // Bad: default capacity, causes multiple resizes
        long start = System.nanoTime();
        Set<Integer> badSet = new HashSet<>();
        for (int i = 0; i < 1_000_000; i++) badSet.add(i);
        System.out.println("Default took: " + (System.nanoTime() - start) / 1_000_000 + " ms");

        // Good: pre-sized to avoid resizing
        start = System.nanoTime();
        Set<Integer> goodSet = new HashSet<>((int)(1_000_000 / 0.75f) + 1);
        for (int i = 0; i < 1_000_000; i++) goodSet.add(i);
        System.out.println("Pre-sized took: " + (System.nanoTime() - start) / 1_000_000 + " ms");
    }
}

import java.util.*;

class BadKey {
    int id;
    BadKey(int id) { this.id = id; }
    public int hashCode() { return 42; } // All same bucket!
    public boolean equals(Object o) { return o instanceof BadKey && ((BadKey)o).id == this.id; }
}

public class CollisionDemo {
    public static void main(String[] args) {
        Set<BadKey> set = new HashSet<>();
        long start = System.nanoTime();
        for (int i = 0; i < 10_000; i++) set.add(new BadKey(i));
        System.out.println("Time for 10K with bad hash: " + (System.nanoTime() - start) / 1_000_000 + " ms");

        Set<Integer> goodSet = new HashSet<>();
        start = System.nanoTime();
        for (int i = 0; i < 10_000; i++) goodSet.add(i);
        System.out.println("Time for 10K with good hash: " + (System.nanoTime() - start) / 1_000_000 + " ms");
    }
}