21. జావా కలెక్షన్స్ ఫ్రేమ్‌వర్క్ — List, ArrayList & LinkedList (Collections Mastery)

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ArrayListVsLinkedListBenchmark {
    public static void main(String[] args) {
        final int ELEMENTS_COUNT = 50_000;

        System.out.println("=================================================");
        System.out.println("⚡ ARRAYLIST VS LINKEDLIST PERFORMANCE SHOWDOWN");
        System.out.println("=================================================
");

        // TEST 1: INSERTION AT HEAD (index 0)
        List<Integer> arrayList = new ArrayList<>();
        long startAl = System.currentTimeMillis();
        for (int i = 0; i < ELEMENTS_COUNT; i++) {
            arrayList.add(0, i); // Constant shifting of all elements!
        }
        long alInsertTime = System.currentTimeMillis() - startAl;

        List<Integer> linkedList = new LinkedList<>();
        long startLl = System.currentTimeMillis();
        for (int i = 0; i < ELEMENTS_COUNT; i++) {
            linkedList.add(0, i); // O(1) Pointer rewiring!
        }
        long llInsertTime = System.currentTimeMillis() - startLl;

        System.out.println("1. Head Insertion Benchmark (50,000 elements at index 0):");
        System.out.printf("   ArrayList  Insert(0):  %5d ms (Slow due to shifting)%n", alInsertTime);
        System.out.printf("   LinkedList Insert(0):  %5d ms (Fast pointer rewire)%n", llInsertTime);

        // TEST 2: RANDOM ACCESS LOOKUP (get(i))
        long startAlGet = System.nanoTime();
        int val1 = arrayList.get(25000); // Direct memory offset calculation
        long alGetTime = System.nanoTime() - startAlGet;

        long startLlGet = System.nanoTime();
        int val2 = linkedList.get(25000); // Traverses 25,000 node pointers!
        long llGetTime = System.nanoTime() - startLlGet;

        System.out.println("
2. Random Access Benchmark (get(25000) from middle):");
        System.out.printf("   ArrayList  get(25000): %5d ns (O(1) Instant Lookup)%n", alGetTime);
        System.out.printf("   LinkedList get(25000): %5d ns (O(N) Sequential Walk)%n", llGetTime);

        System.out.println("
=================================================");
        System.out.println("✅ Verdict: ArrayList wins 95% of cases; LinkedList only for Queue/Deque!");
        System.out.println("=================================================");
    }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorFailFastSafeRemovalDemo {
    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("🛡️ ITERATOR FAIL-FAST VS SAFE REMOVAL DEMO");
        System.out.println("=================================================
");

        List<String> badList = new ArrayList<>(List.of("Apple", "Banana", "Cherry", "Date"));

        // 1. Unsafe Removal triggering ConcurrentModificationException
        System.out.println("1. Attempting list.remove() inside enhanced for-each loop...");
        try {
            for (String fruit : badList) {
                if (fruit.equals("Banana")) {
                    badList.remove(fruit); // ❌ Unsafe removal alters modCount!
                }
            }
        } catch (Exception e) {
            System.out.println("   🚨 CRASH CAUGHT: " + e.getClass().getName());
        }

        // 2. Safe Removal using Iterator
        System.out.println("
2. Performing Safe Removal using Iterator.remove()...");
        List<String> safeList = new ArrayList<>(List.of("Apple", "Banana", "Cherry", "Date"));
        Iterator<String> it = safeList.iterator();

        while (it.hasNext()) {
            String fruit = it.next();
            if (fruit.equals("Banana")) {
                it.remove(); // ✅ Safe removal maintains synchrony!
                System.out.println("   Removed: " + fruit);
            }
        }
        System.out.println("   Final Safe List: " + safeList);

        // 3. Modern Java 8 removeIf() idiom
        System.out.println("
3. Modern Java 8 list.removeIf() idiom:");
        List<String> modernList = new ArrayList<>(List.of("Java", "C++", "Python", "Rust"));
        modernList.removeIf(lang -> lang.startsWith("C"));
        System.out.println("   Final List without 'C': " + modernList);

        System.out.println("
=================================================");
        System.out.println("=================================================");
    }
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class EcommerceOrderFulfillmentEngine {

    public record CustomerOrder(String orderId, String customer, double amount, boolean isPriority) {}

    public static class WarehouseFulfillmentCenter {
        // LinkedList used as efficient FIFO Processing Queue (O(1) poll from head)
        private final LinkedList<CustomerOrder> dispatchQueue = new LinkedList<>();
        // ArrayList used for fast indexed completed ledger lookups (O(1) random access)
        private final ArrayList<CustomerOrder> completedLedger = new ArrayList<>();

        public void receiveOrder(CustomerOrder order) {
            if (order.isPriority()) {
                dispatchQueue.addFirst(order); // VIP express order pushed to front!
                System.out.println("⚡ [PRIORITY EXPRESS] Order pushed to FRONT: " + order.orderId());
            } else {
                dispatchQueue.addLast(order); // Standard order queued at back
                System.out.println("📦 [STANDARD QUEUED] Order added to back:   " + order.orderId());
            }
        }

        public void processNextOrder() {
            if (dispatchQueue.isEmpty()) {
                System.out.println("ℹ️ No pending orders to fulfill.");
                return;
            }
            CustomerOrder processed = dispatchQueue.removeFirst(); // O(1) removal from head
            completedLedger.add(processed); // O(1) append to ledger
            System.out.printf("  🚚 Dispatched: [%s] to %s (₹%,.2f)%n",
                    processed.orderId(), processed.customer(), processed.amount());
        }

        public void printWarehouseStatus() {
            System.out.println("
-------------------------------------------------");
            System.out.println("🏭 WAREHOUSE FULFILLMENT TELEMETRY METRICS");
            System.out.println("   Pending in Queue (LinkedList):  " + dispatchQueue.size());
            System.out.println("   Completed Ledger (ArrayList):   " + completedLedger.size());
            System.out.println("-------------------------------------------------");
        }
    }

    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("🛒 E-COMMERCE WAREHOUSE ORDER PIPELINE");
        System.out.println("=================================================
");

        WarehouseFulfillmentCenter warehouse = new WarehouseFulfillmentCenter();

        warehouse.receiveOrder(new CustomerOrder("ORD-101", "Balaji", 2500.0, false));
        warehouse.receiveOrder(new CustomerOrder("ORD-102", "Suresh", 1200.0, false));
        // Priority order skips the line!
        warehouse.receiveOrder(new CustomerOrder("ORD-VIP-999", "Karthik Verma", 85000.0, true));

        System.out.println("
Processing Warehouse Dispatch Queue:");
        warehouse.processNextOrder(); // Should process VIP-999 first!
        warehouse.processNextOrder(); // Processes ORD-101
        warehouse.processNextOrder(); // Processes ORD-102

        warehouse.printWarehouseStatus();

        System.out.println("=================================================");
    }
}