Java ArrayList Explained — How It Works, When to Use It, and What to Watch Out For

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

public class GuestListDemo {

    public static void main(String[] args) {

        // Program to the List interface — not ArrayList directly.
        // This keeps your code flexible if you need to swap implementations later.
        List<String> guestList = new ArrayList<>();

        // add() appends to the end of the list — O(1) amortised time
        guestList.add("Alice");
        guestList.add("Bob");
        guestList.add("Charlie");

        // add(index, element) inserts at a specific position — O(n) because
        // everything after that index has to shift one spot to the right
        guestList.add(1, "Zara");  // Zara goes between Alice and Bob

        System.out.println("Guest list: " + guestList);
        System.out.println("Number of guests: " + guestList.size());

        // get(index) retrieves by position — O(1), same speed as a plain array
        String firstGuest = guestList.get(0);
        System.out.println("First guest: " + firstGuest);

        // contains() checks if a value exists — O(n) linear scan under the hood
        boolean isInvited = guestList.contains("Bob");
        System.out.println("Is Bob invited? " + isInvited);
    }
}

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

public class ResizingDemo {

    public static void main(String[] args) {

        // --- Scenario 1: No initial capacity hint ---
        // ArrayList starts with internal array of size 10.
        // Every time we exceed capacity, it resizes (copies everything).
        long startTime = System.nanoTime();

        List<Integer> productIds = new ArrayList<>();
        for (int i = 0; i < 100_000; i++) {
            productIds.add(i);  // triggers multiple internal resizes
        }

        long durationWithoutHint = System.nanoTime() - startTime;

        // --- Scenario 2: With initial capacity hint ---
        // We tell ArrayList we expect ~100,000 items.
        // It allocates space upfront — zero resize operations.
        startTime = System.nanoTime();

        List<Integer> productIdsOptimised = new ArrayList<>(100_000);
        for (int i = 0; i < 100_000; i++) {
            productIdsOptimised.add(i);  // no resizing, just writing into pre-allocated space
        }

        long durationWithHint = System.nanoTime() - startTime;

        System.out.println("Without capacity hint: " + durationWithoutHint / 1_000_000 + " ms");
        System.out.println("With capacity hint:    " + durationWithHint / 1_000_000 + " ms");

        // trimToSize() releases any unused allocated slots — useful after
        // you've finished building a list that will now be read-only
        ((ArrayList<Integer>) productIdsOptimised).trimToSize();
        System.out.println("Memory trimmed. List size: " + productIdsOptimised.size());
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

public class OrderProcessing {

    record Order(String id, String status, double amount) {}

    public static void main(String[] args) {

        List<Order> orders = new ArrayList<>();
        orders.add(new Order("ORD-001", "PENDING",  149.99));
        orders.add(new Order("ORD-002", "SHIPPED",   59.00));
        orders.add(new Order("ORD-003", "PENDING",  299.50));
        orders.add(new Order("ORD-004", "CANCELLED", 25.00));
        orders.add(new Order("ORD-005", "SHIPPED",  179.99));

        // --- Pattern 1: Enhanced for-loop (read-only) ---
        System.out.println("All orders:");
        for (Order order : orders) {
            System.out.println("  " + order.id() + " — " + order.status());
        }

        // --- Pattern 2: removeIf — safe removal during iteration ---
        // DO NOT call orders.remove() inside a for-each loop.
        // removeIf handles the iterator internally and avoids ConcurrentModificationException.
        orders.removeIf(order -> order.status().equals("CANCELLED"));
        System.out.println("\nAfter removing cancelled orders: " + orders.size() + " remaining");

        // --- Pattern 3: Sort by amount descending ---
        orders.sort(Comparator.comparingDouble(Order::amount).reversed());
        System.out.println("\nOrders by value (highest first):");
        for (Order order : orders) {
            System.out.printf("  %s  $%.2f%n", order.id(), order.amount());
        }

        // --- Pattern 4: Stream to filter into a new list ---
        // The original list is untouched — stream produces a fresh collection
        List<Order> pendingOrders = orders.stream()
                .filter(order -> order.status().equals("PENDING"))
                .collect(Collectors.toList());

        System.out.println("\nPending orders only:");
        pendingOrders.forEach(o -> System.out.println("  " + o.id() + "  $" + o.amount()));
    }
}

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

public class CollectionComparison {

    public static void main(String[] args) {

        int iterations = 50_000;

        // --- ArrayList: fast random access, slower mid-list insert ---
        List<String> arrayList = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            // Inserting at index 0 forces everything else to shift right — O(n) each time
            arrayList.add(0, "Task-" + i);
        }
        long arrayListInsertTime = System.nanoTime() - start;

        // --- LinkedList: fast front/back insert, slow random access ---
        List<String> linkedList = new LinkedList<>();
        start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            // addFirst() is O(1) — just rewire the head pointer, no shifting
            ((LinkedList<String>) linkedList).addFirst("Task-" + i);
        }
        long linkedListInsertTime = System.nanoTime() - start;

        System.out.println("Inserting " + iterations + " items at the front:");
        System.out.println("  ArrayList:   " + arrayListInsertTime / 1_000_000 + " ms  ← lots of shifting");
        System.out.println("  LinkedList:  " + linkedListInsertTime / 1_000_000 + " ms  ← just pointer rewiring");

        // Now show the flip side: random access
        start = System.nanoTime();
        String ignored1 = arrayList.get(iterations / 2);  // O(1) — direct index jump
        long arrayListGetTime = System.nanoTime() - start;

        start = System.nanoTime();
        String ignored2 = linkedList.get(iterations / 2);  // O(n) — walks the chain
        long linkedListGetTime = System.nanoTime() - start;

        System.out.println("\nRandom access (middle element):");
        System.out.println("  ArrayList:   " + arrayListGetTime + " ns  ← direct jump");
        System.out.println("  LinkedList:  " + linkedListGetTime + " ns  ← walked the chain");
    }
}