import java.util.*;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建
        List<String> list = new ArrayList<>();
        List<String> fixed = List.of("A", "B", "C");     // 不可变
        List<String> copied = List.copyOf(fixed);         // 不可变副本

        // 添加
        list.add("张三");
        list.add("李四");
        list.add(0, "王五");  // 指定位置插入
        list.addAll(List.of("赵六", "钱七"));

        // 访问
        System.out.println(list.get(0));       // 王五
        System.out.println(list.size());       // 5
        System.out.println(list.indexOf("李四")); // 2
        System.out.println(list.contains("张三")); // true

        // 修改
        list.set(0, "老王");

        // 删除
        list.remove("李四");         // 按对象删除
        list.remove(0);              // 按索引删除
        list.removeIf(s -> s.startsWith("赵"));  // 条件删除

        // 排序
        list.sort(Comparator.naturalOrder());
        list.sort(Comparator.reverseOrder());
        list.sort(Comparator.comparingInt(String::length));

        // 遍历
        for (String s : list) System.out.println(s);
        list.forEach(System.out::println);

        // 转换
        String[] arr = list.toArray(new String[0]);
        List<String> sub = list.subList(0, 2);  // 视图，非副本
    }
}

import java.util.*;

public class SetDemo {
    public static void main(String[] args) {
        // HashSet —— 基于 HashMap，O(1) 操作
        Set<String> hashSet = new HashSet<>();
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("张三");  // 重复，不添加
        System.out.println(hashSet.size());  // 2
        System.out.println(hashSet.contains("张三")); // true

        // LinkedHashSet —— 保持插入顺序
        Set<String> linkedSet = new LinkedHashSet<>();
        linkedSet.add("C"); linkedSet.add("A"); linkedSet.add("B");
        System.out.println(linkedSet);  // [C, A, B]

        // TreeSet —— 自然排序，红黑树实现
        Set<String> treeSet = new TreeSet<>();
        treeSet.add("C"); treeSet.add("A"); treeSet.add("B");
        System.out.println(treeSet);  // [A, B, C]

        // 集合运算
        Set<Integer> a = Set.of(1, 2, 3, 4);
        Set<Integer> b = Set.of(3, 4, 5, 6);

        // 并集
        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);
        System.out.println("并集: " + union);  // [1, 2, 3, 4, 5, 6]

        // 交集
        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);
        System.out.println("交集: " + intersection);  // [3, 4]

        // 差集
        Set<Integer> diff = new HashSet<>(a);
        diff.removeAll(b);
        System.out.println("差集: " + diff);  // [1, 2]
    }
}

import java.util.*;

public class MapDemo {
    public static void main(String[] args) {
        // 创建
        Map<String, Integer> scores = new HashMap<>();
        scores.put("张三", 90);
        scores.put("李四", 85);
        scores.put("王五", 92);

        // 访问
        int zhangScore = scores.get("张三");           // 90
        int defaultScore = scores.getOrDefault("赵六", 0);  // 0
        System.out.println("包含张三: " + scores.containsKey("张三"));
        System.out.println("包含90: " + scores.containsValue(90));

        // 遍历
        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        scores.forEach((k, v) -> System.out.println(k + " -> " + v));

        // Java 8 新方法
        scores.putIfAbsent("赵六", 88);  // 不存在才添加
        scores.merge("张三", 5, Integer::sum);  // 张三: 90+5=95
        scores.compute("李四", (k, v) -> v == null ? 0 : v + 10); // 李四: 95

        // 排序
        Map<String, Integer> sorted = new TreeMap<>(scores);  // 按 key 排序
        scores.entrySet().stream()
            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
            .forEach(e -> System.out.println(e.getKey() + ": " + e.getValue()));

        // 不可变 Map
        Map<String, Integer> immutable = Map.of("A", 1, "B", 2, "C", 3);
        Map<String, Integer> copied = Map.copyOf(scores);
    }
}

import java.util.*;

public class QueueDemo {
    public static void main(String[] args) {
        // ArrayDeque —— 双端队列（推荐作栈和队列）
        Deque<String> deque = new ArrayDeque<>();
        deque.offerFirst("A");  // 头部入队
        deque.offerLast("B");   // 尾部入队
        deque.offerLast("C");
        System.out.println(deque.peekFirst());  // A
        System.out.println(deque.peekLast());   // C
        deque.pollFirst();  // 移除 A

        // 用作栈
        Deque<String> stack = new ArrayDeque<>();
        stack.push("第一层");
        stack.push("第二层");
        stack.push("第三层");
        System.out.println(stack.pop());   // 第三层（LIFO）
        System.out.println(stack.peek());  // 第二层

        // PriorityQueue —— 优先队列（最小堆）
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
        minHeap.offer(5); minHeap.offer(1); minHeap.offer(3);
        System.out.println(minHeap.poll());  // 1（最小值先出）
        System.out.println(minHeap.poll());  // 3

        // 最大堆
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
        maxHeap.offer(5); maxHeap.offer(1); maxHeap.offer(3);
        System.out.println(maxHeap.poll());  // 5（最大值先出）
    }
}

import java.util.*;

public class ImmutableCollections {
    public static void main(String[] args) {
        // List 不可变
        List<String> list = List.of("A", "B", "C");
        // list.add("D");  // ❌ UnsupportedOperationException

        // Set 不可变
        Set<Integer> set = Set.of(1, 2, 3);

        // Map 不可变（最多 10 个键值对）
        Map<String, Integer> map = Map.of("one", 1, "two", 2, "three", 3);

        // 更多键值对用 Map.ofEntries
        Map<String, Integer> bigMap = Map.ofEntries(
            Map.entry("A", 1),
            Map.entry("B", 2),
            Map.entry("C", 3)
        );

        // 从可变集合创建不可变副本
        List<String> mutable = new ArrayList<>(list);
        List<String> immutable = List.copyOf(mutable);
    }
}