// Stack: Last-In-First-Out (LIFO)
// Queue: First-In-First-Out (FIFO)
// Array: Fast access, slow insertion/deletion
// Linked List: Slow access, fast insertion/deletion
// Red-Black Tree: Efficient search (binary search principle)

Collection Interface

public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> names = new ArrayList<>();
        names.add("Alex");
        names.add("Taylor");
        names.add("Alex");
        names.add("Jordan");
        System.out.println(names);

        // Collection methods
        if (names.contains("Alex")) {
            names.remove("Alex");
        }
        System.out.println(names);
        
        // Enhanced for loop
        for (String name : names) {
            System.out.println(name);
        }
    }
}

Card Game Implementation

public class CardGame {
    public static void main(String[] args) {
        String[] special = {"Joker", "Ace"};
        String[] suits = {"♠", "♥", "♣", "♦"};
        String[] ranks = {"A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3", "2"};
        
        List<String> deck = new ArrayList<>();
        deck.add(special[0]);
        deck.add(special[1]);
        
        for (String rank : ranks) {
            for (String suit : suits) {
                deck.add(rank + suit);
            }
        }
        
        Map<Integer, String> cardMap = new HashMap<>();
        List<Integer> indices = new ArrayList<>();
        
        for (int i = 0; i < deck.size(); i++) {
            indices.add(i);
            cardMap.put(i, deck.get(i));
        }
        
        Collections.shuffle(indices);
        
        List<Integer> player1 = new ArrayList<>();
        List<Integer> player2 = new ArrayList<>();
        List<Integer> player3 = new ArrayList<>();
        List<Integer> community = new ArrayList<>();
        
        for (int i = 0; i < indices.size(); i++) {
            if (i >= 51) {
                community.add(indices.get(i));
            } else {
                switch (i % 3) {
                    case 0: player1.add(indices.get(i)); break;
                    case 1: player2.add(indices.get(i)); break;
                    case 2: player3.add(indices.get(i)); break;
                }
            }
        }
        
        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);
        Collections.sort(community);
        
        System.out.println("Player 1: " + mapCards(player1, cardMap));
        System.out.println("Player 2: " + mapCards(player2, cardMap));
        System.out.println("Player 3: " + mapCards(player3, cardMap));
        System.out.println("Community: " + mapCards(community, cardMap));
    }
    
    private static List<String> mapCards(List<Integer> indices, Map<Integer, String> cardMap) {
        return indices.stream().map(cardMap::get).collect(Collectors.toList());
    }
}

List and Set Implementations

// ArrayList demonstration
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(1, 15);
numbers.remove(2);
numbers.set(1, 25);
System.out.println(numbers.get(1));

// HashSet demonstration
Set<Integer> uniqueNumbers = new HashSet<>();
uniqueNumbers.add(5);
uniqueNumbers.add(3);
uniqueNumbers.add(5);
uniqueNumbers.add(1);
System.out.println(uniqueNumbers);

// LinkedHashSet maintains insertion order
Set<Integer> orderedSet = new LinkedHashSet<>();
orderedSet.add(5);
orderedSet.add(3);
orderedSet.add(1);
System.out.println(orderedSet);

Colections Utility Class

List<Integer> values = new ArrayList<>();
values.add(7);
values.add(3);
values.add(9);

Collections.addAll(values, 5, 1, 8);
Collections.sort(values);
System.out.println(values);

Collections.sort(values, (a, b) -> b - a);
System.out.println(values);

Collections.shuffle(values);
System.out.println(values);

Map Interfaec

Map<Integer, String> employees = new HashMap<>();
employees.put(101, "Emma");
employees.put(102, "Liam");
employees.put(103, "Olivia");
employees.put(101, "Noah"); // Overwrites previous entry

// Map iteration
employees.keySet().forEach(id -> 
    System.out.println(id + ": " + employees.get(id)));
    
// Entry-based iteration
employees.entrySet().forEach(entry ->
    System.out.println(entry.getKey() + ":" + entry.getValue()));

Character Frequency Analysis

String input = "programming";
Map<Character, Integer> frequency = new HashMap<>();

for (char c : input.toCharArray()) {
    frequency.put(c, frequency.getOrDefault(c, 0) + 1);
}

frequency.forEach((character, count) ->
    System.out.println(character + ": " + count));

Immutable Colelctions

List<String> fixedList = List.of("Java", "Kotlin", "Scala");
Set<Integer> fixedSet = Set.of(10, 20, 30);
Map<String, Integer> fixedMap = Map.of("One", 1, "Two", 2);

// These collections are immutable - modification operations throw exceptions