What is the Java Collections Framework?

package com.bank.demo;

import java.math.BigDecimal;
import java.util.*;

public class CollectionsFrameworkDemo {
    public static void main(String[] args) {
        // List – ordered, allows duplicates
        List<String> accountNumbers = new ArrayList<>();
        accountNumbers.add("SAV2001");
        accountNumbers.add("CUR3001");
        accountNumbers.add("SAV2001"); // duplicate allowed
        System.out.println("List: " + accountNumbers);

        // Set – no duplicates
        Set<String> uniqueAccounts = new HashSet<>(accountNumbers);
        System.out.println("Set: " + uniqueAccounts);

        // Map – key-value pairs
        Map<String, BigDecimal> balances = new HashMap<>();
        balances.put("SAV2001", new BigDecimal("150000.00"));
        balances.put("CUR3001", new BigDecimal("75000.50"));
        System.out.println("Map: " + balances);

        // Queue – FIFO processing
        Queue<String> pendingTransfers = new LinkedList<>();
        pendingTransfers.offer("TXN-001");
        pendingTransfers.offer("TXN-002");
        System.out.println("Queue poll: " + pendingTransfers.poll());

        // Algorithm – sort
        Collections.sort(accountNumbers);
        System.out.println("Sorted: " + accountNumbers);
    }
}

List: [SAV2001, CUR3001, SAV2001]
Set: [CUR3001, SAV2001]
Map: {SAV2001=150000.00, CUR3001=75000.50}
Queue poll: TXN-001
Sorted: [CUR3001, SAV2001, SAV2001]

package com.bank.demo;

import java.util.*;

public class HierarchyDemo {
    public static void main(String[] args) {
        // Every Collection is Iterable – works with for-each
        List<String> accounts = List.of("SAV2001", "CUR3001", "FD4001");
        for (String acc : accounts) {
            System.out.println("Account: " + acc);
        }

        // Map is NOT a Collection
        Map<String, String> holders = Map.of("SAV2001", "Rajesh", "CUR3001", "Priya");
        // But you can iterate its entry set, which IS a Collection
        for (Map.Entry<String, String> entry : holders.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        // Checking the hierarchy at runtime
        System.out.println(accounts instanceof Collection);  // true
        System.out.println(accounts instanceof Iterable);    // true
        System.out.println(holders instanceof Collection);   // false
        System.out.println(holders instanceof Iterable);     // false
    }
}

Account: SAV2001
Account: CUR3001
Account: FD4001
SAV2001 -> Rajesh
CUR3001 -> Priya
true
true
false
false

package com.bank.service;

import java.math.BigDecimal;
import java.util.*;

public class ImplementationChoiceDemo {
    public static void main(String[] args) {
        // ArrayList – transaction log (ordered, random access)
        List<String> transactionLog = new ArrayList<>();
        transactionLog.add("TXN-001: Deposit 50000");
        transactionLog.add("TXN-002: Withdraw 10000");
        String latest = transactionLog.get(transactionLog.size() - 1);

        // HashSet – unique account number enforcement
        Set<String> activeAccounts = new HashSet<>();
        activeAccounts.add("SAV2001");
        boolean isNew = activeAccounts.add("SAV2001"); // false – already exists
        System.out.println("Added duplicate: " + isNew);

        // HashMap – instant balance lookup
        Map<String, BigDecimal> balances = new HashMap<>();
        balances.put("SAV2001", new BigDecimal("150000.00"));
        BigDecimal bal = balances.get("SAV2001"); // O(1)

        // PriorityQueue – high-value transactions processed first
        PriorityQueue<BigDecimal> priorityQueue = new PriorityQueue<>(
            Comparator.reverseOrder() // highest amount first
        );
        priorityQueue.offer(new BigDecimal("5000"));
        priorityQueue.offer(new BigDecimal("500000"));
        priorityQueue.offer(new BigDecimal("25000"));
        System.out.println("Highest priority: " + priorityQueue.poll());

        // TreeMap – sorted account listing for reports
        TreeMap<String, String> sortedAccounts = new TreeMap<>();
        sortedAccounts.put("FD4001", "Priya");
        sortedAccounts.put("CUR3001", "Rajesh");
        sortedAccounts.put("SAV2001", "Rajesh");
        System.out.println("Accounts in order: " + sortedAccounts.keySet());
    }
}

Added duplicate: false
Highest priority: 500000
Accounts in order: [CUR3001, FD4001, SAV2001]

package com.bank.service;

import java.math.BigDecimal;
import java.util.*;

public class AccountService {
    // Program to the interface – not the implementation
    private final Map<String, BigDecimal> balances;

    public AccountService() {
        // Today: HashMap (fast, not thread-safe)
        this.balances = new HashMap<>();
    }

    // Tomorrow: swap to ConcurrentHashMap in ONE line
    // this.balances = new ConcurrentHashMap<>();
    // Nothing else changes because the type is Map, not HashMap

    public void deposit(String accountId, BigDecimal amount) {
        balances.merge(accountId, amount, BigDecimal::add);
    }

    public BigDecimal getBalance(String accountId) {
        return balances.getOrDefault(accountId, BigDecimal.ZERO);
    }

    public static void main(String[] args) {
        AccountService service = new AccountService();
        service.deposit("SAV2001", new BigDecimal("50000.00"));
        service.deposit("SAV2001", new BigDecimal("25000.00"));
        System.out.println("Balance: " + service.getBalance("SAV2001"));
    }
}

Balance: 75000.00

package com.bank.demo;

import java.util.*;

public class CollectionVsCollections {
    public static void main(String[] args) {
        // Collection – the INTERFACE
        Collection<String> accounts = new ArrayList<>();
        accounts.add("SAV2001");
        accounts.add("CUR3001");

        // Collections – the UTILITY CLASS
        List<String> accountList = new ArrayList<>(accounts);
        Collections.sort(accountList);
        System.out.println("Sorted: " + accountList);

        List<String> readOnly = Collections.unmodifiableList(accountList);
        // readOnly.add("FD4001"); // throws UnsupportedOperationException

        int count = Collections.frequency(accountList, "SAV2001");
        System.out.println("Frequency of SAV2001: " + count);
    }
}

Sorted: [CUR3001, SAV2001]
Frequency of SAV2001: 1

package com.bank.demo;

import java.math.BigDecimal;
import java.util.*;

public class AlgorithmsDemo {
    public static void main(String[] args) {
        List<BigDecimal> transactions = new ArrayList<>(List.of(
            new BigDecimal("50000"),
            new BigDecimal("10000"),
            new BigDecimal("75000"),
            new BigDecimal("25000")
        ));

        // Sort – ascending order
        Collections.sort(transactions);
        System.out.println("Sorted: " + transactions);

        // Binary search – must be sorted first
        int index = Collections.binarySearch(transactions, new BigDecimal("50000"));
        System.out.println("Found 50000 at index: " + index);

        // Min and Max
        System.out.println("Min: " + Collections.min(transactions));
        System.out.println("Max: " + Collections.max(transactions));

        // Reverse
        Collections.reverse(transactions);
        System.out.println("Reversed: " + transactions);

        // Shuffle – random order (useful for lottery, random sampling)
        Collections.shuffle(transactions);
        System.out.println("Shuffled: " + transactions);

        // Unmodifiable wrapper – read-only view
        List<BigDecimal> readOnly = Collections.unmodifiableList(transactions);
        try {
            readOnly.add(new BigDecimal("999"));
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify: " + e.getClass().getSimpleName());
        }
    }
}

Sorted: [10000, 25000, 50000, 75000]
Found 50000 at index: 2
Min: 10000
Max: 75000
Reversed: [75000, 50000, 25000, 10000]
Shuffled: [25000, 75000, 10000, 50000]
Cannot modify: UnsupportedOperationException

package com.bank.demo;

import java.util.*;

public class FactoryMethodsDemo {
    public static void main(String[] args) {
        // Java 9: List.of – immutable list
        List<String> accounts = List.of("SAV2001", "CUR3001", "FD4001");
        System.out.println("Accounts: " + accounts);

        // Java 9: Set.of – immutable set, no duplicates
        Set<String> branches = Set.of("Mumbai", "Delhi", "Chennai");
        System.out.println("Branches: " + branches);

        // Java 9: Map.of – immutable map (up to 10 entries)
        Map<String, String> accountHolders = Map.of(
            "SAV2001", "Rajesh",
            "CUR3001", "Priya"
        );
        System.out.println("Holders: " + accountHolders);

        // Java 9: Map.ofEntries – for more than 10 entries
        Map<String, String> branches2 = Map.ofEntries(
            Map.entry("BR001", "Mumbai"),
            Map.entry("BR002", "Delhi"),
            Map.entry("BR003", "Chennai")
        );

        // Java 10: List.copyOf – immutable copy of existing collection
        List<String> mutable = new ArrayList<>(List.of("SAV2001", "CUR3001"));
        List<String> immutableCopy = List.copyOf(mutable);
        mutable.add("FD4001"); // original changes
        System.out.println("Mutable: " + mutable);
        System.out.println("Immutable copy: " + immutableCopy); // copy unchanged

        // Null not allowed
        try {
            List<String> bad = List.of("SAV2001", null);
        } catch (NullPointerException e) {
            System.out.println("Null rejected: " + e.getClass().getSimpleName());
        }

        // Duplicate set element not allowed
        try {
            Set<String> bad = Set.of("SAV2001", "SAV2001");
        } catch (IllegalArgumentException e) {
            System.out.println("Duplicate rejected: " + e.getMessage());
        }
    }
}

Accounts: [SAV2001, CUR3001, FD4001]
Branches: [Chennai, Delhi, Mumbai]
Holders: {CUR3001=Priya, SAV2001=Rajesh}
Mutable: [SAV2001, CUR3001, FD4001]
Immutable copy: [SAV2001, CUR3001]
Null rejected: NullPointerException
Duplicate rejected: duplicate element: SAV2001

package com.bank.demo;

import java.util.*;

public class LegacyVsModernDemo {
    public static void main(String[] args) {
        // BAD – legacy Vector (synchronized, slow)
        Vector<String> legacyAccounts = new Vector<>();
        legacyAccounts.add("SAV2001");

        // GOOD – modern ArrayList
        List<String> modernAccounts = new ArrayList<>();
        modernAccounts.add("SAV2001");

        // BAD – legacy Stack
        Stack<String> legacyStack = new Stack<>();
        legacyStack.push("TXN-001");

        // GOOD – modern ArrayDeque as stack
        Deque<String> modernStack = new ArrayDeque<>();
        modernStack.push("TXN-001");
        System.out.println("Stack pop: " + modernStack.pop());

        // BAD – legacy Hashtable
        Hashtable<String, String> legacyMap = new Hashtable<>();
        // legacyMap.put("SAV2001", null); // NullPointerException!

        // GOOD – modern HashMap (allows null values)
        Map<String, String> modernMap = new HashMap<>();
        modernMap.put("SAV2001", null); // OK
    }
}

Stack pop: TXN-001

package com.bank.demo;

import java.util.*;

public class ConcurrentModificationDemo {
    public static void main(String[] args) {
        List<String> accounts = new ArrayList<>(List.of("SAV2001", "CUR3001", "FD4001"));

        // WRONG – modifying during enhanced for-loop
        try {
            for (String acc : accounts) {
                if (acc.startsWith("CUR")) {
                    accounts.remove(acc); // ConcurrentModificationException!
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Error: " + e.getClass().getSimpleName());
        }

        // CORRECT – use Iterator.remove()
        accounts = new ArrayList<>(List.of("SAV2001", "CUR3001", "FD4001"));
        Iterator<String> it = accounts.iterator();
        while (it.hasNext()) {
            if (it.next().startsWith("CUR")) {
                it.remove(); // safe removal
            }
        }
        System.out.println("After removal: " + accounts);

        // CORRECT – use removeIf (Java 8+)
        accounts = new ArrayList<>(List.of("SAV2001", "CUR3001", "FD4001"));
        accounts.removeIf(acc -> acc.startsWith("CUR"));
        System.out.println("After removeIf: " + accounts);
    }
}

Error: ConcurrentModificationException
After removal: [SAV2001, FD4001]
After removeIf: [SAV2001, FD4001]

package com.bank.demo;

import java.util.*;

public class MutableKeyDemo {
    static class Account {
        String id;
        Account(String id) { this.id = id; }
        @Override public int hashCode() { return id.hashCode(); }
        @Override public boolean equals(Object o) {
            return o instanceof Account a && a.id.equals(this.id);
        }
    }

    public static void main(String[] args) {
        Map<Account, String> map = new HashMap<>();
        Account acc = new Account("SAV2001");
        map.put(acc, "Rajesh");
        System.out.println("Before mutation: " + map.get(acc));

        // WRONG – mutating the key after insertion
        acc.id = "CUR3001"; // hashCode changes!
        System.out.println("After mutation: " + map.get(acc)); // null! Lost forever
        System.out.println("Map size: " + map.size()); // still 1, but unreachable
    }
}

Before mutation: Rajesh
After mutation: null
Map size: 1

package com.bank.service;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.*;

public class ThreadSafeCollectionDemo {
    public static void main(String[] args) {
        // Option 1: Synchronized wrapper
        Map<String, BigDecimal> syncMap =
            Collections.synchronizedMap(new HashMap<>());
        syncMap.put("SAV2001", new BigDecimal("50000"));

        // IMPORTANT: iteration still needs external sync
        synchronized (syncMap) {
            for (var entry : syncMap.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }

        // Option 2: Concurrent collection (preferred)
        ConcurrentHashMap<String, BigDecimal> concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("SAV2001", new BigDecimal("50000"));
        // No external synchronization needed for iteration
        concurrentMap.forEach((k, v) -> System.out.println(k + ": " + v));

        // Atomic operations on ConcurrentHashMap
        concurrentMap.merge("SAV2001", new BigDecimal("10000"), BigDecimal::add);
        System.out.println("After merge: " + concurrentMap.get("SAV2001"));

        // Option 3: CopyOnWriteArrayList for read-heavy scenarios
        List<String> listeners = new CopyOnWriteArrayList<>();
        listeners.add("AuditListener");
        listeners.add("NotificationListener");
        // Safe to iterate while another thread adds/removes
    }
}

SAV2001: 50000
SAV2001: 50000
After merge: 60000

package com.bank.demo;

import java.util.*;

public class PerformanceDemo {
    public static void main(String[] args) {
        int size = 100_000;

        // ArrayList – fast random access
        List<String> arrayList = new ArrayList<>();
        for (int i = 0; i < size; i++) arrayList.add("ACC" + i);
        long start = System.nanoTime();
        String item = arrayList.get(50_000); // O(1)
        long elapsed = System.nanoTime() - start;
        System.out.println("ArrayList.get(50000): " + elapsed + " ns");

        // HashSet – fast contains
        Set<String> hashSet = new HashSet<>(arrayList);
        start = System.nanoTime();
        boolean found = hashSet.contains("ACC50000"); // O(1)
        elapsed = System.nanoTime() - start;
        System.out.println("HashSet.contains: " + elapsed + " ns");

        // ArrayList.contains – slow (O(n) scan)
        start = System.nanoTime();
        found = arrayList.contains("ACC50000"); // O(n)!
        elapsed = System.nanoTime() - start;
        System.out.println("ArrayList.contains: " + elapsed + " ns");
    }
}