import java.util.*;

public class CollectionBasicOps {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        // 1. 添加：add 返回 boolean，Set 用它表示「是否真的加入了新元素」
        boolean added = c.add("Java");
        c.add("Kotlin");
        System.out.println("add 返回: " + added);

        // 2. 数量与判空
        System.out.println("size = " + c.size() + ", isEmpty = " + c.isEmpty());

        // 3. 包含判断：底层依赖元素的 equals 方法
        System.out.println("contains Java? " + c.contains("Java"));

        // 4. 删除：只删第一个匹配项，同样依赖 equals
        c.remove("Kotlin");

        // 5. 转数组：强烈建议传入正确类型与长度的数组，避免浪费一次反射创建
        String[] arr = c.toArray(new String[0]);
        System.out.println(Arrays.toString(arr));

        // 6. 清空：只是把元素置 null 并 size=0，底层数组不会被回收（ArrayList 行为）
        c.clear();
    }
}

import java.util.*;

public class AsListTrap {
    public static void main(String[] args) {
        String[] src = {"Java", "Go", "Rust"};
        List<String> list = Arrays.asList(src);

        // 1. 长度固定：底层是数组，无法扩容
        try {
            list.add("Python");   // 抛 UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("add 失败: " + e.getClass().getSimpleName());
        }
        try {
            list.remove(0);       // 同样抛 UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("remove 失败: " + e.getClass().getSimpleName());
        }

        // 2. set 是允许的：修改的是底层数组对应位置
        list.set(0, "JavaSE");
        System.out.println("原数组被改了: " + Arrays.toString(src)); // [JavaSE, Go, Rust]

        // 3. 反向联动：改原数组，List 内容也跟着变
        src[1] = "Golang";
        System.out.println("list 跟着变: " + list); // [JavaSE, Golang, Rust]
    }
}

String[] src = {"Java", "Go", "Rust"};
// 方案 A：包一层 ArrayList（最常用，会发生一次数组拷贝）
List<String> a = new ArrayList<>(Arrays.asList(src));
// 方案 B：Collections.addAll，一步到位且是深拷贝
List<String> b = new ArrayList<>();
Collections.addAll(b, src);
// 方案 C：JDK 8+ Stream（元素为对象类型时简洁）
List<String> c = Arrays.stream(src).collect(Collectors.toList());

int[] nums = {1, 2, 3};
// 注意这里泛型被推断为 int[]，而不是 Integer
List<int[]> wrong = Arrays.asList(nums);
System.out.println(wrong.size()); // 1，不是 3
// 正确做法：用 Integer 数组或 Stream 装箱
List<Integer> right = Arrays.asList(1, 2, 3);

import java.util.*;

public class ImmutableListDemo {
    public static void main(String[] args) {
        List<String> list = List.of("Java", "Go", "Rust");

        try {
            list.add("C++");                 // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("不可变集合不支持 add");
        }
        try {
            list.set(0, "JavaSE");           // 连 set 也不支持
        } catch (UnsupportedOperationException e) {
            System.out.println("不可变集合不支持 set");
        }

        // 1. 不允许 null 元素：构造时直接 NPE
        try {
            List<String> withNull = List.of("a", null);
        } catch (NullPointerException e) {
            System.out.println("List.of 不允许 null");
        }
        // 2. 连 contains(null) 都是 NPE，而不是返回 false
        try {
            list.contains(null);
        } catch (NullPointerException e) {
            System.out.println("contains(null) 也抛 NPE");
        }

        // 3. Set.of 不允许重复元素，重复直接 IllegalArgumentException
        try {
            Set<String> dup = Set.of("a", "a");
        } catch (IllegalArgumentException e) {
            System.out.println("Set.of 不允许重复元素");
        }
    }
}

import java.util.*;

public class BulkOperationTrap {
    public static void main(String[] args) {
        List<Integer> big = new ArrayList<>();
        for (int i = 0; i < 100_000; i++) big.add(i);

        List<Integer> filter = new ArrayList<>();
        for (int i = 0; i < 10_000; i++) filter.add(i);

        // 慢：ArrayList 的 removeAll 对每个元素都遍历 filter，O(n*m) = 10 亿次比较
        long t0 = System.nanoTime();
        List<Integer> copy1 = new ArrayList<>(big);
        copy1.removeAll(filter);
        long t1 = System.nanoTime();
        System.out.printf("List 版 removeAll: %d ms, 剩余 %d%n",
                (t1 - t0) / 1_000_000, copy1.size());

        // 快：先把过滤集合转成 HashSet，contains 变成 O(1)，整体 O(n)
        long t2 = System.nanoTime();
        List<Integer> copy2 = new ArrayList<>(big);
        copy2.removeAll(new HashSet<>(filter));
        long t3 = System.nanoTime();
        System.out.printf("Set 版 removeAll: %d ms, 剩余 %d%n",
                (t3 - t2) / 1_000_000, copy2.size());
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class ArrayCollectionConvert {
    public static void main(String[] args) {
        // 数组 -> List
        String[] arr = {"a", "b", "c"};
        List<String> fixed = Arrays.asList(arr);              // 定长视图
        List<String> mutable = new ArrayList<>(Arrays.asList(arr)); // 可变副本

        // List -> 数组
        String[] back1 = mutable.toArray(new String[0]);      // 推荐：JDK 内部会优化
        String[] back2 = mutable.toArray(new String[mutable.size()]);

        // 基本类型数组 -> List<Integer>：必须装箱
        int[] ints = {1, 2, 3};
        List<Integer> boxed = Arrays.stream(ints).boxed().collect(Collectors.toList());

        // List<Integer> -> int[]
        int[] unboxed = boxed.stream().mapToInt(Integer::intValue).toArray();
        System.out.println(Arrays.toString(unboxed));
    }
}

import java.util.*;

public class IteratorBasic {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("Java", "Go", "Rust"));
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();          // 每次 next 只能调用一次 remove
            if (s.startsWith("G")) {
                it.remove();               // 删除刚刚返回的 "Go"
            }
        }
        System.out.println(list);          // [Java, Rust]
    }
}

// 源码：for (String s : list) { System.out.println(s); }
// 编译后等价于：
for (Iterator<String> i = list.iterator(); i.hasNext(); ) {
    String s = i.next();
    System.out.println(s);
}

protected transient int modCount = 0;   // 结构性修改次数（增删、扩容、clear 等）

private class Itr implements Iterator<E> {
    int cursor;             // 下一个要返回元素的下标
    int lastRet = -1;       // 上一次返回元素的下标，-1 表示无
    int expectedModCount = modCount;   // 创建迭代器时，把 modCount 快照下来

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();          // ① 每次 next 前先校验
        int i = cursor;
        if (i >= size) throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0) throw new IllegalStateException();
        checkForComodification();          // ② 删除前也校验
        try {
            ArrayList.this.remove(lastRet); // 调用外部类 remove，modCount++
            cursor = lastRet;               // 游标回退，因为元素左移了
            lastRet = -1;
            expectedModCount = modCount;    // ③ 关键：同步更新快照！
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)   // ④ 快照与当前值不一致 -> 抛异常
            throw new ConcurrentModificationException();
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class RemoveElementWays {
    public static void main(String[] args) {
        // 姿势一（最推荐）：Iterator.remove
        List<String> l1 = new ArrayList<>(Arrays.asList("Java", "Go", "Rust", "Go"));
        for (Iterator<String> it = l1.iterator(); it.hasNext(); ) {
            if ("Go".equals(it.next())) it.remove();
        }
        System.out.println("姿势一: " + l1);

        // 姿势二：倒序 for-i 删除（正序会漏元素，倒序不会）
        List<String> l2 = new ArrayList<>(Arrays.asList("Java", "Go", "Rust", "Go"));
        for (int i = l2.size() - 1; i >= 0; i--) {
            if ("Go".equals(l2.get(i))) l2.remove(i);
        }
        System.out.println("姿势二: " + l2);

        // 姿势三：JDK 8+ removeIf（内部就是迭代器实现，最简洁）
        List<String> l3 = new ArrayList<>(Arrays.asList("Java", "Go", "Rust", "Go"));
        l3.removeIf("Go"::equals);
        System.out.println("姿势三: " + l3);

        // 姿势四：Stream 过滤生成新集合（不修改原集合）
        List<String> l4 = new ArrayList<>(Arrays.asList("Java", "Go", "Rust", "Go"));
        List<String> filtered = l4.stream()
                .filter(s -> !"Go".equals(s))
                .collect(Collectors.toList());
        System.out.println("姿势四: " + filtered);
    }
}

import java.util.*;

public class ListIteratorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("Java", "Go", "Rust"));
        ListIterator<String> it = list.listIterator();

        // 正向走，顺手替换元素（set 修改的是 next() 刚返回的位置）
        while (it.hasNext()) {
            String s = it.next();
            it.set(s.toUpperCase());
        }
        System.out.println("转大写后: " + list);   // [JAVA, GO, RUST]

        // 反向遍历：这是普通 Iterator 做不到的
        System.out.print("反向遍历:");
        while (it.hasPrevious()) {
            System.out.print(" " + it.previous());
        }
        System.out.println();

        // add 是插入到「下一次 next() 会返回的元素之前」
        ListIterator<String> it2 = list.listIterator();
        it2.next();       // 游标停在 JAVA 之后
        it2.add("Scala"); // 插到 JAVA 与 GO 之间
        System.out.println("插入后: " + list);
    }
}

transient Object[] elementData;   // 真正存元素的缓冲区
private int size;                 // 元素个数（注意：不是数组长度）

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    // JDK 8+：先给空数组，第一次 add 时才扩容到 10
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public boolean add(E e) {
    ensureCapacityInternal(size + 1);   // ① 确保能装下 size+1 个
    elementData[size++] = e;            // ② 直接尾部写入，O(1) 摊还
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    // 若还是「延迟初始化」的空数组，则首次至少扩到 DEFAULT_CAPACITY(10)
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;                                     // 结构性修改计数
    if (minCapacity - elementData.length > 0)       // 容量不够才扩容
        grow(minCapacity);
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);  // ③ 1.5 倍：右移一位 = 除以 2
    if (newCapacity - minCapacity < 0)                   // 1.5 倍还不够（比如 addAll 大批量）
        newCapacity = minCapacity;                       // 直接用所需最小容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)                // 超过上限特殊处理
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity); // ④ 拷贝迁移
}

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
    int expectedModCount = modCount;   // 先快照，防止序列化过程中被改
    s.defaultWriteObject();            // 先写 size 等非 transient 字段
    s.writeInt(size);                  // 显式写元素个数
    for (int i = 0; i < size; i++) {   // 只写真实存在的元素
        s.writeObject(elementData[i]);
    }
    if (modCount != expectedModCount) { // 序列化期间被改了 -> 同样 fail-fast
        throw new ConcurrentModificationException();
    }
}

public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);
    // 把 index 及其后的元素整体右移一位，给新元素腾位置
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

import java.util.*;

public class EnsureCapacityBench {
    public static void main(String[] args) {
        int n = 2_000_000;

        long t0 = System.currentTimeMillis();
        List<Integer> a = new ArrayList<>();
        for (int i = 0; i < n; i++) a.add(i);
        long t1 = System.currentTimeMillis();

        long t2 = System.currentTimeMillis();
        List<Integer> b = new ArrayList<>();
        b.ensureCapacity(n);            // 或者 new ArrayList<>(n)
        for (int i = 0; i < n; i++) b.add(i);
        long t3 = System.currentTimeMillis();

        System.out.printf("默认: %d ms, 预分配: %d ms%n", t1 - t0, t3 - t2);
        // 用完后如果不再新增，可以缩容释放冗余空间
        ((ArrayList<Integer>) b).trimToSize();
    }
}

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element; this.next = next; this.prev = prev;
    }
}
transient int size = 0;
transient Node<E> first;   // 头指针
transient Node<E> last;    // 尾指针

Node<E> node(int index) {
    // 折半查找：前半段从头遍历，后半段从尾遍历
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++) x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--) x = x.prev;
        return x;
    }
}

// 不推荐
Stack<String> bad = new Stack<>();
// 推荐：官方 Javadoc 明确建议
Deque<String> good = new ArrayDeque<>();
good.push("a"); good.push("b");
System.out.println(good.pop());   // b

List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// 注意：迭代时仍必须手动加锁
synchronized (syncList) {
    for (String s : syncList) System.out.println(s);
}

import java.util.*;

public class SubListTrap {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d", "e"));
        List<String> sub = list.subList(1, 3);   // [b, c]
        System.out.println("sub = " + sub);

        // 1. 改视图 = 改原集合
        sub.set(0, "B");
        System.out.println("原集合被改: " + list);   // [a, B, c, d, e]

        // 2. 反向也成立：改原集合后，视图的任何操作都会 CME
        list.add("f");
        try {
            System.out.println(sub);   // 这里就会抛 ConcurrentModificationException
        } catch (ConcurrentModificationException e) {
            System.out.println("父集合被结构性修改后，子视图失效");
        }
    }
}

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable {
    private transient HashMap<E, Object> map;          // 真正干活的
    private static final Object PRESENT = new Object(); // 所有 value 共用的占位对象

    public HashSet() {
        map = new HashMap<>();                          // 默认容量 16，负载因子 0.75
    }
    public boolean add(E e) {
        return map.put(e, PRESENT) == null;             // put 返回 null 说明 key 原来不存在
    }
    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }
    public boolean contains(Object o) {
        return map.containsKey(o);
    }
    public Iterator<E> iterator() {
        return map.keySet().iterator();                 // 直接复用 keySet 的迭代器
    }
}

import java.util.*;

public class TreeSetOrdering {
    static class Student implements Comparable<Student> {
        String name;
        int score;
        Student(String name, int score) { this.name = name; this.score = score; }

        // 自然排序：分数降序，分数相同按姓名升序
        @Override
        public int compareTo(Student o) {
            int r = Integer.compare(o.score, this.score);   // 降序：反过来比
            return r != 0 ? r : this.name.compareTo(o.name);
        }
        @Override
        public String toString() { return name + "(" + score + ")"; }
    }

    public static void main(String[] args) {
        // 方式一：自然排序（Comparable）
        Set<Student> byComparable = new TreeSet<>();
        byComparable.add(new Student("Alice", 90));
        byComparable.add(new Student("Bob", 95));
        byComparable.add(new Student("Cindy", 90));
        System.out.println("自然排序: " + byComparable);
        // 输出 [Bob(95), Alice(90), Cindy(90)]：分数降序，同分按名字

        // 方式二：定制排序（Comparator），按名字长度升序
        Set<Student> byComparator = new TreeSet<>(
                Comparator.comparingInt((Student s) -> s.name.length())
                          .thenComparing(s -> s.name));
        byComparator.addAll(byComparable);
        System.out.println("定制排序: " + byComparator);
    }
}

// HashSet 中专门为 LinkedHashSet 预留的构造器
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

// LinkedHashSet
public LinkedHashSet() {
    super(16, .75f, true);   // 第三个参数只是用来区分重载，无实际意义
}

TreeSet<Integer> ts = new TreeSet<>(Arrays.asList(10, 20, 30, 40));
System.out.println(ts.lower(25));    // 20：小于 25 的最大值
System.out.println(ts.floor(30));    // 30：小于等于 30 的最大值
System.out.println(ts.ceiling(25));  // 30：大于等于 25 的最小值
System.out.println(ts.higher(40));   // null
System.out.println(ts.subSet(10, false, 40, true)); // (10, 40] = [20, 30, 40]

import java.util.*;

public class DedupDemo {
    static class User {
        private final String id;
        private final String name;

        User(String id, String name) { this.id = id; this.name = name; }

        // 约定：id 相同即视为同一人
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof User)) return false;
            User u = (User) o;
            return Objects.equals(id, u.id);
        }

        @Override
        public int hashCode() {
            // Objects.hash 会把实参装进数组，热点路径上不如手写 31 法
            return id != null ? id.hashCode() : 0;
        }

        @Override
        public String toString() { return id + ":" + name; }
    }

    public static void main(String[] args) {
        List<User> raw = Arrays.asList(
                new User("1", "张三"), new User("2", "李四"),
                new User("1", "张三丰"), new User("3", "王五"),
                new User("2", "李四光"));

        // 1. 去重但保持首次出现顺序
        Set<User> ordered = new LinkedHashSet<>(raw);
        System.out.println("保持顺序去重: " + ordered);

        // 2. 去重且按 id 排序
        Set<User> sorted = new TreeSet<>(Comparator.comparing(u -> u.id));
        sorted.addAll(raw);
        System.out.println("排序去重: " + sorted);

        // 3. 统计每个 id 出现次数（Map 思路，下一篇展开）
        Map<String, Integer> freq = new HashMap<>();
        for (User u : raw) freq.merge(u.id, 1, Integer::sum);
        System.out.println("出现次数: " + freq);
    }
}

import java.util.*;

public class DequeAsStackAndQueue {
    public static void main(String[] args) {
        // 当栈用
        Deque<String> stack = new ArrayDeque<>();
        stack.push("A"); stack.push("B"); stack.push("C");
        System.out.println("栈: " + stack.peek() + " -> " + stack.pop()); // C -> C

        // 当队列用
        Deque<String> queue = new ArrayDeque<>();
        queue.offerLast("A"); queue.offerLast("B"); queue.offerLast("C");
        System.out.println("队列: " + queue.peekFirst() + " -> " + queue.pollFirst()); // A -> A
    }
}

transient Object[] elements;   // 长度恒为 2 的幂
transient int head;            // 队头元素下标
transient int tail;            // 队尾元素「下一个待插入」位置
private static final int MIN_INITIAL_CAPACITY = 8;

private void doubleCapacity() {
    assert head == tail;             // 只在「满」时调用
    int p = head;
    int n = elements.length;
    int r = n - p;                   // head 右侧（含 head）到数组末尾的元素个数
    int newCapacity = n << 1;        // 翻倍
    if (newCapacity < 0) throw new IllegalStateException("Sorry, deque too big");
    Object[] a = new Object[newCapacity];
    // 分两段拷贝：先拷 head 到末尾的部分，再拷开头到 tail 的部分
    System.arraycopy(elements, p, a, 0, r);
    System.arraycopy(elements, 0, a, r, p);
    elements = a;
    head = 0;
    tail = n;
}

transient Object[] queue;                  // 堆数组
private int size = 0;
private final Comparator<? super E> comparator;
private static final int DEFAULT_INITIAL_CAPACITY = 11;

private static <T> void siftUpComparable(int k, T x, Object[] es) {
    Comparable<? super T> key = (Comparable<? super T>) x;
    while (k > 0) {
        int parent = (k - 1) >>> 1;        // 父节点下标
        Object e = es[parent];
        if (key.compareTo((T) e) >= 0)     // 已经 >= 父节点，堆性质满足，停
            break;
        es[k] = e;                         // 父节点往下沉（不是真交换，只单向赋值）
        k = parent;
    }
    es[k] = key;                           // 最后一次性放入，省掉多次交换
}

private static <T> void siftDownComparable(int k, T x, Object[] es, int n) {
    Comparable<? super T> key = (Comparable<? super T>) x;
    int half = n >>> 1;                    // 只需要下沉到最后一个非叶子节点
    while (k < half) {
        int child = (k << 1) + 1;          // 左孩子
        Object c = es[child];
        int right = child + 1;
        // 选出左右孩子中较小的那个
        if (right < n && ((Comparable<? super T>) c).compareTo((T) es[right]) > 0)
            c = es[child = right];
        if (key.compareTo((T) c) <= 0)     // 已经比孩子都小，停
            break;
        es[k] = c;                         // 孩子上浮
        k = child;
    }
    es[k] = key;
}

import java.util.*;

public class TopKDemo {
    /** 返回数组中最大的 k 个数（结果按升序排列） */
    public static List<Integer> topK(int[] nums, int k) {
        if (k <= 0) return List.of();
        // 小顶堆：堆顶是当前候选中最小的一个，一旦来了更大的就把它踢掉
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(k);
        for (int n : nums) {
            if (minHeap.size() < k) {
                minHeap.offer(n);                    // 先填满 k 个
            } else if (n > minHeap.peek()) {
                minHeap.poll();                      // 淘汰当前最小的候选
                minHeap.offer(n);
            }
        }
        List<Integer> result = new ArrayList<>(minHeap);
        Collections.sort(result);                    // 堆内无序，排序后输出更友好
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {3, 1, 5, 12, 2, 11, 7, 9, 4, 8, 10, 6};
        System.out.println("Top5: " + topK(nums, 5));  // [8, 9, 10, 11, 12]

        // 求最小的 k 个：反过来用大顶堆
        PriorityQueue<Integer> maxHeap =
                new PriorityQueue<>((a, b) -> Integer.compare(b, a));
        for (int n : nums) {
            if (maxHeap.size() < 4) maxHeap.offer(n);
            else if (n < maxHeap.peek()) { maxHeap.poll(); maxHeap.offer(n); }
        }
        System.out.println("Bottom4: " + new ArrayList<>(maxHeap)); // [4, 3, 2, 1]
    }
}

import java.util.*;

public class ComparatorChaining {
    static class Order {
        String customer;
        int amount;
        LocalDate date;
        Order(String c, int a, LocalDate d) { customer = c; amount = a; date = d; }
        @Override public String toString() {
            return customer + " " + amount + " " + date;
        }
    }

    public static void main(String[] args) {
        List<Order> orders = new ArrayList<>(Arrays.asList(
                new Order("Bob", 300, LocalDate.of(2026, 1, 3)),
                new Order("Alice", 200, LocalDate.of(2026, 1, 2)),
                new Order("Bob", 100, LocalDate.of(2026, 1, 1)),
                new Order(null, 500, LocalDate.of(2026, 1, 5))));

        // 链式比较：金额降序 -> 日期升序 -> 客户名升序（null 排最前）
        Comparator<Order> cmp = Comparator
                .comparing(Order::getAmount, Comparator.reverseOrder())
                .thenComparing(Order::getDate)
                .thenComparing(Order::getCustomer, Comparator.nullsFirst(String::compareTo));

        orders.sort(cmp);
        orders.forEach(System.out::println);
    }
}

// java.util.List 的默认实现（JDK 8+）
default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();              // ① 先转成数组，避免链表 O(n²) 访问
    Arrays.sort(a, (Comparator) c);           // ② 数组排序（对象走 TimSort）
    ListIterator<E> i = this.listIterator();  // ③ 通过 ListIterator 写回
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}