List（列表接口）、Set（集合接口）与 Queue（队列接口）集合体系

这一章解决的不是“背出几个集合名称”，而是你能根据访问方式、去重语义、顺序、容量和并发边界，给 WMS（仓储管理系统）批次拣货、订单履约优先级、Runner（执行器）调度、IoT（物联网）报警治理和异步导出选出可解释、可治理的数据结构。

1. 复习目标与迁移范围

本章迁移并深化入口文档的 4.1、4.3、5.1、6 节及关联题；HashMap（哈希映射）内部数组、树化和扩容留给下一章，避免把“使用 Set（集合接口）的契约”与“哈希桶实现”混写。

学完后，你应能：

• 先区分接口契约与具体实现，再依据业务语义选型；
• 用 10 → 15 → 22 的容量演绎说明 ArrayList（数组列表）的均摊成本；
• 反驳“LinkedList（链表列表）中间插入一定 O(1)（常数复杂度）”的错误前提；
• 区分内存去重、进程内队列与跨实例幂等、持久消息的边界；
• 从队列积压、OOM（内存溢出）、ConcurrentModificationException（并发修改异常）、顺序误判和比较器失配定位问题。

2. 接口契约、实现与只读视图

2.1 从 Iterable（可迭代接口）到 Deque（双端队列）的关系与选型

接口先定义“你可以对元素做什么”，实现才决定“怎样存、怎样快”。Map（映射接口）不继承 Collection（集合接口）：它的基本单元是 key（键）到 value（值）的映射；虽然可以取得 keySet（键集合）、values（值集合）和 entrySet（键值对集合）视图，但 Map（映射接口）本身不是一个“元素集合”。

flowchart TD
    I["Iterable（可迭代接口）：可取得 Iterator（迭代器）"] --> C["Collection（集合接口）：元素群体契约"]
    C --> L["List（列表接口）：有位置、允许重复"]
    C --> S["Set（集合接口）：按相等语义去重"]
    C --> Q["Queue（队列接口）：按取出策略消费"]
    Q --> D["Deque（双端队列）：两端进出"]
    M["Map（映射接口）：key（键）→ value（值）"] -. "不属于 Collection（集合接口）" .-> C
    M --> KS["keySet（键集合）视图"]
    M --> VS["values（值集合）视图"]

图中实线表示继承关系。List（列表接口）强调位置，Set（集合接口）强调唯一性，Queue（队列接口）强调消费规则；Deque（双端队列）在队头和队尾都能操作。Map（映射接口）独立于 Collection（集合接口），只能通过三个视图暴露集合式访问，不能因为它“装了很多数据”就把它当作 Collection（集合接口）。

flowchart TD
    A["先问：业务单元是 key（键）→ value（值）吗？"] -->|是| M["Map（映射接口）；下一章再选哈希或排序实现"]
    A -->|否| B{"需要按位置读取或保留重复吗？"}
    B -->|是| C{"主要是尾部追加、遍历或按下标读取吗？"}
    C -->|是| AL["ArrayList（数组列表）"]
    C -->|否| LL["只有已持有 ListIterator（列表迭代器）位置时才考虑 LinkedList（链表列表）"]
    B -->|否| D{"需要按相等语义去重吗？"}
    D -->|是| E{"要插入顺序或排序吗？"}
    E -->|无顺序| HS["HashSet（哈希集合）"]
    E -->|插入顺序| LHS["LinkedHashSet（链式哈希集合）"]
    E -->|排序/范围| TS["TreeSet（树集合）"]
    D -->|否| F{"元素要按时间、栈或优先级被消费吗？"}
    F -->|FIFO（先进先出）/LIFO（后进先出）| AD["ArrayDeque（数组双端队列）"]
    F -->|优先级| PQ["PriorityQueue（优先队列）"]
    F -->|生产消费且需阻塞/背压| BQ["BlockingQueue（阻塞队列）"]

这棵树故意把“线程安全”和“容量是否有界”放在最后复核，而不是把它们当集合种类。普通 ArrayList（数组列表）、HashSet（哈希集合）、ArrayDeque（数组双端队列）都不是线程安全容器；共享可变集合要么改变所有权（分片后归并），要么使用并发实现并定义容量、超时、拒绝和降级策略。

接口方法也有失败语义：Queue（队列接口）的 add（添加）/remove（移除）/element（查看队头）多用异常报告失败，offer（尝试入队）/poll（尝试出队）/peek（查看队头）多用特殊返回值。对有界队列，优先用能表达等待上限的 offer（尝试入队）超时版本，而不是把调用线程无限挂住。

热门面试题

1. 问题（基础题）：为什么 Map（映射接口）不属于 Collection（集合接口）？

   • 考点：抽象边界、视图与元素语义。
   • 回答思路：先定义两者的基本单元，再说视图不是继承，最后联系按 key（键）查找。
   • 详细答案：Collection（集合接口）的基本操作围绕单个元素，例如包含、遍历、增加和移除；Map（映射接口）的基本操作围绕键到值的关联，例如按 key（键）查找、覆盖和删除映射。Map（映射接口）可导出键、值、键值对三个集合视图，是为了便于遍历和批量操作，不改变它独立的契约。把 Map（映射接口）当 Collection（集合接口）会掩盖唯一 key（键）、覆盖旧 value（值）和按 key（键）寻址这些核心语义。
   • 进阶追问：WMS（仓储管理系统）库存聚合为什么通常以 Map（映射接口）而不是 List（列表接口）为主？
   • 进阶回答：库存聚合的业务单元是稳定的“仓库 + SKU（库存单位）”到数量，不是无差别元素序列。用 Map（映射接口）可直接按组合 key（键）累加、覆盖或读取；若用 List（列表接口），每次更新都需线性查找且容易留下重复分组。并发时还要把聚合所有权分片或使用恰当并发映射，不能仅因 Map（映射接口）查得快就忽略原子累加和容量边界。

2. 问题（原理题）：集合选型为什么不能只看时间复杂度？

   • 考点：契约优先、常数成本、缓存局部性、容量与并发。
   • 回答思路：先用语义排除错误结构，再比较完整操作成本和资源边界。
   • 详细答案：复杂度是渐近描述，不能替代业务契约和真实成本。比如 LinkedList（链表列表）在已定位节点前插入是 O(1)（常数复杂度），但从下标定位该节点仍是 O(n)（线性复杂度）；ArrayList（数组列表）移动引用是 O(n)（线性复杂度），却可由连续槽位和批量复制获得较低常数。更关键的是容量、对象数量、线程共享、失败后的重试语义都不由一个大 O（复杂度记号）决定。先选择正确语义，再用数据量和压测验证成本。
   • 进阶追问：Runner（执行器）任务为什么不能因为 Queue（队列接口）是 FIFO（先进先出）就默认选无界队列？
   • 进阶回答：FIFO（先进先出）只定义取出顺序，不约束积压上限。无界队列会在下游变慢时继续吸收任务，把背压转化为堆对象、GC（垃圾回收）压力和最终 OOM（内存溢出）。Runner（执行器）需要先估算每个任务的内存、允许排队时长和消费者吞吐，再选有界队列、超时提交、拒绝、降级或持久化，而不是让内存替业务做无限缓冲。

3. 问题（项目题）：订单履约既要按承诺时间处理，又要让同一订单只进入一次，怎样拆分集合职责？

   • 考点：去重语义、优先级、持久化幂等。
   • 回答思路：把去重与调度排序拆开，说明内存结构只做局部加速。
   • 详细答案：先用稳定订单事件号定义幂等边界，在数据库唯一约束或 Redis（远程字典服务）原子写入处做跨实例判重；成功领取的任务再进入按承诺发货时间排序的 PriorityQueue（优先队列）或持久调度表。内存 Set（集合接口）可以降低同一实例短窗口内的重复入队，但实例重启、扩容或网络重试后都不可靠。把 Set（集合接口）和优先队列混成一个“万能容器”，会同时丢掉可解释的去重边界与调度恢复能力。
   • 进阶追问：为什么不能只依赖 PriorityQueue（优先队列）遍历检查重复？
   • 进阶回答：PriorityQueue（优先队列）的堆数组只保证堆顶最优，不保证遍历全局排序，也不以业务唯一键判重；扫描既是 O(n)（线性复杂度），也无法跨进程原子化。重复控制必须用稳定业务键和持久化条件写入；优先队列只承担已确认任务的本地调度顺序。

2.2 工厂、包装与视图：长度、可变性和快照

只读不等于快照，固定长度也不等于不可修改。以下表格只保留容易误用的边界，Object（对象基类）元素本身是否可变是另一个维度。

Arrays.asList（数组转固定长度列表方法）最适合在数组与 List（列表接口）之间做轻量桥接；需要增删时应显式 new ArrayList<>(...)。List.of（不可修改列表工厂方法）从 JDK（Java 开发工具包）9 起可用，List.copyOf（列表复制方法）从 JDK（Java 开发工具包）10 起可用。JDK（Java 开发工具包）8 需要稳定容器快照时，使用 Collections.unmodifiableList(new ArrayList<>(source))：先创建私有 ArrayList（数组列表）副本，再返回该副本的不可修改视图。这个替代写法允许 null（空值），与 JDK（Java 开发工具包）9+/10+ 工厂/复制方法拒绝 null（空值）的行为不同；它同样只是浅复制，元素对象仍可能可变。Collections.unmodifiableList（不可修改列表包装方法）若直接包原列表，则只是实时视图，源列表变化仍会反映。

热门面试题

1. 问题（基础题）：Arrays.asList（数组转固定长度列表方法）、List.of（不可修改列表工厂方法）和 Collections.unmodifiableList（不可修改列表包装方法）怎么区分？

   • 考点：长度、容器修改、视图与快照。
   • 回答思路：按“能否增删、能否替换、底层是否共享、是否允许 null（空值）”逐项回答。
   • 详细答案：Arrays.asList（数组转固定长度列表方法）返回由原数组支撑的固定长度列表，元素可替换但不可增删；List.of（不可修改列表工厂方法）从 JDK（Java 开发工具包）9 起返回不可修改列表且拒绝 null（空值）；Collections.unmodifiableList（不可修改列表包装方法）只是禁止经包装引用修改，原列表持有者仍可改，视图会随之变化。JDK（Java 开发工具包）10 起可用 List.copyOf（列表复制方法）冻结当前引用序列；JDK（Java 开发工具包）8 则使用 Collections.unmodifiableList(new ArrayList<>(source)) 先复制再包装。后者允许 null（空值），但仍是元素引用的浅复制，不应把包装视图或容器快照误当深层不可变。
   • 进阶追问：为什么只读视图不能作为跨线程安全发布的充分条件？
   • 进阶回答：只读视图只限制一个引用上的修改方法，不提供锁、可见性或底层容器冻结。其他线程修改源列表时，读取线程仍可能观察到中间状态、触发 ConcurrentModificationException（并发修改异常）或读到不一致业务快照。跨线程发布要么构造完成后以不可变快照安全发布，要么用明确的并发协调机制；JDK（Java 开发工具包）8 的私有复制包装也必须在复制完成后再发布。

2. 问题（原理题）：为什么“容器不可修改”不等于“对象图不可变”？

   • 考点：浅复制、元素可变性、防御性拷贝。
   • 回答思路：区分列表槽位不能改与槽位指向对象不能改。
   • 详细答案：不可修改列表保护的是列表结构：不能新增、删除或替换引用；如果元素仍是可变订单对象，持有该对象的人仍可修改状态、金额或明细，所有读取者都能看到改变。真正不可变的结果对象需要私有 final（最终关键字）字段、构造期校验、无修改方法，并对数组和可变集合进行 defensive copy（防御性拷贝）。在支付和库存场景，不能因为返回了只读 List（列表接口）就放松状态机和数据库一致性控制。
   • 进阶追问：异步导出为何通常要复制导出条件而不是一直引用 Web（万维网）请求对象？
   • 进阶回答：请求对象生命周期短、字段可能被框架复用或后续代码修改，异步线程读取它会造成结果漂移和上下文泄漏。应在提交任务时校验并复制不可变的筛选条件、操作者和时间范围，任务执行时再基于快照查询；大数据本身仍按页读取，不能把查询结果整体复制进内存。

3. 问题（项目题）：WMS（仓储管理系统）拣货波次接口返回列表时，怎样避免调用方误改服务端缓存？

   • 考点：所有权、缓存泄漏、不可变返回值。
   • 回答思路：先判断缓存是否共享，再选择复制或只读视图，并说清元素边界。
   • 详细答案：如果内部缓存的波次明细会继续更新，不能把其可变 ArrayList（数组列表）直接返回；调用方 clear（清空）或排序都会污染缓存。面向外部接口应构建只含展示字段的不可变数据传输对象，JDK（Java 开发工具包）10+ 用 List.copyOf（列表复制方法）发布容器快照，JDK（Java 开发工具包）8 用私有 ArrayList（数组列表）复制后再 Collections.unmodifiableList（不可修改列表包装方法）。后者允许 null（空值），元素对象仍可变；若直接包装内部列表则只是实时视图。无论哪种方式，库存可用量等业务事实仍以数据库或缓存原子读写为准。
   • 进阶追问：复制会不会造成过多内存？
   • 进阶回答：会，所以边界不是“永远复制”，而是缩小响应页、只投影必需字段、设置缓存条目上限和过期，并按访问频率评估。对于超大导出，用分页流式写出而不是构造一个巨型不可修改列表；复制解决所有权，不解决无界数据量。

3. List（列表接口）：动态数组与双向链表

3.1 ArrayList（数组列表）：容量、复制、局部性与 fail-fast（快速失败）

ArrayList（数组列表）把元素引用放进一个 Object[]（对象数组）槽位数组；“连续”说的是引用槽位数组连续，不是说每个 Java（编程语言）对象本体一定在物理内存连续。连续槽位有利于顺序预取和处理器缓存命中：一次 cache line（缓存行）可带来相邻多个引用槽位；随后仍要通过引用访问各个对象，若对象分散，第二跳仍可能失去局部性。

本机事实核对：

• JDK（Java 开发工具包）8：/Users/Lever/Library/Java/JavaVirtualMachines/corretto-1.8.0_402/Contents/Home/src.zip 的 java/util/ArrayList.java 定义 DEFAULT_CAPACITY = 10、两个共享空数组；默认构造首次 add（添加）扩到 10，grow（扩容方法）为 old + (old >> 1) 后用 Arrays.copyOf（数组复制方法）复制。
• JDK（Java 开发工具包）21：/Users/Lever/Library/Java/JavaVirtualMachines/openjdk-21.0.2/Contents/Home/lib/src.zip 的 java.base/java/util/ArrayList.java 同样延迟至首次添加分配 10；grow（扩容方法）调用 ArraysSupport.newLength（数组新长度计算方法），以旧容量一半作为首选增长量并处理最小容量和大数组边界。
• 两版 ensureCapacity（确保容量方法）都允许提前扩容；结构性修改更新 modCount（结构修改计数），迭代器比较预期值以尽力发现并发结构修改；中间插入、删除通过 System.arraycopy（系统数组复制方法）搬移引用。

flowchart LR
    A["默认构造：共享空槽位数组"] --> B["第 1 次 add（添加）：capacity（容量）= 10"]
    B --> C["size（元素数）= 10，再 add（添加）"]
    C --> D["新槽位数组：capacity（容量）= 15；复制 10 个引用"]
    D --> E["size（元素数）= 15，再 add（添加）"]
    E --> F["新槽位数组：capacity（容量）= 22；复制 15 个引用"]
    F --> G["旧槽位数组可回收；新元素写入"]

图中 10、15、22 是默认增长路径的整数截断结果：10 + 10/2 = 15，15 + 15/2 = 22。1.5 倍是当前 JDK（Java 开发工具包）实现的空间与复制次数权衡，不是 List（列表接口）契约；不能把它写进依赖具体容量的业务逻辑。

均摊分析不是说每一次追加都便宜，而是容量几何增长时，某个元素在后续扩容中被复制的次数受增长比例约束。N 次尾部追加的总复制量是 O(n)（线性复杂度）量级，因此单次平均为 O(1)（常数复杂度）；单次扩容仍可能造成内存带宽和延迟尖峰。已知单批最多 5 000 条时用 new ArrayList<>(5000)（指定容量创建数组列表）或 ensureCapacity（确保容量方法）可减少复制，但预估过大又会浪费堆。

Iterator（迭代器）的 fail-fast（快速失败）机制记录 expectedModCount（预期结构修改计数），检测到结构计数不一致时通常抛 ConcurrentModificationException（并发修改异常）。它是对程序错误的尽力而为检测：没有同步、没有 happens-before（先行发生）保证，也不能保证每次竞争都被发现；因此绝不是线程安全保证。遍历时要删除当前元素，用 Iterator（迭代器）的 remove（移除）方法；多线程场景用明确同步、并发容器或快照策略。

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/** 演示容量预估、比较器稳定性和有界任务队列。 */
public class CollectionMechanismDemo {
    /** 订单调度对象；入队后不修改优先级字段。 */
    private static final class FulfillmentTask {
        private final String orderNo;
        private final int priority;

        /**
         * 创建履约任务。
         *
         * @param orderNo 订单号，不能为空
         * @param priority 数值越小代表越优先
         */
        private FulfillmentTask(String orderNo, int priority) {
            this.orderNo = orderNo;
            this.priority = priority;
        }
    }

    /**
     * 运行可验证示例。
     *
     * @param args 命令行参数，未使用
     * @throws InterruptedException 等待队列超时时抛出
     */
    public static void main(String[] args) throws InterruptedException {
        List<String> pickingLines = new ArrayList<>(3);
        pickingLines.add("P-1");
        pickingLines.add("P-2");

        PriorityQueue<FulfillmentTask> tasks = new PriorityQueue<>(
                Comparator.comparingInt(task -> task.priority));
        tasks.offer(new FulfillmentTask("O-2", 20));
        tasks.offer(new FulfillmentTask("O-1", 10));

        ArrayBlockingQueue<String> runnerQueue = new ArrayBlockingQueue<>(1);
        boolean accepted = runnerQueue.offer("export-1", 10, TimeUnit.MILLISECONDS);
        System.out.println(pickingLines.size() + ":" + tasks.poll().orderNo + ":" + accepted);
    }
}

示例输出应为 2:O-1:true。代码中的优先级字段设为 final（最终关键字），因为任务已经进入 PriorityQueue（优先队列）后再修改排序字段会破坏堆序；有界 ArrayBlockingQueue（数组阻塞队列）的超时 offer（尝试入队）使调用方能选择降级而不是无限等待。

热门面试题

1. 问题（基础题）：ArrayList（数组列表）为什么尾部追加是均摊 O(1)（常数复杂度），却仍会有延迟尖峰？

   • 考点：几何扩容、数组复制、均摊分析与内存峰值。
   • 回答思路：先区分一次操作和 N 次总成本，再解释新旧数组并存。
   • 详细答案：多数尾部 add（添加）只写一个空槽位；满容时才分配更大引用数组并复制所有已有引用。由于容量按比例增长，连续 N 次追加的累计复制量与 N 同阶，平均到每次是 O(1)（常数复杂度），但触发扩容的那次仍是 O(n)（线性复杂度）。扩容瞬间新旧数组同时存活，复制占用 CPU（中央处理器）和内存带宽，所以大批次导入会出现响应时间尖峰甚至放大 GC（垃圾回收）压力。
   • 进阶追问：为什么 1.5 倍不能当作 List（列表接口）的固定承诺？
   • 进阶回答：List（列表接口）只约定行为，不约定内部容量、增长比例或数组布局；JDK（Java 开发工具包）8 与 JDK（Java 开发工具包）21 的源码都以一半旧容量为首选增长，但 JDK（Java 开发工具包）21 已通过内部长度计算器处理边界。替代实现和未来版本可以变化，业务只能通过显式初始容量表达预估，不能依赖反射读取容量或假设“第 16 个必扩容到 22”。

2. 问题（原理题）：ArrayList（数组列表）的“连续内存”到底连续什么？

   • 考点：引用数组、对象布局、缓存局部性。
   • 回答思路：先纠正对象本体连续的绝对化说法，再解释两跳访问与实际收益。
   • 详细答案：ArrayList（数组列表）连续的是 Object[]（对象数组）中的引用槽位，按下标遍历时 CPU（中央处理器）更容易预取相邻槽位并利用 cache line（缓存行）。槽位指向的业务对象通常由 JVM（Java 虚拟机）分配和 GC（垃圾回收）移动决定，不能承诺对象本体物理连续；读取对象字段仍需要沿引用再访问一次内存。即便如此，少对象包装、顺序遍历和批量复制通常让 ArrayList（数组列表）在常见业务中优于指针分散的链表。
   • 进阶追问：什么时候这种局部性优势可能不明显？
   • 进阶回答：如果列表只保存很大的外部对象、每次访问都被数据库或网络 I/O（输入输出）主导，或者算法随机跳转远多于顺序扫描，容器槽位局部性不是主要瓶颈。此时应先用 JFR（Java 飞行记录器）或基准测试定位热点，不能用“数组更快”的经验替代观测；但语义、内存上限和并发边界仍然要先正确。

3. 问题（项目题）：异步导出为什么不能把全部查询结果装进一个 ArrayList（数组列表）后再写文件？

   • 考点：驻留集、批处理边界、背压与失败恢复。
   • 回答思路：从对象图、导出速度差、检查点和分页写出回答。
   • 详细答案：全量装载让每一行对象、关联字符串和格式化结果长期驻留，数据量增长会把堆、GC（垃圾回收）和失败重试成本一起放大；预估容量只能减少复制，不能限制总对象数。正确做法是用游标或分页取固定批次，转换后立即用 BufferedWriter（缓冲字符输出流）写出并释放批次引用，同时记录页号或主键检查点。写出端变慢时应限制拉取并发，必要时暂停或取消任务，而不是继续把数据压入本地列表。
   • 进阶追问：如何验证导出没有因为分页而重复或漏行？
   • 进阶回答：使用稳定、唯一且单调的排序键做 seek（定位）分页，例如记录最后成功的主键和导出条件快照，下一页查询使用严格大于该键；避免 offset（偏移量）分页在数据写入时漂移。结果文件可记录批次数、行数、首尾键和校验摘要，失败重试从检查点继续；这比依赖内存列表索引更可恢复。

3.2 LinkedList（链表列表）：定位是成本，改链才是 O(1)（常数复杂度）

LinkedList（链表列表）使用双向 Node（节点）：每个节点持有前驱、元素引用和后继。按 index（下标）访问时，源码会比较索引与 size / 2，从更近的头或尾开始遍历；这只把平均步数约减半，量级仍为 O(n)（线性复杂度）。

flowchart LR
    H["first（首节点）"] <--> N1["Node（节点）：prev（前驱）/ item（元素）/ next（后继）"]
    N1 <--> N2["Node（节点）：prev（前驱）/ item（元素）/ next（后继）"]
    N2 <--> N3["Node（节点）：prev（前驱）/ item（元素）/ next（后继）"]
    N3 <--> T["last（尾节点）"]
    X["待插入 Node（节点）"] -. "已定位 N2 时，只重连相邻引用" .-> N2

图中“只重连相邻引用”是插入动作本身的常数成本，不包含找到 N2 的过程。业务代码通常拿到的是 index（下标）或对象条件，不是内部 Node（节点）；先查找再插入的完整成本仍为 O(n)（线性复杂度）。已有 ListIterator（列表迭代器）正停在目标位置，连续局部插入或删除才是链表擅长的前提。

本机 JDK（Java 开发工具包）8 源码 java/util/LinkedList.java 的 node(int)（按下标定位节点方法）从 first（首节点）或 last（尾节点）遍历；linkBefore（前插链接方法）和 unlink（解除链接方法）会更新相邻引用、size（元素数）与 modCount（结构修改计数）。每个 Node（节点）额外对象头、前后引用与分配管理成本，使链表不仅占用更多堆，也更容易在大量节点时增加 GC（垃圾回收）工作。

热门面试题

1. 问题（基础题）：为什么“LinkedList（链表列表）中间插入一定 O(1)（常数复杂度）”是错误表述？

   • 考点：定位前提、完整操作成本。
   • 回答思路：指出它漏掉定位成本，再给出已持有迭代器位置的例外。
   • 详细答案：链表在已拿到目标 Node（节点）或 ListIterator（列表迭代器）当前位置时，只需改少量前后引用，插入或删除动作可视为 O(1)（常数复杂度）。但按 index（下标）插入或按条件查找时，必须从头或尾逐节点定位，完整操作是 O(n)（线性复杂度)。因此面试和设计讨论必须说明“位置是否已获得”，否则只报修改指针的局部复杂度会误导选型。
   • 进阶追问：为何实际业务中 ArrayList（数组列表）中间插入也经常更快？
   • 进阶回答：ArrayList（数组列表）虽然要移动后缀引用，但 System.arraycopy（系统数组复制方法）在连续槽位上批量工作，缓存局部性和底层优化通常较好；LinkedList（链表列表）则要遍历分散节点、分配节点并更新多个引用。真实性能由元素数量、插入位置分布、对象大小和 GC（垃圾回收）共同决定，应压测完整业务操作而不是只比较理论中的一小段动作。

2. 问题（原理题）：LinkedList（链表列表）为什么缓存不友好？

   • 考点：节点分散、指针追逐、对象开销。
   • 回答思路：说明每一步依赖上一步的 next（后继）引用，预取困难。
   • 详细答案：链表元素藏在独立 Node（节点）对象中，访问下一个元素必须先读取当前节点中的 next（后继）引用，再跳到可能远离当前 cache line（缓存行）的地址；这种数据相关的指针追逐限制了 CPU（中央处理器）有效预取。每个节点还带有前驱、后继和对象头，存同样 N 个元素需要更多分配和 GC（垃圾回收）元数据。链表不是不能用，而是要在“已定位局部改链”的特定工作负载中证明其收益。
   • 进阶追问：LinkedList（链表列表）支持 Deque（双端队列）是否意味着它是默认队列实现？
   • 进阶回答：不意味着。它确实支持头尾操作和 null（空值），但节点分配、额外引用和局部性成本仍存在。单线程栈和普通队列通常优先 ArrayDeque（数组双端队列），它以环形数组存放引用且禁止 null（空值）以避免空槽与元素值混淆；需要阻塞生产消费再按容量和调度需求选择 BlockingQueue（阻塞队列）。

3. 问题（项目题）：WMS（仓储管理系统）批次拣货明细为何通常不选 LinkedList（链表列表）？

   • 考点：批量构建、顺序扫描、批量写入、内存成本。
   • 回答思路：匹配数据流而非凭“常插入”印象选型。
   • 详细答案：批次拣货常见流程是按规则生成明细、顺序校验、分组和批量落库，核心动作是尾部构建与顺序遍历，而不是在已经定位的节点前反复插入。ArrayList（数组列表）可按预估明细数申请槽位，引用更紧凑，遍历更利于处理器缓存；批内排序或删除也更容易与数组算法配合。若业务声称需要频繁中间插入，应先检查能否按规则一次排序或分阶段生成，避免用链表掩盖流程设计问题。
   • 进阶追问：如果波次规则确实要求不停改优先级，应该改用 LinkedList（链表列表）吗？
   • 进阶回答：通常不应。动态优先级是调度问题，应明确排序键、更新频率和可恢复性；本地短队列可在重新入队时用 PriorityQueue（优先队列）维护堆序，跨实例或需恢复时用持久调度表。把元素放在 LinkedList（链表列表）里再反复扫描插入，仍是线性定位且没有优先级结构保证。

4. Set（集合接口）：相等、顺序与排序边界

4.1 HashSet（哈希集合）、LinkedHashSet（链式哈希集合）与 TreeSet（树集合）

Set（集合接口）首先回答“什么算同一个元素”。HashSet（哈希集合）把元素作为内部 HashMap（哈希映射）的 key（键）并使用占位 value（值）；本章只需要掌握相等契约：若 equals（相等判断方法）相等，则 hashCode（哈希码方法）必须相等；参与计算的字段放入 Set（集合接口）后不能改变。HashSet（哈希集合）不保证遍历顺序，也不应把一次运行的表面顺序当业务顺序。

TreeSet（树集合）认定 compare(a, b) == 0 的两个元素占同一个排序位置，即使它们的 equals（相等判断方法）返回 false（假值）。比较器与 equals（相等判断方法）不一致时，TreeSet（树集合）可能“吞掉”业务上不同的对象，或者与 HashSet（哈希集合）得到不同元素数；排序键必须能表达你希望的唯一性。不要用只比较金额、只比较优先级这类粗粒度比较器给需要保留多笔订单的集合去重。

数据演绎：IoT（物联网）报警窗口。 规则是“60 秒内相同 deviceId + alarmCode（设备标识加报警编码）只发送一次通知，但累计次数”。T0 第一次进入，Set（集合接口）不存在该稳定 key（键），发送并登记；T0+10 秒第二次进入，命中集合，只递增计数；T0+60 秒清理窗口或过期后，后续告警可重新通知。若把这个 HashSet（哈希集合）做成无界且每实例一份，设备数暴涨、实例扩缩容或重启都会使去重语义失效，因此它只能是优化层。

热门面试题

1. 问题（基础题）：HashSet（哈希集合）为什么能去重，又为什么不保证顺序？

   • 考点：相等契约、哈希结构与顺序契约。
   • 回答思路：说明元素作为 key（键）的两阶段比较，再区分桶布局与业务顺序。
   • 详细答案：HashSet（哈希集合）用元素的 hashCode（哈希码方法）缩小候选范围，再用 equals（相等判断方法）确认业务相等；已存在时 add（添加）不会增加大小。其遍历来自内部哈希结构的槽位与冲突节点布局，容量、哈希分布和实现变化都会影响呈现次序，因此接口没有插入或排序承诺。需要稳定首次到达顺序选 LinkedHashSet（链式哈希集合），需要排序选 TreeSet（树集合），不能靠 HashSet（哈希集合）的偶然顺序实现履约规则。
   • 进阶追问：可变对象放进 HashSet（哈希集合）后修改相等字段会发生什么？
   • 进阶回答：对象仍留在按旧 hashCode（哈希码方法）定位的结构位置，但后续查询按新哈希寻找，可能找不到、删不掉或再次加入一个业务相同对象。应选不可变业务标识作为元素或 key（键），例如支付事件号；状态、更新时间、计数等会变字段不能参与相等契约。

2. 问题（原理题）：TreeSet（树集合）中 Comparator（比较器）返回零而 equals（相等判断方法）不相等有什么风险？

   • 考点：排序等价、集合唯一性与一致性。
   • 回答思路：先说 TreeSet（树集合）的去重依据，再举只比较优先级的反例。
   • 详细答案：TreeSet（树集合）以比较结果决定节点位置，结果为零意味着没有新的排序位置，后续元素被视为重复而不加入。若 Comparator（比较器）只比较履约优先级，两个订单号不同但优先级相同的订单会被当作同一个元素；而 HashSet（哈希集合）按订单号 equals（相等判断方法）可能保留两个，集合间转换就会静默丢数据。比较器应先按业务唯一字段或完整排序元组比较，至少明确这种折叠是业务规则而不是意外。
   • 进阶追问：Comparable（可比较接口）和 Comparator（比较器）如何取舍？
   • 进阶回答：实体有稳定、唯一且普遍适用的自然顺序时可以实现 Comparable（可比较接口）；同一实体需要按承诺时间、距离、金额等多种上下文排序时，使用外置 Comparator（比较器）更清晰。不要为了放入 TreeSet（树集合）强行赋予领域对象唯一“自然顺序”，尤其当排序字段可变时，应在入队前生成不可变调度快照。

3. 问题（项目题）：支付或库存请求为何不能把内存 Set（集合接口）当作幂等最终保障？

   • 考点：进程边界、重启、并发原子性与持久事实。
   • 回答思路：列出多实例、重启、过期和写入失败四个边界，再给持久化方案。
   • 详细答案：内存 Set（集合接口）只存在于单个 JVM（Java 虚拟机）实例，负载均衡会把重复请求送到不同实例，发布或 OOM（内存溢出）重启会丢失记录，窗口清理后也无法证明历史事件是否执行成功。支付与库存副作用必须以稳定业务号在数据库唯一约束、条件更新或 Redis（远程字典服务）原子操作中落下可恢复证据，并记录状态机、重试与对账入口。本地 Set（集合接口）最多减少本实例重复计算，绝不能替代跨实例幂等。
   • 进阶追问：Redis（远程字典服务）去重键是否就足够？
   • 进阶回答：也不总是足够。键过期、网络超时、先写键后业务失败、主从切换和业务状态不一致都要设计。可靠方案应明确“领取、执行、完成”的状态，使用原子条件、过期租约和可补偿记录；资金和库存最终仍通过数据库约束、状态查询与对账收敛，不能把一个 SETNX（不存在则设置）调用当作完整事务。

4.2 有序 Map（映射接口）：LinkedHashMap（链式哈希映射）、TreeMap（树映射）与窗口淘汰

有序 Map（映射接口）解决的是“按什么规则看见和取到映射”，不是替代下一章的 HashMap（哈希映射）桶、树化和扩容原理。LinkedHashMap（链式哈希映射）在哈希定位之外，为每个条目维护前后双向链接；accessOrder（访问顺序标志）为 false（假值）时迭代按插入顺序，为 true（真值）时成功读取会把命中条目移到尾部，因此迭代按“从最久未访问到最近访问”顺序。额外链接让迭代顺序确定，但也增加每条目的引用、访问重连和遍历顺序维护成本；它默认非线程安全，访问顺序模式的读取本身会改变结构顺序，不能把它当只读并发缓存。

flowchart LR
    A["新条目写入 LinkedHashMap（链式哈希映射）"] --> B["挂到 LinkedHashMap.tail（最新条目引用）"]
    B --> C["插入后调用 removeEldestEntry（移除最老条目方法）"]
    C --> D{"超过容量？"}
    D -->|是| E["移除 LinkedHashMap.head（最老条目引用）"]
    D -->|否| F["保留映射"]
    G["命中读取，accessOrder（访问顺序标志）= true（真值）"] --> H["命中条目移到 LinkedHashMap.tail（最新条目引用）"]
    H --> I["迭代顺序：最久未访问 → 最近访问"]

图中容量淘汰由插入新映射之后触发：典型重写是当 size（元素数）大于上限时返回 true（真值），从 LinkedHashMap.head（最老条目引用）删除一个最老条目。单纯读取只在 accessOrder（访问顺序标志）为 true（真值）时重连条目到 LinkedHashMap.tail（最新条目引用），不会自动检查过期或按字节权重淘汰。因此它能实现单实例、固定条目数的 LRU（最近最少使用）近似缓存，却不能解决 TTL（存活时间）、大对象权重、加载回源、并发、跨实例一致性和重启恢复。

TreeMap（树映射）以红黑树按 key（键）的 Comparable（可比较接口）自然顺序或 Comparator（比较器）排序。比较结果为零就代表同一个树位置和同一个 key（键）身份：后写会覆盖 value（值），即使两个 key（键）的 equals（相等判断方法）是 false（假值）。因此比较器必须与业务唯一性一致，或显式把订单号、设备号等稳定第二排序字段加入比较元组。它适合 firstKey（首键获取方法）、lastKey（末键获取方法）、floorKey（向下取整键方法）、ceilingKey（向上取整键方法）和 subMap（子范围映射方法）等范围能力；subMap（子范围映射方法）返回的是受边界限制的实时视图，向该视图写入越界 key（键）会失败，不是独立快照。自然顺序 TreeMap（树映射）不接受 null（空值）键；使用 Comparator（比较器）时，只有该比较器明确支持 null（空值）键才可能接受。这个限制与是否允许 null（空值） value（值）是不同问题。

数据演绎：IoT（物联网）报警窗口的单实例局限。 设 accessOrder（访问顺序标志）为 true（真值）、容量为 3，报警键是 deviceId + alarmCode（设备标识加报警编码）。依次进入 A、B、C 后，顺序为 A→B→C；再次命中 A，顺序变为 B→C→A；D 进入后插入完成，removeEldestEntry（移除最老条目方法）删除 B，得到 C→A→D。这个过程只证明当前实例的最近访问淘汰，不等于 60 秒窗口去重：没有时间检查、不同实例各有一份顺序、重启即丢失；原始报警仍要持久化，跨实例窗口和最终治理仍需 Redis（远程字典服务）、数据库条件记录或消息平台等方案。

本机源码事实核对：JDK（Java 开发工具包）8 的 java/util/LinkedHashMap.java 和 JDK（Java 开发工具包）21 的 java.base/java/util/LinkedHashMap.java 都维护 LinkedHashMap.head（最老条目引用）、LinkedHashMap.tail（最新条目引用）与 accessOrder（访问顺序标志）；这两个字段类型都是条目引用，不是数组下标。插入后通过 afterNodeInsertion（节点插入后处理方法）检查 removeEldestEntry（移除最老条目方法），命中访问通过 afterNodeAccess（节点访问后处理方法）把条目移到 LinkedHashMap.tail（最新条目引用）。JDK（Java 开发工具包）21 的 java.base/java/util/TreeMap.java 以 Comparator（比较器）或 Comparable（可比较接口）路径比较 key（键），并公开上述邻近键与范围视图 API（应用程序接口）。

热门面试题

1. 问题（基础题）：LinkedHashMap（链式哈希映射）如何用 accessOrder（访问顺序标志）和 removeEldestEntry（移除最老条目方法）实现 LRU（最近最少使用）？

   • 考点：双向链接、访问重排、插入后淘汰和容量边界。
   • 回答思路：先区分插入顺序和访问顺序，再说明读取重排、插入后检查、头部淘汰。
   • 详细答案：创建 LinkedHashMap（链式哈希映射）时将 accessOrder（访问顺序标志）设为 true（真值），命中读取会把条目移动到 LinkedHashMap.tail（最新条目引用），LinkedHashMap.head（最老条目引用）因此是最久未访问条目。覆盖 removeEldestEntry（移除最老条目方法）并在 size（元素数）超过上限时返回 true（真值），新映射插入后会删除 LinkedHashMap.head（最老条目引用）。这些字段是双向链接中的条目引用，不是队列数组下标；触发点是新映射插入后，不是每次读取、也不是后台定时扫描。因此它只表达按条目数的单机 LRU（最近最少使用）近似淘汰，不能自动实现过期、权重、批量逐出或跨进程缓存一致性。
   • 进阶追问：为什么访问顺序的 LinkedHashMap（链式哈希映射）不能直接当多线程读缓存？
   • 进阶回答：在访问顺序模式下，成功读取要重连当前条目并更新 modCount（结构修改计数），逻辑读实际包含结构写；多个线程同时读取或遍历与读取交错都没有同步保障。外层锁能提供正确性但可能形成热点，生产缓存还应评估容量、过期、加载、统计、淘汰和跨实例一致性，通常优先成熟缓存组件或 Redis（远程字典服务）。

2. 问题（原理题）：TreeMap（树映射）为何可能把两个 equals（相等判断方法）不同的 key（键）当成同一个？

   • 考点：比较器零值、红黑树位置与映射覆盖语义。
   • 回答思路：先说明树按比较路径定位，再说明比较结果为零的覆盖和业务风险。
   • 详细答案：TreeMap（树映射）沿红黑树用 Comparable（可比较接口）或 Comparator（比较器）比较 key（键），结果小于零走左、大于零走右、等于零则命中已有树节点并覆盖其 value（值）。所以键身份由比较结果定义，不由 equals（相等判断方法）单独定义。若比较器只比较订单优先级，订单号不同但优先级相同的两笔订单会覆盖；若需要“先按优先级排序、再按订单号唯一”，比较器必须把订单号作为第二比较字段。
   • 进阶追问：TreeMap（树映射）的范围查询有什么优势和边界？
   • 进阶回答：firstKey（首键获取方法）、lastKey（末键获取方法）、floorKey（向下取整键方法）和 ceilingKey（向上取整键方法）能在排序树上找到边界，subMap（子范围映射方法）可得到限定上下界的实时 NavigableMap（可导航映射接口）视图，适合按承诺时间或分数区间扫描。它不是快照，底层修改会反映；向范围视图写入越界键会抛异常。自然顺序不支持 null（空值）键，使用自定义 Comparator（比较器）也必须显式处理空值和比较一致性。

3. 问题（项目题）：IoT（物联网）报警风暴为什么不能只靠 LinkedHashMap（链式哈希映射）淘汰？

   • 考点：LRU（最近最少使用）与时间窗口差异、实例边界、审计与最终一致性。
   • 回答思路：用 A、B、C、A、D 演绎说明访问淘汰，再拆解时间、持久化和跨实例问题。
   • 详细答案：LinkedHashMap（链式哈希映射）可在单实例内按设备报警键保存最近访问项，容量满后淘汰最久未访问项，适合限制临时去重索引的内存；但“最近最少使用”不等于“60 秒内只通知一次”，因为热键可能永不淘汰而冷键可能在 1 秒内被容量挤掉。多实例的映射互不共享，扩缩容和重启都会丢失状态；因此原始报警必须先持久化，跨实例去重用 Redis（远程字典服务）原子窗口、数据库唯一/状态记录或消息平台分区治理，并为重复、延迟和失败保留审计与补偿入口。
   • 进阶追问：LinkedHashSet（链式哈希集合）或 TreeSet（树集合）能替代这个方案吗？
   • 进阶回答：LinkedHashSet（链式哈希集合）只能保留插入顺序的元素，不记录 value（值）、不会因访问更新顺序，也没有 removeEldestEntry（移除最老条目方法）回调；TreeSet（树集合）按排序键维护有序去重，适合范围而非最近访问淘汰。它们都无法解决跨实例、持久化和时间窗口一致性，只应作为单进程局部结构按语义选择。

5. Queue（队列接口）与 Deque（双端队列）：环形数组、堆和阻塞语义

5.1 ArrayDeque（数组双端队列）：单线程栈和队列的默认选择

ArrayDeque（数组双端队列）以可扩展环形数组保存元素，ArrayDeque.head（队头下标）指向首元素，ArrayDeque.tail（下一个可写槽位下标）指向下一个可写槽位；下标到末端后回绕到零。JDK（Java 开发工具包）21 源码 java.base/java/util/ArrayDeque.java 维护 ArrayDeque.head（队头下标）、ArrayDeque.tail（下一个可写槽位下标）和 elements（元素数组），容量不足时重新分配并把逻辑顺序元素搬到新数组。它禁止 null（空值），因为空槽位用于表达无元素，允许 null（空值）会让 poll（尝试出队）结果无法区分“队列为空”和“元素就是空值”。

flowchart LR
    H["ArrayDeque.head（队头下标）= 6"] --> S6["槽位 6：A"] --> S7["槽位 7：B"] --> S0["槽位 0：C"] --> T["ArrayDeque.tail（下一个可写槽位下标）= 1"]
    E["空槽位：null（空值）"] --- S1["槽位 1"]
    N["offerLast（队尾入队） D"] --> S1
    P["pollFirst（队头出队）"] --> S6

图中的物理槽位顺序是 6、7、0，而逻辑队列顺序仍是 A、B、C。出队后要清空旧槽位引用以便 GC（垃圾回收）；当环形数组装满时扩容并保持逻辑顺序。两端常规 addFirst（队头加入）、addLast（队尾加入）、pollFirst（队头取出）、pollLast（队尾取出）近似 O(1)（常数复杂度），但扩容仍是一次性复制成本。

热门面试题

1. 问题（基础题）：为什么 ArrayDeque（数组双端队列）通常替代 Stack（栈类）或 LinkedList（链表列表）？

   • 考点：环形数组、两端操作、对象分配与历史 API（应用程序接口）。
   • 回答思路：说明两端操作都是常规常数成本，再比较同步和节点开销。
   • 详细答案：ArrayDeque（数组双端队列）把元素引用保存在环形数组，两端进出无需为每个元素创建 Node（节点），局部性和内存密度通常优于 LinkedList（链表列表）。Stack（栈类）是历史类，继承 Vector（动态数组类）且带不必要的同步语义；ArrayDeque（数组双端队列）通过 push（压栈）/pop（弹栈）或队列 API（应用程序接口）表达意图更清楚。前提是单线程或外部同步，且不需要存放 null（空值）。
   • 进阶追问：为什么 ArrayDeque（数组双端队列）禁止 null（空值）？
   • 进阶回答：其内部使用 null（空值）表示未占用槽位，poll（尝试出队）返回 null（空值）也表示队列空；若允许元素值也是 null（空值），调用者无法区分“取到了空元素”和“没有元素”。这种限制换来简单、快速的空槽判断；业务若确实需表达空值，应使用显式占位对象或 Optional（可选值容器）语义，而不是把 null（空值）塞入队列。

2. 问题（原理题）：环形数组为什么不需要每次队头出队都搬移全部元素？

   • 考点：逻辑下标、取模回绕、槽位复用。
   • 回答思路：解释 ArrayDeque.head（队头下标）/ArrayDeque.tail（下一个可写槽位下标）移动，区分出队和扩容。
   • 详细答案：队头出队只读取 ArrayDeque.head（队头下标）槽位、置为 null（空值）并把 ArrayDeque.head（队头下标）移动到下一个位置；队尾入队只在 ArrayDeque.tail（下一个可写槽位下标）写入并前移。逻辑序列通过回绕下标表达，不像普通数组删除头元素那样整体左移。只有容量耗尽需要更大数组时，才把当前逻辑序列按顺序复制到新数组，这也是它在常规队列操作下保持低成本的原因。
   • 进阶追问：是否可以把 ArrayDeque（数组双端队列）共享给多个 Runner（执行器）线程？
   • 进阶回答：不可以直接共享读写。多个线程同时更新 ArrayDeque.head（队头下标）、ArrayDeque.tail（下一个可写槽位下标）或数组槽位会破坏状态，fail-fast（快速失败）也不能保护正确性。若是多个生产者消费者，应使用 BlockingQueue（阻塞队列）或专用并发队列；若是单线程事件循环，每个循环维护私有 ArrayDeque（数组双端队列）才符合其所有权模型。

3. 问题（项目题）：异步导出的分页缓冲怎样使用队列而不制造 OOM（内存溢出）？

   • 考点：有限批次、生产消费速率差、内存上限。
   • 回答思路：定义批次大小和队列容量，说明满时的行为。
   • 详细答案：把数据库读取结果封装成固定大小页，而不是单行对象无限入队；若读取和写出在同一线程，可用 ArrayDeque（数组双端队列）只保存少量待处理页。多线程流水线则用有界 BlockingQueue（阻塞队列），容量按“页大小 × 允许驻留页数”计算；队列满时读取线程超时、暂停或失败回写，让压力可见。每页写完立即释放引用并记录检查点，避免队列成为隐藏的全量结果集。
   • 进阶追问：为什么不把队列容量简单设为 Integer.MAX_VALUE（最大整型值）？
   • 进阶回答：这等于声明应用堆是缓冲上限，无法将数据库读取速度限制在文件写出速度之内。高峰或下游卡住时，任务页会持续累积，先表现为 GC（垃圾回收）频繁、延迟上升，最终 OOM（内存溢出）；恢复时还会有很长尾部积压。有界容量把问题提前变成可处理的超时、拒绝或持久化转移。

5.2 PriorityQueue（优先队列）与 BlockingQueue（阻塞队列）：局部有序和背压

PriorityQueue（优先队列）是基于数组的平衡二叉堆。默认是最小堆，或由 Comparator（比较器）定义“堆顶最优”：数组下标 i 的子节点是 2*i+1 与 2*i+2，每个父节点不大于其后代。入队时上浮，出队时用末元素替换堆顶再下沉；因此 peek（查看队头）和 poll（尝试出队）得到的是最优元素，但遍历顺序不是全局排序。

flowchart TD
    R["3：堆顶，最小优先"] --> A["8"]
    R --> B["5"]
    A --> C["12"]
    A --> D["10"]
    B --> E["7"]
    B --> F["9"]
    X["插入 4：末尾 → 与 5 比较上浮 → 与 3 比较停止"]

图中只有父节点与后代的偏序得到保证，8 可以排在 5 前面而不违反最小堆规则。要得到全局排序，连续 poll（尝试出队）或复制后排序；直接 for-each（逐个遍历）打印 PriorityQueue（优先队列）不能作为订单优先级清单。

BlockingQueue（阻塞队列）提供三组不同的失败语义：put（阻塞入队）/take（阻塞出队）可无限等待但可被中断；offer（尝试入队）/poll（尝试出队）立即返回；带 timeout（超时）的 offer（尝试入队）/poll（尝试出队）允许在明确时间内等待，并同样可能抛 InterruptedException（中断异常）。它们都不提供通用 close（关闭）语义：消费者关闭时需要用取消标记、线程中断或约定的 poison pill（毒丸对象）结束，并确保生产者停止提交。Java（编程语言）内存队列也不是 Kafka（分布式日志消息系统）或 RocketMQ（分布式消息队列）：它没有跨进程持久化、副本、消费位点或宕机恢复。

Runner（执行器）洪峰演绎。 假设 20 个消费者合计稳定处理 400 个任务/秒，入口瞬时接受 2 000 个任务/秒，持续 30 秒：净积压 （2000 - 400）×30 = 48 000 个任务。若每个任务连同上下文平均占 16 KiB（千字节），仅队列引用到的对象约为 750 MiB（兆字节），还没算任务执行中的对象、线程栈和其他请求。无界 LinkedBlockingQueue（链表阻塞队列）只是把拒绝延后；有界队列例如 2 000 页容量会在约 1.25 秒暴露压力，调用方可拒绝、降级、限流或把已持久化任务转交给可靠调度系统。

热门面试题

1. 问题（基础题）：PriorityQueue（优先队列）为什么不能保证遍历结果全局有序？

   • 考点：堆不变量、堆顶与数组布局。
   • 回答思路：说明堆只约束父子/后代关系，再给正确获取全序的方法。
   • 详细答案：PriorityQueue（优先队列）维护的是堆不变量：最优元素在堆顶，每个父节点不劣于其子孙；兄弟节点和不同子树之间没有完整大小关系。内部数组按层存放堆，Iterator（迭代器）只是扫描该数组，所以遍历顺序无需排序。需要一个个取最高优先级任务时使用 poll（尝试出队）；需要展示完整排序清单时复制元素后排序，不能把遍历输出当成调度证明。
   • 进阶追问：入队后修改优先级字段为什么危险？
   • 进阶回答：堆只在插入、删除等操作中执行上浮或下沉；元素已在堆内时改字段，容器不知道要重建位置，旧节点会留在错误层级，peek（查看队头）可能不是实际最高优先级。应让排序键不可变；优先级变化时删除旧任务并以新快照重新入队，或用带版本的持久调度记录过滤旧条目。

2. 问题（原理题）：ArrayBlockingQueue（数组阻塞队列）、LinkedBlockingQueue（链表阻塞队列）、SynchronousQueue（同步移交队列）如何选？

   • 考点：容量、移交语义、对象成本和背压。
   • 回答思路：先定义允许多少排队，再讨论结构与线程池策略。
   • 详细答案：容量是第一决策。ArrayBlockingQueue（数组阻塞队列）强制显式固定容量，适合能估计内存预算的稳定流水线；LinkedBlockingQueue（链表阻塞队列）可指定容量，但默认近似无界，生产任务必须避免默认构造；SynchronousQueue（同步移交队列）没有缓冲，每次提交必须直接交给消费者，适合希望以扩线程或快速拒绝替代排队的策略。三者都只能协调本 JVM（Java 虚拟机）线程，任务必须恢复时要先落持久层。
   • 进阶追问：BlockingQueue（阻塞队列）的关闭和中断边界是什么？
   • 进阶回答：BlockingQueue（阻塞队列）没有标准 close（关闭）操作。任务系统停止时先停止生产，再中断等待中的消费者或投递约定的 poison pill（毒丸对象）；消费者捕获 InterruptedException（中断异常）后应恢复中断标记或结束循环，不能吞掉后继续永久工作。若任务有业务副作用，停止前后都要持久化领取状态和检查点，线程中断只改变本地等待，不自动回滚外部调用。

3. 问题（项目题）：如何用有界队列治理 Runner（执行器）任务洪峰？

   • 考点：背压、拒绝、降级、持久化与可观测性。
   • 回答思路：先容量预算，再设计满队列分流和任务恢复，最后给监控指标。
   • 详细答案：按任务平均内存、允许排队时长、消费者吞吐和堆预算设置有界 ArrayBlockingQueue（数组阻塞队列）或显式容量 LinkedBlockingQueue（链表阻塞队列）。提交端用有限 timeout（超时）的 offer（尝试入队）；满时将可延迟任务落库等待扫描、对可降级任务返回繁忙、对必须执行任务保留可靠状态并告警，不能在 Web（万维网）线程无限阻塞。监控 queueSize（队列大小）、任务等待时间、activeCount（活跃线程数）、rejectCount（拒绝次数）、处理耗时和失败重试，按持续积压而非单次高峰扩容。
   • 进阶追问：为什么“加大队列”常使事故更难恢复？
   • 进阶回答：更大队列延后了拒绝，却增加堆驻留、GC（垃圾回收）抖动和恢复后的历史任务尾部；任务可能已过期、依赖数据已变化，积压越久越难保证顺序和幂等。应把容量视为延迟预算的一部分，队列满后主动限速、降级或持久化转移，让系统在压力下保留核心路径和可恢复证据。

6. 设计思想、线上排查与项目话术

6.1 把集合放回系统边界：空间、时间、语义与背压

集合不是孤立算法题，而是系统边界的缩影：动态数组用 Space-Time Tradeoff（空间换时间）减少多数追加的复制次数；链表用更多对象和引用换局部改链；Set（集合接口）用相等契约约束重复；堆以局部有序换取快速拿到最优项；队列用 Buffering（缓冲）实现时间解耦，再用 Backpressure（背压）防止缓冲把压力藏进内存。

可复述的话术：

在 WMS（仓储管理系统）批次拣货里，我按波次明细数预估 ArrayList（数组列表）容量，顺序构建和批量写库，不因为“中间插入快”就选择 LinkedList（链表列表）。订单履约把幂等领取与优先级调度拆开：稳定事件号先在持久层保证唯一，再用 PriorityQueue（优先队列）处理单实例待执行排序，优先级字段做成不可变快照。Runner（执行器）用有界 BlockingQueue（阻塞队列）和超时提交，把洪峰变成可观测的拒绝、降级或持久化转移；IoT（物联网）报警用有界时间窗口 Set（集合接口）做实例内降噪，但跨实例一致性仍交给 Redis（远程字典服务）和原始告警存储。这样数据结构只承担它能承担的局部职责，业务正确性有持久化和状态机兜底。

热门面试题

1. 问题（基础题）：Iterator（迭代器）的 fail-fast（快速失败）是否能保证线程安全？

   • 考点：错误检测、可见性与并发控制边界。
   • 回答思路：先说 modCount（结构修改计数）检测，再明确它不是锁和内存模型保证。
   • 详细答案：多数普通集合的 Iterator（迭代器）保存预期结构修改计数，遍历时发现实际 modCount（结构修改计数）变化通常抛 ConcurrentModificationException（并发修改异常），用于尽早暴露错误使用。该检查不加锁、不建立线程间可见性，也无法穷尽所有竞争时序；没有异常不等于数据正确。线程安全需要明确所有权、锁、并发容器或不可变快照，fail-fast（快速失败）只能辅助发现问题。
   • 进阶追问：线上偶发 ConcurrentModificationException（并发修改异常）怎样排查？
   • 进阶回答：先从异常栈找到创建 Iterator（迭代器）和执行 next（取得下一项）的位置，再搜索同一集合引用的 add（添加）、remove（移除）、clear（清空）路径及异步回调。确认集合是请求私有还是共享；请求私有场景改用迭代器删除或分阶段收集，共享场景定义单写者、同步或并发策略。不要只捕获异常重试，否则可能重复执行库存、支付或通知副作用。

2. 问题（原理题）：队列如何体现时间解耦，又为何必须配合 Backpressure（背压）？

   • 考点：缓冲、吞吐差、容量边界与失败模式。
   • 回答思路：用上游快于下游的速率差解释，再说明有界容量把风险显式化。
   • 详细答案：队列让生产者不必等待每个消费者完成，短时流量可先进入缓冲，消费者按自己的速度处理，这就是时间解耦。但若平均生产速率长期大于消费速率，积压必然线性增长；无界内存队列只把拒绝推迟为 GC（垃圾回收）抖动和 OOM（内存溢出）。有界容量、超时提交、限流、拒绝、降级和持久化转移构成 Backpressure（背压），让上游看见下游能力并作出业务选择。
   • 进阶追问：为什么 Java（编程语言）BlockingQueue（阻塞队列）不能替代 MQ（消息队列）？
   • 进阶回答：BlockingQueue（阻塞队列）只在一个 JVM（Java 虚拟机）内存中协调线程，没有持久化、副本、跨进程消费、位点、重放和故障转移；进程重启通常丢失队列内容。它适合进程内流水线与线程池工作队列，必须跨实例可靠投递、恢复或审计的任务要使用持久化任务表或专业 MQ（消息队列），并继续处理幂等、顺序和积压治理。

3. 问题（项目题）：报警去重、订单优先级和异步导出如何共享一套集合治理原则？

   • 考点：语义拆分、容量、可恢复性与观测。
   • 回答思路：分别给三种结构的局部职责，再归纳状态和资源边界。
   • 详细答案：报警去重用 Set（集合接口）表达时间窗口内的相等语义，但设置最大键数、过期和持久审计；订单优先级用 PriorityQueue（优先队列）表达“下一件最优”，但排序键不可变且持久状态决定最终领取；异步导出用 List（列表接口）保存有限页、用有界队列衔接读取和写出，但检查点决定恢复。三者共同点是内存结构只缓存有限、可丢失的派生态，业务事实、幂等和恢复放在持久化状态机；同时观测大小、等待时间、淘汰和拒绝，而不是只观察 CPU（中央处理器）。
   • 进阶追问：发生 OOM（内存溢出）后，为什么不能只增加 Heap（堆）？
   • 进阶回答：增大 Heap（堆）可能延后爆炸，却保留无界增长、错误生命周期和下游失速根因，并可能增加 GC（垃圾回收）停顿。应保留 Heap（堆）转储，找到最大集合及其到垃圾回收根的引用链，结合任务速率、缓存命中和队列积压定位持续写入者；先限流、暂停或清理止血，再补容量、过期、分页和持久化恢复策略，最后以压测验证。

7. 复习清单

• 能画出 Iterable（可迭代接口）、Collection（集合接口）、List（列表接口）、Set（集合接口）、Queue（队列接口）、Deque（双端队列）与 Map（映射接口）的边界。
• 能用顺序、重复、排序、按 index（下标）/key（键）、FIFO（先进先出）/LIFO（后进先出）/优先级、容量和并发完成选型。
• 能推演 ArrayList（数组列表）10 → 15 → 22 的容量、复制数和均摊成本，并说明这不是接口契约。
• 能说清引用槽位连续而对象本体不承诺连续，以及 LinkedList（链表列表）完整插入成本。
• 能解释 HashSet（哈希集合）无顺序、LinkedHashSet（链式哈希集合）插入顺序、TreeSet（树集合）比较结果为零的去重风险。
• 能画出 ArrayDeque（数组双端队列）回绕和 PriorityQueue（优先队列）堆顶，说明优先队列遍历不全局有序。
• 能给 Runner（执行器）说清有界 BlockingQueue（阻塞队列）、超时、拒绝、降级、持久化和中断边界。

8. 版本与参考来源

• 本机 JDK（Java 开发工具包）8：/Users/Lever/Library/Java/JavaVirtualMachines/corretto-1.8.0_402/Contents/Home/src.zip：java/util/ArrayList.java、java/util/LinkedList.java。
• 本机 JDK（Java 开发工具包）21：/Users/Lever/Library/Java/JavaVirtualMachines/openjdk-21.0.2/Contents/Home/lib/src.zip：java.base/java/util/ArrayList.java、ArrayDeque.java、PriorityQueue.java 与 java.util.concurrent（Java 并发工具包）队列实现。
• JDK（Java 开发工具包）21 ArrayList（数组列表）API（应用程序接口）
• JDK（Java 开发工具包）21 Queue（队列接口）API（应用程序接口）
• JDK（Java 开发工具包）21 PriorityQueue（优先队列）API（应用程序接口）
• JDK（Java 开发工具包）21 BlockingQueue（阻塞队列）API（应用程序接口）