Java Collections Interview Questions — What Senior Devs Actually Ask

import java.util.*;

public class CollectionHierarchyDemo {

    public static void main(String[] args) {

        // Always program to the interface (List), not the implementation (ArrayList).
        // This means you can swap to LinkedList later with ONE word change.
        List<String> festivalLineup = new ArrayList<>();
        festivalLineup.add("Arctic Monkeys");
        festivalLineup.add("Kendrick Lamar");
        festivalLineup.add("Arctic Monkeys"); // duplicates ARE allowed in List
        System.out.println("Lineup (List allows duplicates): " + festivalLineup);

        // Set enforces uniqueness automatically — no extra if-checks needed.
        Set<String> uniqueArtists = new HashSet<>(festivalLineup);
        System.out.println("Unique artists (Set removes dupes): " + uniqueArtists);

        // Map is NOT a Collection — note it doesn't extend Collection at all.
        Map<String, String> wristbandAccess = new HashMap<>();
        wristbandAccess.put("RED", "Backstage");
        wristbandAccess.put("BLUE", "General Admission");
        wristbandAccess.put("GREEN", "VIP Lounge");

        // O(1) average lookup — this is why you use Map instead of searching a List.
        String accessLevel = wristbandAccess.get("RED");
        System.out.println("RED wristband grants: " + accessLevel);

        // Proving Map is NOT a Collection
        System.out.println("Is HashMap a Collection? " +
            (wristbandAccess instanceof Collection)); // false!
    }
}

import java.util.*;

public class CollectionChoiceDemo {

    public static void main(String[] args) {

        // --- ArrayList: best for indexed reads, rare insertions ---
        List<String> ticketQueue = new ArrayList<>();
        ticketQueue.add("Alice");
        ticketQueue.add("Bob");
        ticketQueue.add("Charlie");

        // O(1) random access by index — this is ArrayList's superpower.
        String headliner = ticketQueue.get(0);
        System.out.println("First in queue: " + headliner);

        // --- HashMap: best for key-based lookup ---
        Map<String, Integer> artistTicketsSold = new HashMap<>();
        artistTicketsSold.put("Arctic Monkeys", 45000);
        artistTicketsSold.put("Kendrick Lamar", 62000);
        artistTicketsSold.put("Billie Eilish", 58000);

        // O(1) average lookup — no looping required.
        int kendrickSales = artistTicketsSold.get("Kendrick Lamar");
        System.out.println("Kendrick tickets sold: " + kendrickSales);

        // --- LinkedHashMap: when insertion order matters for reports ---
        Map<String, Integer> orderedSales = new LinkedHashMap<>();
        orderedSales.put("Friday", 12000);
        orderedSales.put("Saturday", 28000);
        orderedSales.put("Sunday", 19000);

        // Iterates in the order we inserted — HashMap would NOT guarantee this.
        System.out.println("Daily sales in order:");
        orderedSales.forEach((day, sales) ->
            System.out.println("  " + day + " -> " + sales + " tickets"));

        // --- TreeMap: when you need keys sorted ---
        Map<String, Integer> sortedArtists = new TreeMap<>(artistTicketsSold);
        System.out.println("Artists sorted alphabetically: " + sortedArtists.keySet());
    }
}

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class IteratorSafetyDemo {

    public static void main(String[] args) {

        List<String> performers = new ArrayList<>(
            Arrays.asList("Arctic Monkeys", "CANCELLED_ACT", "Billie Eilish",
                          "CANCELLED_ACT", "Kendrick Lamar")
        );

        // --- WRONG: This throws ConcurrentModificationException ---
        // Uncomment to see the crash:
        // for (String performer : performers) {
        //     if (performer.startsWith("CANCELLED")) {
        //         performers.remove(performer); // modCount mismatch -> BOOM
        //     }
        // }

        // --- CORRECT approach 1: Iterator.remove() ---
        Iterator<String> iterator = performers.iterator();
        while (iterator.hasNext()) {
            String performer = iterator.next();
            if (performer.startsWith("CANCELLED")) {
                // iterator.remove() updates modCount correctly — no exception.
                iterator.remove();
            }
        }
        System.out.println("After safe removal: " + performers);

        // --- CORRECT approach 2: removeIf() — cleaner, Java 8+ ---
        List<String> backup = new ArrayList<>(
            Arrays.asList("Arctic Monkeys", "CANCELLED_ACT", "Billie Eilish")
        );
        backup.removeIf(p -> p.startsWith("CANCELLED")); // internally uses Iterator.remove()
        System.out.println("After removeIf: " + backup);

        // --- Fail-SAFE: CopyOnWriteArrayList for read-heavy concurrent use ---
        List<String> safeList = new CopyOnWriteArrayList<>(
            Arrays.asList("Fan1", "Fan2", "Fan3")
        );
        for (String fan : safeList) {
            // Iterating over a snapshot — adding here does NOT throw.
            safeList.add("NewFan"); // writes copy the array; iterator sees original snapshot
            System.out.println("Processing: " + fan);
            break; // just showing the concept, not looping forever
        }
        System.out.println("CopyOnWriteArrayList size after concurrent add: " + safeList.size());
    }
}

import java.util.*;

public class HashMapInternalsDemo {

    // A proper key class — overrides BOTH hashCode AND equals.
    // Without both, HashMap breaks in subtle, hard-to-debug ways.
    static class VenueSection {
        private final String zone;
        private final int row;

        VenueSection(String zone, int row) {
            this.zone = zone;
            this.row = row;
        }

        @Override
        public int hashCode() {
            // Objects.hash() computes a combined hash — always use this pattern.
            return Objects.hash(zone, row);
        }

        @Override
        public boolean equals(Object other) {
            if (this == other) return true;
            if (!(other instanceof VenueSection)) return false;
            VenueSection that = (VenueSection) other;
            // Two sections are equal if BOTH zone AND row match.
            return Objects.equals(this.zone, that.zone) && this.row == that.row;
        }

        @Override
        public String toString() {
            return zone + "-Row" + row;
        }
    }

    public static void main(String[] args) {

        Map<VenueSection, String> seatAssignments = new HashMap<>();

        VenueSection frontLeft  = new VenueSection("Left", 1);
        VenueSection frontRight = new VenueSection("Right", 1);

        seatAssignments.put(frontLeft,  "Alice");
        seatAssignments.put(frontRight, "Bob");

        // Creating a NEW object with same data — should find Alice if equals/hashCode correct.
        VenueSection lookupKey = new VenueSection("Left", 1);
        String occupant = seatAssignments.get(lookupKey);
        System.out.println("Occupant of Left-Row1: " + occupant);
        // Without hashCode override, this would print: null (wrong bucket looked up)
        // Without equals override, this would print: null (bucket found, but equals fails)

        // Demonstrating default capacity and load factor
        // HashMap starts with 16 buckets, load factor 0.75
        // It resizes (doubles) when entries > 16 * 0.75 = 12
        Map<String, Integer> capacityDemo = new HashMap<>(32, 0.75f);
        // Providing initial capacity avoids expensive resizes for known-size data.
        System.out.println("Pre-sized map created with capacity 32.");

        // getOrDefault — cleaner than null-checking get() results
        String vipOccupant = seatAssignments.getOrDefault(
            new VenueSection("VIP", 1), "Empty seat"
        );
        System.out.println("VIP-Row1 occupant: " + vipOccupant);
    }
}