LCZ's world

java知识1

Mon, 21 Sep 2026 00:00:00 GMT

[ ] 是否借助ai

1.java中的序列化和反序列化

序列化就是把内存中的 Java 对象转成二进制字节流，这样才能存到硬盘或者通过网络发给别的机器。反序列化就是反过来，把字节流还原成 Java 对象。硬盘和网络只认 0 和 1，不认 Java 对象，所以必须有这么一层转换。

序列化的内容一般是可保存、可传输、可打印的形式。对于密码等敏感字段，要防止序列化。

1）怎么做序列化：类必须实现 Serializable 接口，这玩意儿就是个许可证，没它 JDK 序列化机制压根不让你序列化

2）怎么防序列化：敏感字段比如密码，加个 transient 关键字，序列化的时候自动跳过

3）怎么稳（保持兼容性）：显式定义 serialVersionUID，相当于给类打个版本戳，防止改了类结构后反序列化旧数据时报错(自动转换走默认值或默认处理)

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String username;
    private transient String password; // 不参与序列化
    private int age;
}

对象不能直接传输：

对象在 JVM 里是"立体"的，到处都是引用关系。比如某个字段指向服务器内存地址 0x1234 处的另一个对象，这地址只在当前 JVM 有效，传到网络另一端，人家客户端的 0x1234 地址上根本不是同一个东西。
序列化要干的活就是把这些引用关系"压扁"，把整个对象图递归地转成一段自包含的字节序列。接收端拿到后，反序列化时在自己的堆上重建整个对象图，引用关系照样能还原回来。

静态变量（static）不参与序列化，

序列化存的是对象的状态。静态变量属于类。

JDK自带序列化的问题

性能差，字节流过大，速度慢
跨语言不友好，py，go读不懂，无法互通常用JSON序列化解决，虽然性能一般，但可读性好。RPC框架用Protobuf、Hessian等

面试官追问

提问：transient 和 static 修饰的字段都不会被序列化，它们有什么区别？

回答：本质不同。static 字段属于类，压根就不是对象状态的一部分，所以不存在"序列化不序列化"的问题，它就不在序列化的范畴内。transient 是专门告诉序列化机制"这个实例字段我不想存"，比如密码、缓存这类不适合持久化的数据。一个是"不归你管"，一个是"归你管但我不让你存"。

提问：如果父类没有实现 Serializable，子类实现了，序列化子类对象时父类的字段会怎样？

回答：父类字段不会被序列化。反序列化时，子类字段正常恢复，但父类字段会调用父类的无参构造器重新初始化。如果父类没有无参构造器，反序列化直接报错。所以如果需要父类字段也参与序列化，父类也得实现 Serializable。

提问：Externalizable 接口和 Serializable 有什么区别？

回答：Serializable 是自动序列化，JDK 帮你搞定所有字段。Externalizable 是手动挡，必须自己实现 writeExternal 和 readExternal 方法，一个字段一个字段地写出去、读进来。好处是完全可控，可以做定制优化；坏处是麻烦，漏写一个字段就丢数据。性能要求高的场景可以考虑，一般业务代码用 Serializable 就够了。

提问：为什么说反序列化是 Java 安全漏洞的重灾区？

回答：反序列化会触发对象的构造过程，如果恶意构造的字节流能让某些类的特定方法被执行，就可能造成远程代码执行。典型的就是利用 Commons-Collections、Fastjson 这些库里的 gadget chain，攻击者只要找到一条能从反序列化入口通往危险方法的调用链，就能在服务器上执行任意代码。防御手段包括：升级有漏洞的依赖库、配置反序列化白名单、用 JSON 替代 Java 原生序列化。

解释：反序列化不只是“把数据读回来”，它还会根据字节流里的类信息，去创建对象、调用对象的方法。攻击者一旦能控制这段字节流，就可能让服务器执行他想要的代码。攻击者可以伪造一段序列化数据，里面指定：

要反序列化成哪个类；
类的字段值是什么；
这些字段又引用了哪些其他对象。

2.java中HashMap的原理

HashMap 底层就是一个数组，结合链表和红黑树来解决冲突。

它的工作原理其实很简单，主要说这 3 点:

1）怎么存

存一个 Key-Value 时，先算 Key 的 hashCode，然后用 (table.length-1) & hash 算出应该放在数组的哪个下标位置。

2）冲突了怎么办

两个不同的 Key 算出来下标一样，就叫哈希冲突。HashMap 的解决办法是用链表把它们串起来，JDK 8 做了优化，如果同一个下标下的链表超过 8 个节点（且数组长度大于等于 64），就转成红黑树，查找速度从 O(n) 变成 O(logn)。

3）扩容机制

数组长度是有限的，存多了会挤。HashMap 有个负载因子默认 0.75，数组用了 75% 就自动扩容，把数组大小翻倍，然后把所有数据重新算位置放到新数组里。这个操作叫 rehash，比较耗性能，所以初始化时最好给个预估容量。

HashMap 是非线程安全的

多线程环境下可能出问题，比如数据覆盖或者死循环，这时候应该用 ConcurrentHashMap。

hashCode 和 equals 的重要性

HashMap 的 key 必须正确实现 hashCode() 和 equals() 方法。hashCode() 决定元素存在哪个桶，equals() 决定两个 key 是不是同一个。

put 的时候，如果两个 key 的 hashCode() 相同但 equals() 返回 false，它们会被当成不同的 key 存在同一个桶的不同位置。如果 hashCode() 实现得不好导致分布不均，或者 equals() 写错了，会导致元素找不到或者重复插入。跳转到解释equals和hashcode的关系

hashmap的扩容机制

默认容量16

HashMap 的扩容由负载因子控制，默认是 0.75。意思就是当元素数量超过容量 × 0.75 时触发扩容。比如初始容量 16，阈值就是 12，存第 13 个元素时就会扩容。

扩容的规则很简单：容量直接翻倍，从 16 变 32，32 变 64，始终保持 2 的幂次。扩容后所有元素要重新分配位置，这个过程叫 rehashing。即每个元素的存储位置会根据新容量的大小重新计算，并移动到新的数组中。

面试官追问

提问：为什么链表转红黑树的阈值是 8，不是 6 或者 10？回答：根据泊松分布计算，在负载因子 0.75 的情况下，一个桶里元素个数达到 8 的概率已经非常低了，大概是千万分之六。选 8 是因为这个概率下转红黑树基本只会在 hash 分布极差的时候发生，正常情况几乎不会触发，既保证了极端情况的性能，又避免了频繁转换的开销。

提问：JDK 8 改成尾插法就完全线程安全了吗？回答：没有。尾插法只是解决了扩容时链表成环的问题，但 HashMap 本身还是非线程安全的。并发 put 的时候还是可能丢数据，比如两个线程同时往一个空桶插入，后插入的会覆盖先插入的。多线程场景必须用 ConcurrentHashMap。

提问：HashMap 的 key 可以用 null 吗？回答：可以，HashMap 允许一个 null key。存的时候会把 null key 的 hash 值当成 0，固定放在数组下标 0 的位置。但 ConcurrentHashMap 不允许 null key，因为多线程场景下无法区分"key 不存在"和"key 存在但 value 是 null"。

3.解释equals和hashcode的关系

契约规定：equals 相等的对象，hashCode 必须相等；但hashCode 相等的对象，equals 不一定相等。先比较hashcode后比较equals。

这条规则在使用 HashMap、HashSet 这类基于哈希的集合时特别重要。这些集合判断两个对象是否相同，先比 hashCode，hashCode 不等直接认为是两个不同对象，根本不会调 equals。所以如果只重写 equals 不重写 hashCode，集合就废了。

默认的hashcode返回对象的内存地址，equals默认比较的是引用地址，默认是==

重写可以用lombok自动生成。

提问：HashMap 的 key 用可变对象有什么风险？回答：如果 key 是可变对象，存进去之后又改了参与 hashCode 计算的字段，那这个 entry 就再也找不到了。因为修改后 hashCode 变了，HashMap 会到新的槽位去找，但数据还在老槽位，get 返回 null，remove 也删不掉，造成内存泄漏。所以 HashMap 的 key 最好用不可变对象，String、Integer 这些都可以，自定义类当 key 要特别小心。

重写 equals 不重写 hashCode，会出现equals相同但hashcode不同，可能会导致业务逻辑上重复的元素被重复添加，查找找不到，例如key是对象的情况，查找的凭据对象是新new的。

参考资料

面试鸭

mq学习过程中的疑问复盘

Fri, 18 Sep 2026 00:00:00 GMT

[x] 是否借助ai

本次对话复盘总结

本次对话围绕 Java / Spring AMQP 中的几个核心概念展开：

匿名内部类与嵌套接口
Lambda 表达式
Java Future
SLF4J 日志占位符与异常处理
RabbitMQ ReturnCallback 触发机制

1. `ReturnsCallback` 是类还是方法？为什么里面还能有方法？

结论

RabbitTemplate.ReturnsCallback 是一个接口，不是方法。
setReturnsCallback(...) 才是方法。

代码拆解

rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        // ...
    }
});

部分	说明
`setReturnsCallback`	RabbitTemplate 的方法，用于设置回调
`RabbitTemplate.ReturnsCallback`	定义在 RabbitTemplate 内部的接口
`returnedMessage`	接口中的抽象方法，此处被实现
`new ... { ... }`	匿名内部类，创建接口的实现类对象

关键点

new 接口() { ... } 是匿名内部类语法。
大括号里写的是接口方法的实现，所以“里面还能有方法”很正常。
等价于先定义一个实现类，再 new 它。

2. 类里面的接口（嵌套接口）

结论

Java 允许在类里面定义接口，称为成员接口 / 嵌套接口。

public class RabbitTemplate {
    public interface ReturnsCallback {
        void returnedMessage(ReturnedMessage returned);
    }
}

特点

默认隐式 static
即使不写 static，成员接口也是静态的，不依赖外部类对象。
访问需要带外部类名
```
RabbitTemplate.ReturnsCallback
```
编译后生成 外部类$内部接口.class
例如 RabbitTemplate$ReturnsCallback.class。
设计好处
- 归属清晰：一看就知道属于 RabbitTemplate
- 避免命名污染
- 方便组织相关代码

常见例子

Map.Entry 就是定义在 Map 接口内部的嵌套接口。

3. 为什么可以用 Lambda 表达式？

结论

因为 ReturnsCallback 是函数式接口——只有一个抽象方法。
Java 8 规定：函数式接口可以用 Lambda 创建实例。

函数式接口定义

public interface ReturnsCallback {
    void returnedMessage(ReturnedMessage returned); // 唯一抽象方法
}

匿名内部类 → Lambda

// 匿名内部类
new RabbitTemplate.ReturnsCallback() {
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        log.error("触发return callback,");
        log.debug("exchange: {}", returned.getExchange());
    }
}

// Lambda
returned -> {
    log.error("触发return callback,");
    log.debug("exchange: {}", returned.getExchange());
}

原理：目标类型推断

setReturnsCallback(ReturnsCallback callback) 需要 ReturnsCallback 类型，
编译器知道该接口只有一个抽象方法，因此能推断出：

参数类型是 ReturnedMessage
方法体就是 Lambda 的 { ... }

注意

Lambda 和匿名内部类不完全等价（this 指向不同，底层实现不同）。
只有函数式接口才能用 Lambda。

4. Java 的 Future 是什么？

一句话

Future 是 java.util.concurrent 下的接口，表示异步任务的未来结果，类似“取餐号”。

核心方法

方法	作用
`get()`	阻塞等待结果
`get(timeout, unit)`	超时等待
`isDone()`	任务是否完成
`isCancelled()`	是否取消
`cancel(...)`	尝试取消

基本用法

ExecutorService pool = Executors.newFixedThreadPool(2);

Future<Integer> future = pool.submit(() -> {
    Thread.sleep(1000);
    return 42;
});

// 可以先做别的事
Integer result = future.get(); // 阻塞取结果

局限性

获取结果只能阻塞或轮询。
不方便组合多个 Future。
没有回调机制。
异常处理麻烦（ExecutionException）。

增强版：CompletableFuture

支持链式调用、组合、回调、手动完成、更好的异常处理。

CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> 42);
cf.thenAccept(r -> System.out.println("结果：" + r));

FutureTask

FutureTask 同时实现 Runnable 和 Future，可交给线程执行并取结果。

5. `log.error` 为什么第一个没有 `{}` 占位符？

结论

因为 SLF4J 对 Throwable（异常） 有特殊处理：
异常作为最后一个参数传入时，会自动打印堆栈，不需要 {}。

两条日志对比

log.error("处理确认结果异常", ex);
// ex 是异常，直接作为最后一个参数，自动打印堆栈

log.error("发送消息失败，收到 nack, reason : {}", result.getReason());
// result.getReason() 是普通对象，必须用 {} 占位

SLF4J 参数匹配规则

先看消息中有几个 {}。
如果最后一个参数是 Throwable，且占位符数量少于参数数量，则该异常不参与占位符填充，专门用于打印堆栈。
剩余参数按顺序填充 {}。

正确写法

写法	含义
`log.error("消息", ex)`	异常打印堆栈，无需 `{}`
`log.error("消息 {}", obj)`	普通对象用 `{}` 填充
`log.error("消息 {}", ex)`	错误！异常被当普通参数，不打印堆栈
`log.error("消息 {} ", msg, ex)`	`msg` 填充 `{}`，`ex` 打印堆栈

6. ReturnCallback 是怎么触发的？

一句话

消息到达 Exchange，但路由不到任何队列，且开启了 mandatory=true，Broker 会把消息退回，Spring AMQP 收到后触发 ReturnsCallback。

与 ConfirmCallback 的区别

回调	触发时机	关注点
`ConfirmCallback`	消息到达 Exchange（或未到达）	是否成功到交换机
`ReturnsCallback`	到达 Exchange 但路由不到队列	是否成功进队列

触发前提

消息到达 Exchange，但路由失败
- Exchange 存在
- routingKey 找不到匹配的 Binding
- 没有任何队列接收

必须开启 mandatory 或 publisher-returns

spring:
  rabbitmq:
    publisher-returns: true
    template:
      mandatory: true

或代码：

rabbitTemplate.setMandatory(true);

触发流程

生产者 publish
      │
      ▼
消息到达 Exchange
      │
      ├── 能路由到队列 ──► 入队，结束（不触发）
      │
      └── 路由不到队列
              │
              ├── mandatory=false ──► 丢弃，不触发
              │
              └── mandatory=true
                      │
                      ▼
            Broker 退回（Basic.Return）
                      │
                      ▼
        Spring AMQP 回调 ReturnsCallback.returnedMessage()

`ReturnedMessage` 包含

字段	含义
`exchange`	交换机
`routingKey`	路由键
`message`	消息本身
`replyCode`	退回码，如 `312 NO_ROUTE`
`replyText`	退回原因文本

常见不触发原因

没开 mandatory。
Exchange 不存在（走 ConfirmCallback，ack=false）。
路由成功，正常入队。
只用了 convertAndSend 但没设置 mandatory。
确认机制没开（实际项目常与 publisher-confirm 一起开）。

典型组合使用

rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
    if (ack) {
        log.info("消息到达交换机成功");
    } else {
        log.error("消息到达交换机失败：{}", cause);
    }
});

rabbitTemplate.setReturnsCallback(returned -> {
    log.error("消息路由到队列失败：{}", returned);
});

判断逻辑：

Confirm ack=true + 无 Return → 成功到交换机且入队。
Confirm ack=true + 有 Return → 到交换机但路由失败。
Confirm ack=false → 连交换机都没到。

7. 核心要点速查

主题	核心结论
`ReturnsCallback`	是接口，不是方法；`setReturnsCallback` 才是方法
匿名内部类	`new 接口() { ... }`，就地实现接口方法
嵌套接口	类里面可以定义接口，默认 `static`，用 `外部类.接口` 访问
Lambda	仅函数式接口可用，是匿名内部类的简洁写法
`Future`	异步任务取餐号；`get()` 阻塞取结果；`CompletableFuture` 是增强版
SLF4J 异常	异常作为最后一个参数自动打印堆栈，不加 `{}`；普通参数必须加 `{}`
`ReturnCallback`	消息到 Exchange 但路由失败 + `mandatory=true` → Broker 退回 → 触发回调
`ConfirmCallback`	关注消息是否到达 Exchange；与 ReturnCallback 配合判断消息全链路状态

8. 易混淆点提醒

ReturnsCallback 是接口，不是方法。
new 接口() { ... } 是匿名内部类，不是直接实例化接口。
Lambda 只能用于函数式接口（有且仅有一个抽象方法）。
Future.get() 会阻塞当前线程。
SLF4J 中异常不要加 {}，否则不打印堆栈。
ReturnCallback 触发的前提是 mandatory=true，否则消息被静默丢弃。
Exchange 不存在时走 ConfirmCallback，不走 ReturnCallback。

以上为本次对话的完整复盘总结，建议按主题分块复习，重点掌握匿名内部类、函数式接口、SLF4J 异常处理和 RabbitMQ 两个回调的触发条件与区别。

微服务（部分）和mq学习日记

Thu, 17 Sep 2026 00:00:00 GMT

[x] 是否借助ai

hmall 微服务项目排错与知识点总结

一次完整的踩坑链：网关缺类启动失败 → RabbitMQ 认证/vhost → 购物车 user_id 为 null → Feign 跨服务丢失用户 → 复制 Maven 模块不识别。贯穿主题：依赖作用域、条件装配、用户信息在多次"进程边界"上的显式传递。

一、问题时间线（每个错误的根因一句话）

#	现象	根因	修复手段
1	网关启动 `ClassNotFoundException: MessageConverter`	hm-common 的 `MqConfig` 被无条件自动装配，但 amqp 依赖是 provided，网关没有该类	`MqConfig` 加 `@ConditionalOnClass`
2	trade-service 启动 `ACCESS_REFUSED ... PLAIN`	RabbitMQ 不存在 hmall 用户或密码不对	`rabbitmqctl add_user / change_password`
3	trade-service 报 `530 vhost /hmall not found`（服务能启动但不断重试）	虚拟主机未创建、未授权	`add_vhost` + `set_permissions`
4	cart-service 加购报 `Field 'user_id' doesn't have a default value`	网关只打印 userId 没下传；下游无拦截器，ThreadLocal 为 null	网关 mutate 加头 + 下游 UserInfoInterceptor + MvcConfig
5	余额支付 Feign 调 user-service 返回 500	Feign 是全新 HTTP 请求，不会自动透传请求头，下游 UserContext 又为 null	自定义 `RequestInterceptor` 复制 user-info 头
6	复制进来的 publisher 文件夹不是模块	未登记 `<modules>`；且子 pom 的 parent 还指向旧项目 mq-demo	改 parent、补依赖、登记模块、Reload Maven

二、Maven 依赖机制

1. classpath（类路径）

JVM 运行时查找所有 .class / jar 的"路径清单"，IDEA 启动命令里的 -classpath a;b;c.jar 就是它。
清单里没有的类，运行时就抛 ClassNotFoundException。
每个服务的 classpath 相互独立。
判断缺类问题的第一现场：在启动命令的 classpath 里搜报错类所在的 jar。

2. 依赖范围 scope

scope	编译可见	运行时在 classpath	向下游传递	典型用途
compile（默认）	是	是	是	普通依赖
provided	是	否	否	servlet-api（外部 Tomcat 提供）、hm-common 里的 amqp/mybatis

provided 的语义："编译时借我看，运行环境会自备，不要打包、不要传递"。
微服务公共模块中"可选功能"依赖（MQ、数据库、webmvc）应设 provided，由真正使用的服务自己引入 starter。

3. 依赖传递

A 依赖 B（compile），B 依赖 C（compile），则 A 的 classpath 自动有 C。
provided 在传递链上会被"掐断"。
本项目实际链路：
- 网关 → hm-common，amqp 是 provided → 拿不到 MessageConverter
- trade/pay-service 自己声明 spring-boot-starter-amqp（compile）→ starter 传递整套 amqp jar → 正常

4. 复制外部 Maven 模块的标准手续（三步，缺一不可）

改子模块 pom 的 <parent>：指向当前聚合工程（从旧项目复制来的 parent 会导致 Non-resolvable parent POM），并补齐原父 pom 继承来的依赖；
在根 pom 的 <modules> 中登记 <module>publisher</module>；
IDEA 重新导入：Maven 面板刷新，或 pom 右键 Add as Maven Project。

复制文件 ≠ 加入工程。蓝色方块模块图标 = 已被 Maven 识别。

三、Spring Boot 自动装配

1. spring.factories

路径：src/main/resources/META-INF/spring.factories
作用：公共 jar 里的配置类不在使用方的扫描包（@SpringBootApplication 所在包及子包）内，必须在此"登记户口"才会被自动装配。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.hmall.common.config.MyBatisConfig,\
  com.hmall.common.config.MqConfig,\
  com.hmall.common.config.JsonConfig,\
  com.hmall.common.config.MvcConfig

包内的配置类（如 hm-service 单体里的 config）能被直接扫描，不需要登记。

2. @ConditionalOnClass —— 可选依赖的标准兜底

@Configuration
@ConditionalOnClass(MessageConverter.class)
public class MqConfig {
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

含义：括号中的类在 classpath 存在时，整个配置类才生效，否则跳过。
为什么不会因为引用了缺失类而崩：Spring Boot 用 ASM 先读字节码判断条件，再决定是否加载类，类不加载就不会解析其方法签名。
触发背景：JVM 加载类时必须解析其所有方法的参数/返回值类型；反射 getDeclaredMethods() 时找不到类型即 NoClassDefFoundError。
hm-common 的统一套路：

配置类	条件类	防住谁
MyBatisConfig	MybatisPlusInterceptor、BaseMapper	无数据库服务/网关
MqConfig	MessageConverter	无 MQ 服务/网关
MvcConfig	DispatcherServlet、HttpServletRequest	WebFlux 网关（无 Servlet API）

经验法则：写进 spring.factories 的配置类，只要引用了 provided 依赖的类型，就必须配 @ConditionalOnClass。

四、RabbitMQ 排错三连

连接认证是分步的，看错误码区分：

TCP 不通：连接超时/拒绝（查容器、端口、防火墙）
用户名密码错：ACCESS_REFUSED - Login was refused using authentication mechanism PLAIN
vhost 不存在：reply-code=530, NOT_ALLOWED - vhost /hmall not found
vhost 无权限：access to vhost ... refused（三道关卡的最后一道）

常用命令：

# 用户
docker exec -it mq rabbitmqctl add_user hmall 123
docker exec -it mq rabbitmqctl change_password hmall 123
docker exec -it mq rabbitmqctl list_users
# 虚拟主机
docker exec -it mq rabbitmqctl add_vhost /hmall
docker exec -it mq rabbitmqctl list_vhosts
# 授权：configure / write / read 三个正则
docker exec -it mq rabbitmqctl set_permissions -p /hmall hmall ".*" ".*" ".*"
docker exec -it mq rabbitmqctl list_permissions -p /hmall

Socket closed 多为服务端拒绝后主动关闭，不一定是网络问题。
guest 默认只能 localhost 登录，跨机访问必须自建用户。
vhost 类似 MySQL 的 database：逻辑隔离队列/交换机/权限。
监听容器行为差异：认证失败=致命错误，启动直接失败；vhost/网络故障=可恢复错误，应用启动成功但后台每 5 秒重试（功能仍不可用）。

五、ThreadLocal 与用户信息透传

1. UserContext

public class UserContext {
    private static final ThreadLocal<Long> tl = new ThreadLocal<>();

    public static void setUser(Long userId) { tl.set(userId); }
    public static Long getUser() { return tl.get(); }
    public static void removeUser() { tl.remove(); }
}

作用域：同一 JVM + 同一线程，本质是线程私有 Map。
afterCompletion 必须 remove()：Tomcat 线程池复用线程，不清理会"用户串号"。

2. 核心原则

ThreadLocal 跨不了进程。凡是跨进程边界（HTTP、MQ），用户信息都必须显式搭车传输，每一跳都要有人搬运；HTTP 协议本身无状态，框架不会自动把头传给"下一个请求"。

3. 用户信息的完整传递链

浏览器 --JWT--> 网关验签得到 userId
网关 --(加 user-info 请求头)--> 微服务
微服务拦截器读头 -> UserContext.setUser()
微服务A --Feign 新 HTTP 请求(需 RequestInterceptor 复制头)--> 微服务B
微服务B 拦截器读头 -> 重建 UserContext

4. 第一环：网关注入请求头（WebFlux，对象不可变）

// 把 userId 放入名为 user-info 的请求头
ServerHttpRequest newRequest = request.mutate()
        .header("user-info", userId.toString())
        .build();
ServerWebExchange newExchange = exchange.mutate().request(newRequest).build();
return chain.filter(newExchange);

WebFlux 的 request/exchange 是不可变对象（响应式并发安全），没有 set 方法。
mutate() = 建造者模式：以原对象为蓝本复制 → 修改 → build() 产出新对象，原对象不变（类比 String）。
exchange 是请求在网关中的上下文容器，chain.filter() 只收 exchange，所以要把新 request 装回新 exchange。

5. 第二环：下游微服务接收（Spring MVC 拦截器）

public class UserInfoInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 1.从请求头取网关传来的用户信息
        String userInfo = request.getHeader("user-info");
        // 2.非空则存入 ThreadLocal
        if (StrUtil.isNotBlank(userInfo)) {
            UserContext.setUser(Long.valueOf(userInfo));
        }
        // 3.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest req, HttpServletResponse resp, Object handler, Exception ex) {
        // 4.请求结束清理，避免线程池复用导致用户串号
        UserContext.removeUser();
    }
}

6. MvcConfig：注册拦截器

@Configuration
@ConditionalOnClass({DispatcherServlet.class, HttpServletRequest.class})
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserInfoInterceptor());
    }
}

WebMvcConfigurer：Spring MVC 留给开发者的扩展插槽，重写回调即可定制默认配置。
拦截器在 Controller 之前执行，先把 userId 放入 ThreadLocal，Service 层才取得到。
放 hm-common + 登记 spring.factories → 所有微服务复用；@ConditionalOnClass 防网关（WebFlux 无 DispatcherServlet）缺类崩溃。
执行顺序：preHandle → Controller/Service → afterCompletion。

7. 第三环：Feign 跨服务透传

@Bean
public RequestInterceptor userInfoRequestInterceptor() {
    return template -> {
        // 1.拿到当前线程正在处理的"入站请求"
        ServletRequestAttributes attrs =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attrs == null) {
            // 没有请求上下文（MQ 监听器、定时任务等异步线程），直接跳过
            return;
        }
        // 2.从入站请求头里取出网关注入的 user-info
        String userId = attrs.getRequest().getHeader("user-info");
        // 3.写入 Feign 即将发出的"出站请求"头里
        if (StrUtil.isNotBlank(userId)) {
            template.header("user-info", userId);
        }
    };
}

Feign 是通用 HTTP 客户端，每次调用构造全新请求，默认不复制入站请求头。
RequestContextHolder：Spring MVC 基于 ThreadLocal 持有"当前入站请求"。
attrs == null 判断：异步线程（MQ、@Async、线程池）没有入站请求。
配置位置：hm-api 的 DefaultFeignConfig（经 @EnableFeignClients(defaultConfiguration=...) 全局生效）。
hm-api 若编译找不到 HttpServletRequest，加 provided 的 tomcat-embed-core。
推论：MQ 消息不透传用户身份（收发时间/线程完全不同），需要用户时从业务数据（如订单的 bizUserId）取。

六、异常栈（Stack Trace）排查方法论

固定四步：

找根因：搜 with root cause / 最底层 Caused by，读那句"人话"。
看现场：MyBatis 日志的 Preparing（SQL）+ Parameters（实际参数），定位什么数据不对。
- 例：INSERT 列清单缺 user_id + 查询参数是 null → 上游传值缺失，而非数据库问题。
定位代码：栈中只找自己的包名（com.hmall.），框架包（org.springframework. 等）跳过； IDEA 中 Ctrl+点击蓝色链接，或 Ctrl+G 输行号。
- 注意区分："异常炸点行"（如 save()）≠"错误数据出生地"（如 getUser() 返回 null），要带着问题向上追。
反向追问边界：这个值谁应该赋值？沿调用链一直追到断链处（网关头丢失 / Feign 未透传）。

微服务特有原则：

调用方日志里的 FeignException/500 只说明"对方挂了"，真正的异常栈要去被调服务的控制台找。

其他技巧：

异常栈从上往下是"抛出点→调用者"，从下往上是请求实际流动方向。
看到光秃秃的 Spring 默认错误 JSON（timestamp/status/error/path）而非统一返回，通常是全局异常处理器 @RestControllerAdvice 未被扫描/未注册 spring.factories。

七、其他零散知识点

spring.factories 自动配置 vs 组件扫描：前者管 jar 包外配置类，后者管启动包子包。
@Configuration：声明配置类；但包外的配置类单靠它不会被发现，仍需 spring.factories。
WebFlux(网关) 与 WebMVC(业务服务) 不能混：网关 classpath 有 spring-webflux，加载 servlet 相关类会失败——这也是 hm-common 所有配置类都要条件化的原因。
MyBatis-Plus 默认 NOT_NULL 插入策略：值为 null 的字段不进 INSERT 列清单，数据库 NOT NULL 无默认值时即报错。
Feign 调试：Logger.Level.FULL 可打印完整请求/响应（头、行、体），跨服务排错利器。
改公共模块后必须 Rebuild / mvn install：下游运行时用的是 jar/target 编译产物。

八、本次涉及的关键文件清单

文件	作用
`hm-common/.../config/MqConfig.java`	RabbitMQ 消息转换器，加 @ConditionalOnClass
`hm-common/.../config/MvcConfig.java`	注册 UserInfoInterceptor（新建）
`hm-common/.../interceptor/UserInfoInterceptor.java`	下游读取 user-info 头入 ThreadLocal（新建）
`hm-common/resources/META-INF/spring.factories`	公共自动装配登记处
`hm-gateway/.../filters/AuthGlobalFilter.java`	JWT 验签 + mutate 透传 user-info
`hm-api/.../config/DefaultFeignConfig.java`	Feign 日志级别 + 请求头透传拦截器
`cart-service/.../CartServiceImpl.java`	修复硬编码 userId=1 的 TODO
`publisher/pom.xml`、根 `pom.xml`	外部模块迁入：改 parent、补依赖、登记 modules

九、一句话总纲

公共模块靠"provided 依赖 + @ConditionalOnClass + spring.factories"做到按需装配；用户身份靠 ThreadLocal 在进程内保存、靠 HTTP 请求头在每个进程边界被显式搬运（网关 mutate、MVC 拦截器、Feign RequestInterceptor 各管一跳）；排错时先找 root cause 与 SQL 参数，再沿自己的包名追代码，跨服务就去对方日志里找真相。

python变量常量命令规范

Mon, 14 Sep 2026 00:00:00 GMT

[x] 是否借助ai

PEP 8 命名规范总表

类型	推荐风格	示例
变量	小写 + 下划线	`user_name`, `total_count`
常量	全大写 + 下划线	`MAX_RETRY`, `DATABASE_URL`
函数	小写 + 下划线	`get_user()`, `calc_total()`
方法	小写 + 下划线	`save()`, `to_dict()`
类	大驼峰	`UserInfo`, `HttpClient`
异常	大驼峰，常用 `Error` 结尾	`ValueError`, `LoginError`
模块	小写 + 下划线，短小	`utils.py`, `data_loader.py`
包	全小写，尽量不用下划线	`mypackage`, `httptools`
类型变量	大驼峰或单大写	`T`, `AnyStr`, `UserType`
私有成员	单下划线开头	`_internal`, `_cache`
名称改写	双下划线开头	`__secret`
魔术方法/特殊变量	双下划线开头和结尾	`__init__`, `__name__`

魔术方法与特殊变量

一、魔术方法

魔术方法：以 __ 开头和结尾，由 Python 自动调用，不要自己直接调用，也不要自创。

常用分类

类别	方法	触发场景
生命周期	`__new__` / `__init__` / `__del__`	创建、初始化、销毁
字符串	`__str__` / `__repr__`	`print()` / 调试表示
比较哈希	`__eq__` / `__hash__` / `__bool__`	`==` / `hash()` / `bool()`
容器迭代	`__len__` / `__getitem__` / `__setitem__` / `__iter__` / `__next__` / `__contains__`	`len()` / 索引 / `for` / `in`
属性访问	`__getattr__` / `__setattr__` / `__delattr__`	属性不存在 / 设置 / 删除
调用上下文	`__call__` / `__enter__` / `__exit__`	`obj()` / `with`
运算符	`__add__` / `__radd__` / `__iadd__`	`+` / 右加 / `+=`

示例

class User:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"用户：{self.name}"

    def __repr__(self):
        return f"User(name={self.name!r})"

    def __eq__(self, other):
        return isinstance(other, User) and self.name == other.name

    def __hash__(self):
        return hash(self.name)

特殊变量

特殊变量由 Python 自动维护，通常不要随意覆盖。

变量	含义
`__name__`	模块名；直接运行时为 `"__main__"`
`__file__`	当前模块文件路径
`__doc__`	文档字符串
`__dict__`	模块 / 类 / 实例的命名空间字典
`__class__`	实例所属类
`__bases__`	直接基类元组
`__mro__`	方法解析顺序
`__all__`	`from module import *` 时导出的名字
`__slots__`	限制实例属性，节省内存
`__version__` / `__author__`	约定俗成的包信息

示例

# main.py
def main():
    print("运行主程序")

if __name__ == "__main__":
    main()

class User:
    __slots__ = ("name", "age")

    def __init__(self, name, age):
        self.name = name
        self.age = age

要点

if __name__ == "__main__": 用于保护脚本入口。
__all__ 控制 import * 的导出内容。
__slots__ 会阻止动态添加属性。
__version__、__author__ 不是内置变量，只是社区约定。

vscode常用快捷键

Mon, 14 Sep 2026 00:00:00 GMT

[x] 是否借助ai

VS Code 常用快捷键（Windows）

最常用

Ctrl + Shift + P：命令面板
Ctrl + P：快速打开文件
Ctrl + Shift + F：全局搜索
Ctrl + 反引号：打开/关闭终端
Ctrl + B：打开/关闭侧边栏
Ctrl + /：行注释/取消注释
Alt + ↑ / ↓：向上/向下移动当前行
Shift + Alt + ↑ / ↓：向上/向下复制当前行
Ctrl + D：选中下一个相同内容
F12：转到定义
Shift + Alt + F：格式化整个文档
Ctrl + S：保存

编辑操作

Ctrl + X：剪切
Ctrl + C：复制
Ctrl + V：粘贴
Ctrl + Z：撤销
Ctrl + Y：重做
Ctrl + F：当前文件查找
Ctrl + H：当前文件替换
Ctrl + G：跳转到指定行
Ctrl + Shift + K：删除当前行
Ctrl + Enter：在当前行下方插入新行
Ctrl + Shift + Enter：在当前行上方插入新行
Ctrl + ]：增加缩进
Ctrl + [：减少缩进
Shift + Alt + A：块注释
Ctrl + Backspace：删除前一个单词
Ctrl + Delete：删除后一个单词
Home：行首
End：行尾
Ctrl + Home：文件开头
Ctrl + End：文件结尾

多光标

Alt + 鼠标点击：添加多个光标
Ctrl + Alt + ↑ / ↓：向上/向下添加光标
Ctrl + D：选中下一个相同内容
Ctrl + Shift + L：选中所有相同内容
Ctrl + U：撤销上一次光标操作

导航与跳转

Ctrl + P：快速打开文件
Ctrl + Shift + O：跳转到文件内符号
Ctrl + T：搜索工作区符号
F12：转到定义
Alt + F12：预览定义
Shift + F12：查看所有引用
F2：重命名符号
Ctrl + Tab：切换打开的文件
Ctrl + PageUp：切换到上一个标签页
Ctrl + PageDown：切换到下一个标签页
Ctrl + 1 / 2 / 3：聚焦第 1/2/3 个编辑器组
Ctrl + Shift + \：跳转到匹配括号

搜索与替换

Ctrl + F：当前文件查找
Ctrl + H：当前文件替换
F3：下一个匹配
Shift + F3：上一个匹配
Ctrl + Shift + F：全局搜索
Ctrl + Shift + H：全局替换

视图与面板

Ctrl + B：切换侧边栏
Ctrl + Shift + E：资源管理器
Ctrl + Shift + F：搜索面板
Ctrl + Shift + G：源代码管理
Ctrl + Shift + D：运行和调试
Ctrl + Shift + X：扩展
Ctrl + 反引号：终端
Ctrl + Shift + 反引号：新建终端
Ctrl + J：切换底部面板
Ctrl + K Z：禅模式
Esc Esc：退出禅模式
F11：全屏

文件操作

Ctrl + N：新建文件
Ctrl + O：打开文件
Ctrl + S：保存
Ctrl + K S：全部保存
Ctrl + Shift + S：另存为
Ctrl + W：关闭当前编辑器
Ctrl + K W：关闭所有编辑器
Ctrl + Shift + T：重新打开刚关闭的文件

调试

F5：启动/继续
Shift + F5：停止调试
F9：切换断点
F10：单步跳过
F11：单步进入
Shift + F11：单步跳出
Ctrl + Shift + F5：重启调试

格式化与智能提示

Shift + Alt + F：格式化整个文档
Ctrl + K Ctrl + F：格式化选中部分
Ctrl + Space：触发建议
Ctrl + Shift + Space：参数提示
Ctrl + .：快速修复
F2：重命名符号

其他实用

Ctrl + ,：打开设置
Ctrl + K Ctrl + S：打开键盘快捷方式
Ctrl + K Ctrl + T：切换主题
Ctrl + Shift + P：命令面板

java集合

Sat, 05 Sep 2026 00:00:00 GMT

[x] 是否借助ai

Java 常用集合与 API 详解

面向 Java 后端面试与日常开发的集合框架系统性整理文档。内容涵盖 Collection 与 Map 两大体系下的核心实现类、底层数据结构、关键 API、源码级原理、性能对比与并发场景实践，并补充 Java 8 引入的 Stream API 与 java.util.concurrent 包下的并发集合。对应 JDK 版本以 JDK 8 / 11 / 17 为主，关键差异会单独标注。

一、Java 集合框架总览

1.1 整体架构

Java 集合框架（Java Collections Framework, JCF）位于 java.util 包下，提供了一套统一的接口与实现，让数据的存储、检索、操作可复用、可互操作。整体结构可分为两大根接口：

java.util.Collection：存储单列数据，每个元素独立存在
- List：有序、可重复
- Set：无序（部分实现有序）、不可重复
- Queue / Deque：队列与双端队列
java.util.Map：存储双列数据（key-value 键值对）

                         Iterable<E>
                             │
                       Collection<E>
              ┌──────────────┼────────────────────┐
            List<E>       Set<E>            Queue<E>
              │             │                  │
       ┌──────┼──────┐   ┌──┼──┐          ┌───┼────┐
   ArrayList  LinkedList HashSet TreeSet  PriorityQueue Deque
       Vector  Stack     LinkedHashSet  ArrayDeque
                                  │
                                  └──> NavigableSet -> SortedSet

                                Map<K,V>
                                  │
                ┌─────────────────┼─────────────────┐
            HashMap           SortedMap          Hashtable
                │                │                  │
        LinkedHashMap        TreeMap          Properties
                │
        WeakHashMap / IdentityHashMap
                │
        ConcurrentMap
                │
        ConcurrentHashMap

1.2 接口规范与设计思想

设计原则	体现
面向接口编程	业务代码应面向 `List` / `Map` 等接口编程，而不是具体实现
可选操作（Optional Operation）	接口中部分方法如 `add(int, E)` 标注 `UnsupportedOperationException`，未实现时可抛出（不可变集合常用）
equals / hashCode 契约	`Set` 与 `Map` 的 key 要求正确实现这俩方法，否则去重与查找失效
fail-fast 机制	多数集合在迭代过程中检测到结构性修改会抛 `ConcurrentModificationException`（`ConcurrentHashMap` 等是 fail-safe）

1.3 包路径速查

包	主要内容
`java.util`	集合框架主体（`List` / `Set` / `Map` / `Queue` / 工具类）
`java.util.concurrent`	并发集合（`ConcurrentHashMap` / `CopyOnWriteArrayList` / `BlockingQueue` 等）
`java.util.concurrent.atomic`	原子类（不属集合但常配合并发集合使用）
`java.util.function`	函数式接口（`Predicate` / `Function` / `Supplier` 等，配合 Stream 使用）
`java.util.stream`	Stream API（`Stream` / `Collectors`）
`java.util.Collections`	集合工具类（旧 API）

1.4 集合与数组的区别

维度	数组	集合
长度	固定	动态扩容
类型	可存基本类型与对象	只能存对象（基本类型需装箱）
功能	仅有 length 属性	提供丰富的 CRUD、批量操作、流式 API
性能	极致紧凑（内存连续）	一般略低于数组，但接口与实现优化已接近数组

1.5 通用遍历方式

List<String> list = Arrays.asList("a", "b", "c");

// 1. for 循环（List 专属）
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

// 2. 增强 for（foreach，本质是 Iterator）
for (String s : list) {
    System.out.println(s);
}

// 3. Iterator（可在遍历中安全 remove）
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if ("b".equals(s)) it.remove();
}

// 4. forEach + Lambda（Java 8+）
list.forEach(System.out::println);

// 5. Stream（Java 8+，可链式 + 并行）
list.stream().filter(s -> s.length() > 0).forEach(System.out::println);

二、List 接口详解

List 接口继承自 Collection，特征是有序（按插入顺序）、可重复、可按索引访问。

2.1 List 接口核心 API

// 位置访问
E get(int index);
E set(int index, E element);    // 返回旧值
void add(int index, E element);
E remove(int index);

// 查找（基于 equals）
int indexOf(Object o);          // 第一次出现的下标，无则返回 -1
int lastIndexOf(Object o);

// 范围视图（重要！返回的是原集合的视图，修改互相影响）
List<E> subList(int fromIndex, int toIndex);

// 批量操作
boolean addAll(int index, Collection<? extends E> c);

// Java 8+ 默认方法
default void replaceAll(UnaryOperator<E> operator);   // 原地替换
default void sort(Comparator<? super E> c);           // 原地排序

2.2 ArrayList

2.2.1 底层结构与关键字段

ArrayList 是基于动态数组实现的，随机访问快（O(1)）、插入删除慢（平均 O(n)，涉及数组拷贝）、非线程安全。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    private static final int DEFAULT_CAPACITY = 10;       // 初始容量
    private static final Object[] EMPTY_ELEMENTDATA = {};  // 空数组常量
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 区分无参构造
    transient Object[] elementData;  // 存储元素的数组，未被序列化
    private int size;                 // 实际元素数量
    protected transient int modCount = 0;  // 结构修改计数（fail-fast）
}

2.2.2 三种构造方式

new ArrayList<>();                 // elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA
new ArrayList<>(int initialCapacity);
new ArrayList<>(Collection<? extends E> c);

无参构造不会立即分配 10 个容量的数组，而是把内部数组设为一个空数组常量。首次 add 时才扩容到 10——这是一种懒加载策略。

2.2.3 扩容机制（核心）

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
}

private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)  // 容量已满，需扩容
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

private Object[] grow() {
    return grow(size + 1);
}

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);  // 1.5 倍
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)               // 接近 Integer.MAX_VALUE
        newCapacity = hugeCapacity(minCapacity);
    return elementData = Arrays.copyOf(elementData, newCapacity);
}

要点：

每次扩容为原容量的 1.5 倍（oldCapacity + oldCapacity >> 1）。
通过 Arrays.copyOf 复制数组，开销是 O(n)，所以预判容量一次性分配可以显著减少扩容次数。
hugeCapacity 在 minCapacity < 0（即溢出）时抛 OutOfMemoryError。

2.2.4 常用 API 与复杂度

方法	时间复杂度	说明
`get(int)`	O(1)	随机访问极快
`set(int, E)`	O(1)	直接覆盖
`add(E)`	均摊 O(1)	末尾追加，扩容时 O(n)
`add(int, E)`	O(n)	需移动后续元素
`remove(int)`	O(n)	需移动后续元素
`remove(Object)`	O(n)	先线性查找，再移动
`contains(Object)`	O(n)	线性扫描
`indexOf(Object)`	O(n)	线性扫描
`clear()`	O(n)	遍历置 null，便于 GC
`iterator()`	O(1)	返回内部类 `Itr`
`forEach(Consumer)`	O(n)	默认方法，Java 8+

2.2.5 迭代器 fail-fast

public E next() {
    checkForComodification();
    ...
}

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException;
}

只要在迭代过程中通过集合自身（而非 iterator.remove()）修改结构就会触发 ConcurrentModificationException。ConcurrentModificationException 是一种最佳努力的检测，并不能保证 100% 触发并发问题。

2.2.6 使用建议

已知元素数量时使用 new ArrayList<>(initialCapacity)，避免多次扩容与拷贝。
频繁在头/中部插入删除、且数据量大时，改用 LinkedList。
多读少写、要线程安全时考虑 CopyOnWriteArrayList（写时复制）。

2.3 LinkedList

2.3.1 底层结构

LinkedList 基于双向链表，实现了 List 与 Deque 接口，因此既可以当列表也可以当队列/栈。

public class LinkedList<E> extends AbstractSequentialList<E>
        implements List<E>, Deque<E>, Cloneable, java.io.Serializable {

    transient int size = 0;
    transient Node<E> first;   // 头节点
    transient Node<E> last;    // 尾节点

    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
        Node(E item, Node<E> next, Node<E> prev) {
            this.item = item; this.next = next; this.prev = prev;
        }
    }
}

2.3.2 关键操作源码

public void addFirst(E e) {
    Node<E> f = first;
    Node<E> newNode = new Node<>(null, f, null);
    first = newNode;
    if (f == null) last = newNode;
    else f.prev = newNode;
    size++;
    modCount++;
}

public void addLast(E e) {
    Node<E> l = last;
    Node<E> newNode = new Node<>(e, null, l);
    last = newNode;
    if (l == null) first = newNode;
    else l.next = newNode;
    size++;
    modCount++;
}

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;  // 这里会根据 index 决定从前往后还是从后往前遍历
}

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;
    }
}

get(int) 会根据 index 位置选择更短的方向遍历，是个小优化。

2.3.3 时间复杂度

方法	时间复杂度	说明
`addFirst / removeFirst`	O(1)	头插/头删
`addLast / removeLast`	O(1)	尾插/尾删
`add(int, E)` / `remove(int)`	O(n)	需要先定位
`get(int)`	O(n)，平均 n/4	通过折半遍历
`contains(Object)`	O(n)	线性扫描
`peek() / poll() / push() / pop()`	O(1)	当作栈/队列使用

2.3.4 Deque 接口常用方法

队头	抛异常	返回特殊值
队头取	`getFirst()`	`peekFirst()`
队头删	`removeFirst()`	`pollFirst()`
队头插	`addFirst()`	`offerFirst()`
队尾	`getLast()` / `addLast()` / `removeLast()`	`peekLast()` / `offerLast()` / `pollLast()`

推荐用 offer / poll / peek，因为它们通过返回值表达失败（null 或 false），不会抛异常。

2.3.5 使用建议

频繁在头尾插删，且不需要随机访问时，使用 LinkedList。
不要把 LinkedList 当作 ArrayList 用——get(i) 是 O(n)，比 ArrayList 慢很多，且每个节点有额外两个指针（内存开销更大、缓存局部性差）。
实际工程中，优先选 ArrayDeque 作为栈/队列，比 LinkedList 更紧凑、更快（基于数组，无包装节点）。

2.4 Vector

2.4.1 特性

线程安全：所有方法都用 synchronized 修饰，是 JDK 早期提供的线程安全 List。
扩容机制：默认扩容为 2 倍（与 ArrayList 的 1.5 倍不同）。
性能远不如 ArrayList + 手动同步或并发集合，已经基本被淘汰。

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
    ...
}

2.4.2 Stack

Stack 继承自 Vector，提供 LIFO 语义：

public class Stack<E> extends Vector<E> {
    public E push(E item) { add(item); return item; }
    public synchronized E pop() { ... }
    public synchronized E peek() { ... }
    public boolean empty() { return size() == 0; }
    public synchronized int search(Object o) { return indexOf(o) + 1; }
}

不推荐使用 Stack（继承自 Vector，同步开销大）。推荐使用 ArrayDeque，效率更高。

2.5 List 实现类对比

特性	ArrayList	LinkedList	Vector
底层	动态数组	双向链表	动态数组
随机访问	O(1)	O(n)	O(1)
头插	O(n)	O(1)	O(n)
尾插	O(1) 均摊	O(1)	O(1) 均摊
中间插删	O(n)	O(n)（先定位）	O(n)
内存占用	小	较大（前后指针）	小
线程安全	否	否	是（粗粒度同步）
默认扩容	1.5x	—	2x
推荐度	★★★★★	★★（被 ArrayDeque 取代）	✗（淘汰）

2.6 List 选型建议

随机访问多、尾部追加为主 → ArrayList
头尾操作频繁、要实现队列/栈 → ArrayDeque（数组实现、更紧凑）
多读少写、要线程安全 → CopyOnWriteArrayList
高并发写多读多 → 业务层加锁 + ArrayList，或使用 Collections.synchronizedList(new ArrayList<>())
明确不可变、共享只读 → List.of(...) / Collections.unmodifiableList(...)

三、Set 接口详解

Set 接口继承自 Collection，特征是不允许重复元素（基于 equals 判断），最多一个 null（部分实现禁止 null）。Set 的常用实现有 HashSet / LinkedHashSet / TreeSet / EnumSet / CopyOnWriteArraySet。

3.1 Set 接口核心 API

Set 没有 List 那种按索引访问的方法，方法定义和 Collection 大体一致。Java 8+ 在 Collection 上补充了大量默认方法：

// Collection 默认方法（Set 全部继承）
default boolean removeIf(Predicate<? super E> filter);

// Stream
default Stream<E> stream();
default Stream<E> parallelStream();

// forEach
default void forEach(Consumer<? super E> action);

// 数学集合运算（需要目标 Set 实现了对应方法）
boolean containsAll(Collection<?> c);             // 子集
boolean addAll(Collection<? extends E> c);        // 并集
boolean retainAll(Collection<?> c);                // 交集
boolean removeAll(Collection<?> c);                // 差集

3.2 HashSet

3.2.1 底层结构

HashSet 是基于 HashMap 实现的，所有元素作为 HashMap 的 key 存放，value 统一为一个名为 PRESENT 的 Object 常量。所以 HashSet 的所有特性都源自 HashMap。

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();

    public HashSet() { map = new HashMap<>(); }
    public HashSet(int initialCapacity) { map = new HashMap<>(initialCapacity); }
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }

    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }

    public int size() { return map.size(); }
}

3.2.2 关键特性

不允许重复（依赖 hashCode + equals 共同决定）
无序（迭代顺序取决于哈希值与桶分布）
允许一个 null
增删改查均摊 O(1)（哈希足够均匀时）
非线程安全

3.2.3 去重原理（重要）

对象放入 HashSet 时：

计算 hashCode() 得到哈希值
通过哈希值定位桶（数组下标）
若桶为空直接放入；不为空则逐个用 equals() 比较
若 equals() 返回 true，则视为重复，丢弃新元素

因此自定义对象若要正确去重，必须同时重写 hashCode 与 equals，且契约一致：a.equals(b) ⇒ a.hashCode() == b.hashCode()。

3.2.4 使用示例

Set<String> set = new HashSet<>();
set.add("a");
set.add("b");
set.add("a");       // 不会被加入
System.out.println(set.size());  // 2

// 自定义对象去重
class User {
    String name;
    int age;
    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User u = (User) o;
        return age == u.age && Objects.equals(name, u.name);
    }
    @Override public int hashCode() { return Objects.hash(name, age); }
}
Set<User> users = new HashSet<>();
users.add(new User("tom", 18));
users.add(new User("tom", 18));  // 不会加入

3.2.5 性能与负载因子

HashSet 委托 HashMap，其容量与负载因子由 HashMap 决定（默认 16，负载 0.75）。元素数量超过 capacity * loadFactor 时触发扩容，桶数翻倍。

3.3 LinkedHashSet

3.3.1 底层结构

LinkedHashSet 继承自 HashSet，底层使用 LinkedHashMap。它在哈希表基础上维护了一条双向链表记录插入顺序（或访问顺序，构造参数控制）。

public LinkedHashSet() { super(16, .75f, true); }

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

dummy 参数仅用于区分与 HashSet(int, float) 重载，无业务含义。

3.3.2 特性

保持插入顺序（默认）
不允许重复
比 HashSet 略慢（多维护一条链表），但仍接近 O(1) 增删查
可用于实现 LRU（LinkedHashMap 的 accessOrder=true + removeEldestEntry）

3.3.3 简单 LRU 缓存

class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int maxSize;
    public LRUCache(int maxSize) {
        super(16, .75f, true);  // accessOrder=true
        this.maxSize = maxSize;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxSize;
    }
}

3.4 TreeSet

3.4.1 底层结构

TreeSet 基于 TreeMap（红黑树） 实现，元素是 TreeMap 的 key，因此：

有序：自然顺序或自定义 Comparator 顺序
不允许重复
不允许 null（自然顺序下，因为 compareTo 会 NPE）
增删改查 O(log n)

public class TreeSet<E> extends AbstractSet<E>
        implements NavigableSet<E>, Cloneable, java.io.Serializable {
    private transient NavigableMap<E, Object> m;
    private static final Object PRESENT = new Object();

    public TreeSet() { this(new TreeMap<>()); }
    public TreeSet(Comparator<? super E> comparator) { this(new TreeMap<>(comparator)); }
}

3.4.2 NavigableSet 扩展 API

// 范围操作
E lower(E e);       // 小于 e 的最大元素
E floor(E e);       // 小于或等于 e 的最大元素
E ceiling(E e);     // 大于或等于 e 的最小元素
E higher(E e);      // 大于 e 的最小元素

// 头尾
E first();          // 最小的
E last();           // 最大的
E pollFirst();      // 取出并移除最小
E pollLast();       // 取出并移除最大

// 子集视图
NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive);
NavigableSet<E> headSet(E toElement, boolean inclusive);
NavigableSet<E> tailSet(E fromElement, boolean inclusive);

// 逆序
NavigableSet<E> descendingSet();
Iterator<E> descendingIterator();

3.4.3 比较器

// 1. 自然顺序（元素实现 Comparable）
TreeSet<Integer> ts1 = new TreeSet<>();
ts1.add(3); ts1.add(1); ts1.add(2);
// 遍历：1 2 3

// 2. 自定义比较器
TreeSet<String> ts2 = new TreeSet<>(Comparator.comparingInt(String::length));
ts2.add("aa"); ts2.add("b"); ts2.add("ccc");
// 遍历：b aa ccc（按长度升序，长度相同按 String 自然顺序）

// 3. Lambda 比较器（Java 8+）
TreeSet<User> ts3 = new TreeSet<>((a, b) -> Integer.compare(a.getAge(), b.getAge()));

3.4.4 使用建议

需要有序 + 去重，首选 TreeSet
频繁范围查询 / 找最值：TreeSet 比 ArrayList + sort + binarySearch 方便
元素若用自定义对象，必须实现 Comparable 或在构造时传入 Comparator

3.5 EnumSet

专为枚举设计，底层是位向量（一个 long 存储 64 个元素），极快且极紧凑：

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

EnumSet<Day> weekend = EnumSet.of(Day.SAT, Day.SUN);
EnumSet<Day> weekday = EnumSet.complementOf(weekend);

for (Day d : EnumSet.range(Day.MON, Day.FRI)) { ... }

3.6 CopyOnWriteArraySet

基于 CopyOnWriteArrayList 实现。写时复制，写操作性能差但读操作极快且线程安全，适合读多写极少的场景（如黑白名单）。

3.7 Set 实现类对比

特性	HashSet	LinkedHashSet	TreeSet	EnumSet	CopyOnWriteArraySet
底层	HashMap	LinkedHashMap	TreeMap（红黑树）	位向量	COW 数组
顺序	无	插入顺序	自然 / 比较器	枚举声明顺序	插入顺序
增删查	O(1) 均摊	O(1) 均摊	O(log n)	O(1)	读 O(1)、写 O(n)
允许 null	是（1 个）	是（1 个）	否（取决于比较器）	否	是（1 个）
线程安全	否	否	否	否	是
适用场景	默认去重	需要保留插入顺序	有序去重、范围查询	枚举集合	读多写少

四、Map 接口详解

Map 用于存储键值对（key-value），key 不允许重复（基于 equals），一个 key 最多映射一个 value。Map 不是 Collection 的子接口，但提供了 Collection 视图（keySet、values、entrySet）以使用 Collection 的 API。

4.1 Map 接口核心 API

// 基本 CRUD
V put(K key, V value);
V get(Object key);
V remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void clear();

// 批量
void putAll(Map<? extends K, ? extends V> m);

// 默认方法（Java 8+）
default V getOrDefault(Object key, V defaultValue);
default void forEach(BiConsumer<? super K, ? super V> action);
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function);
default V putIfAbsent(K key, V value);
default boolean remove(Object key, Object value);          // 同时匹配才删
default boolean replace(K key, V oldValue, V newValue);    // CAS 替换
default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction);
default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction);
default V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction);
default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction);

// 视图（重要）
Set<K> keySet();
Collection<V> values();
Set<Map.Entry<K, V>> entrySet();

4.2 Map.Entry 接口

interface Entry<K, V> {
    K getKey();
    V getValue();
    V setValue(V value);
    static <K, V> Map.Entry<K, V> entry(K k, V v);  // Java 9+
    // Java 8+ 比较器
    static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K, V>> comparingByValue();
    static <K, V> Comparator<Map.Entry<K, V>> comparingByKey();
}

4.3 HashMap（JDK 8，面试核心）

4.3.1 底层结构

HashMap 是基于哈希表实现的，采用数组 + 链表 + 红黑树三种结构混合：

┌────────────────────┐
│   table (Node[])   │
│  ┌────┐ ┌────┐    │
│  │ [] │ │[N1]│→[N2]│→[N3]│   链表长度 < 8
│  └────┘ └────┘    │
│  ┌────┐ ┌────┐    │
│  │ [] │ │[T1]│─→[T2]│        红黑树 (Node 数 >= 8 且 table 长度 >= 64)
│  └────┘ └────┘    │
└────────────────────┘

关键字段：

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   // 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;                // 链表转红黑树阈值
static final int UNTREEIFY_THRESHOLD = 6;              // 红黑树退化为链表阈值
static final int MIN_TREEIFY_CAPACITY = 64;            // 树化最小表长度

transient Node<K, V>[] table;
transient int size;
int threshold;             // 扩容阈值 = capacity * loadFactor
final float loadFactor;

Node 是 Map.Entry 的实现：

static class Node<K, V> implements Map.Entry<K, V> {
    final int hash;
    final K key;
    V value;
    Node<K, V> next;
}

4.3.2 hash 算法

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

设计要点：

key.hashCode() 高 16 位与低 16 位异或，让高位也参与到下标计算中，减少哈希冲突
容量是 2 的幂时，(n - 1) & hash 相当于取模（位运算比 % 快很多）

static int indexFor(int h, int length) {
    return h & (length - 1);  // 等价于 h % length，length 必为 2 的幂
}

4.3.3 put 流程

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K, V>[] tab; Node<K, V> p; int n, i;
    // 1. 表为空则初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 2. 计算下标，桶为空则直接放
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K, V> e; K k;
        // 3. 桶不为空：先比较头节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 4. 红黑树节点则走树插入
        else if (p instanceof TreeNode)
            e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
        // 5. 链表：遍历到末尾追加，必要时树化
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);  // 链表长度 >= 8 时尝试树化
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                    break;
                p = e;
            }
        }
        // 6. 已存在的 key：替换值
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);  // LinkedHashMap 用
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);   // LinkedHashMap 用
    return null;
}

4.3.4 扩容机制（resize）

final Node<K, V>[] resize() {
    Node<K, V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1;  // 阈值翻倍
    }
    else if (oldThr > 0)
        newCap = oldThr;
    else {
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float) newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY
                  ? (int) ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K, V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                else {
                    // 链表拆分：JDK 8 优化，避免重新计算 hash
                    Node<K, V> loHead = null, loTail = null;
                    Node<K, V> hiHead = null, hiTail = null;
                    Node<K, V> next;
                    do {
                        next = e.next;
                        // 关键：根据 hash & oldCap == 0 决定节点位置
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null) loHead = e;
                            else loTail.next = e;
                            loTail = e;
                        } else {
                            if (hiTail == null) hiHead = e;
                            else hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

要点：

容量翻倍：容量与阈值均翻倍（仍保持 2 的幂）
JDK 8 链表拆分优化：每个节点根据 e.hash & oldCap == 0 决定留在原下标或迁移到 j + oldCap，不需要重新计算 hash，只需 1 次位运算
树拆分：红黑树拆分为低位树和高位树，必要时退化为链表

4.3.5 get 流程

public V get(Object key) {
    Node<K, V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K, V> getNode(int hash, Object key) {
    Node<K, V>[] tab; Node<K, V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 1. 先查头节点
        if (first.hash == hash &&
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 2. 链表 / 树继续查找
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K, V>) first).getTreeNode(hash, key);
            do {
                if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

4.3.6 为什么容量是 2 的幂

桶下标计算 hash & (n - 1) 等价于模运算，位运算比取模快得多
扩容时只需判断一位（e.hash & oldCap）就能确定节点的新位置，避免重新计算哈希

4.3.7 为什么负载因子默认 0.75

太高：冲突概率增大，链表变长，查找变慢
太低：浪费空间，扩容频繁
0.75 是空间与时间的折中（泊松分布下，桶中元素数符合期望 ≤ 0.5 时冲突率低）

4.3.8 树化的两个条件

if (binCount >= TREEIFY_THRESHOLD - 1)  // 链表长度 >= 8
    treeifyBin(tab, hash);

if (tab.length < MIN_TREEIFY_CAPACITY)  // 表长度 < 64
    resize();   // 优先扩容而不是树化

链表长度 ≥ 8 且 table 长度 ≥ 64 才转红黑树；否则优先扩容降低冲突。退化阈值为 6，扩容拆分时如果节点数 ≤ 6 会退化成链表。

4.3.9 使用建议

预分配容量：new HashMap<>(expectedSize / 0.75f + 1)，避免扩容
key 必须正确实现 hashCode 与 equals
不允许用可变对象作为 key（修改后哈希变化导致查不到、内存泄漏）

4.4 LinkedHashMap

4.4.1 底层结构

继承自 HashMap，在 Node 基础上扩展为 Entry，新增 before / after 指针维护双向链表，可按插入顺序或访问顺序遍历。

static class Entry<K, V> extends HashMap.Node<K, V> {
    Entry<K, V> before, after;
    Entry(int hash, K key, V value, Node<K, V> next) {
        super(hash, key, value, next);
    }
}

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

accessOrder = false（默认）：按插入顺序
accessOrder = true：按访问顺序，每次 get 都会把节点移到尾部（实现 LRU 的核心）

4.4.2 LRU 实现

public class LRU<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;
    public LRU(int capacity) {
        super(16, 0.75f, true);
        this.capacity = capacity;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;
    }
}

4.5 TreeMap

4.5.1 底层结构

基于红黑树实现，key 有序（自然顺序或自定义 Comparator），增删改查 O(log n)。

4.5.2 NavigableMap API

Map.Entry<K, V> lowerEntry(K key);
Map.Entry<K, V> floorEntry(K key);
Map.Entry<K, V> ceilingEntry(K key);
Map.Entry<K, V> higherEntry(K key);

Map.Entry<K, V> firstEntry();
Map.Entry<K, V> lastEntry();
Map.Entry<K, V> pollFirstEntry();
Map.Entry<K, V> pollLastEntry();

NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive);

4.5.3 使用场景

需要 有序 + key 范围查询 / 找最值：首选 TreeMap
子树迭代性能比遍历 HashMap 转 list + sort 略慢，但能持续维护有序

4.6 Hashtable

4.6.1 特性

早期线程安全 Map，方法都用 synchronized 修饰
不允许 key / value 为 null
默认容量 11，扩容 2 * old + 1
已被 ConcurrentHashMap 取代

4.7 ConcurrentHashMap（重点）

4.7.1 设计目标

提供高并发的线程安全 Map，相比 Hashtable 的全表锁和 Collections.synchronizedMap 的单一互斥锁，CHM 通过分段锁 / CAS 实现更高的并发度。

4.7.2 JDK 7 vs JDK 8

版本	JDK 7	JDK 8+
结构	Segment 数组 + HashEntry 数组 + 链表	Node 数组 + 链表 / 红黑树（与 HashMap 类似）
并发控制	Segment 锁（默认 16 段）	CAS + `synchronized`（只锁桶头节点）
size 统计	多次统计取最优（避免一致性开销）	baseCount + counterCells（类似 LongAdder）
扩容	Segment 内独立扩容	多线程协同扩容（transfer）

4.7.3 关键字段（JDK 8+）

transient volatile Node<K, V>[] table;        // 桶数组，volatile 保持可见性
private transient volatile Node<K, V>[] nextTable; // 扩容时的新表
private transient volatile int sizeCtl;       // 控制扩容标识
private transient volatile long baseCount;
private transient volatile CounterCell[] counterCells;

4.7.4 put 流程概要

表为空则 initTable()（CAS）
桶为空则 CAS 写入新节点
桶非空：
- MOVED → 协助扩容（helpTransfer）
- 红黑树 → 树插入
- 链表 → synchronized 锁头节点后遍历插入
链表节点数达到阈值 → 树化
更新元素计数（addCount）

4.7.5 get 流程

不需要加锁（volatile 保证可见性）
沿桶链表 / 树查找
弱一致性：可能读到中途正在扩容的数据，但不会抛 ConcurrentModificationException，是 fail-safe 迭代器

4.7.6 为什么不允许 null key / value

多线程下 containsKey + put 组合不能保证原子，null 无法明确表示"该 key 不存在"

4.8 Map 实现类对比

特性	HashMap	LinkedHashMap	TreeMap	Hashtable	ConcurrentHashMap
底层	哈希表	哈希表 + 链表	红黑树	哈希表	哈希表（分段/CAS）
顺序	无	插入/访问	自然/比较器	无	无
增删查	O(1) 均摊	O(1) 均摊	O(log n)	O(1) 均摊	O(1) 均摊
允许 null	KV 都允许	KV 都允许	不允许 key	都不允许	都不允许
线程安全	否	否	否	是（粗粒度）	是（细粒度）
迭代器	fail-fast	fail-fast	fail-fast	fail-fast	fail-safe（弱一致）
推荐度	★★★★★	★★★★	★★★★	✗	★★★★★

五、Queue / Deque 接口详解

Queue 是一种先进先出（FIFO） 的数据结构。Deque（Double Ended Queue）是双端队列，支持在两端插入和删除元素。

5.1 Queue 接口方法分组

行为	抛异常	返回特殊值
队尾插入	`add(e)`	`offer(e)`（推荐）
队头取并删除	`remove()`	`poll()`（推荐）
队头取不删	`element()`	`peek()`（推荐）

5.2 Deque 接口方法

位置	抛异常	返回特殊值
头插	`addFirst(e)`	`offerFirst(e)`
尾插	`addLast(e)`	`offerLast(e)`
头取删	`removeFirst()`	`pollFirst()`
尾取删	`removeLast()`	`pollLast()`
头查看	`getFirst()`	`peekFirst()`
尾查看	`getLast()`	`peekLast()`
栈压入	`push(e)`（= addFirst）
栈弹出	`pop()`（= removeFirst）

5.3 ArrayDeque

5.3.1 底层结构

基于循环数组实现的双端队列，可作为栈（比 Stack 快）或队列（比 LinkedList 紧凑）。

public class ArrayDeque<E> extends AbstractCollection<E>
        implements Deque<E>, Cloneable, Serializable {

    transient Object[] elements;
    transient int head;
    transient int tail;
    private static final int MIN_INITIAL_CAPACITY = 8;
}

5.3.2 关键特性

容量始终为 2 的幂
head 与 tail 在数组两端向中间扩展，到达边界时循环
扩容时翻倍，并重新映射头尾位置
不允许 null 元素

5.3.3 用法

// 当作栈
Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
stack.push(3);
while (!stack.isEmpty()) {
    System.out.println(stack.pop());  // 3 2 1
}

// 当作队列
Deque<Integer> queue = new ArrayDeque<>();
queue.offer(1);
queue.offer(2);
queue.offer(3);
while (!queue.isEmpty()) {
    System.out.println(queue.poll());  // 1 2 3
}

5.4 PriorityQueue

5.4.1 底层结构

基于二叉小顶堆（数组实现）实现的优先级队列。默认自然顺序（最小堆），可通过 Comparator 自定义。

public class PriorityQueue<E> extends AbstractQueue<E>
        implements java.io.Serializable {

    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    transient Object[] queue;
    int size;
    private final Comparator<? super E> comparator;
}

5.4.2 堆操作

// 上浮：插入时保证堆序
private void siftUpComparable(int k, E x) {
    Comparable<? super E> key = (Comparable<? super E>) x;
    while (k > 0) {
        int parent = (k - 1) >>> 1;
        Object e = queue[parent];
        if (key.compareTo((E) e) >= 0) break;
        queue[k] = e;
        k = parent;
    }
    queue[k] = key;
}

// 下沉：删除堆顶时维持堆序
private void siftDownComparable(int k, E x) {
    int half = size >>> 1;
    while (k < half) {
        int child = (k << 1) + 1;
        Object c = queue[child];
        int right = child + 1;
        if (right < size && ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
            c = queue[child = right];
        if (key.compareTo((E) c) <= 0) break;
        queue[k] = c;
        k = child;
    }
    queue[k] = key;
}

5.4.3 时间复杂度

操作	时间复杂度
`offer`	O(log n)
`poll`	O(log n)
`peek`	O(1)
`remove(Object)`	O(n)
`add`	O(log n)

5.4.4 使用建议

默认小顶堆：每次 poll 取出最小元素
大顶堆：传入 Comparator.reverseOrder() 或 Collections.reverseOrder()
不允许 null 元素
非线程安全，需要线程安全请用 PriorityBlockingQueue

5.5 BlockingQueue（并发队列入口）

java.util.concurrent.BlockingQueue 增加了阻塞能力，是生产者-消费者模式的经典工具：

实现类	数据结构	容量	特点
`ArrayBlockingQueue`	数组	有界（必填）	单锁实现
`LinkedBlockingQueue`	链表	可选有界（默认 Integer.MAX_VALUE）	双锁（take/put 各一锁）
`PriorityBlockingQueue`	堆	无界	元素按优先级
`SynchronousQueue`	不存储元素	0	插入必须等待取出
`DelayQueue`	堆	无界	元素到期才能取出
`LinkedTransferQueue`	链表	无界	`transfer` 直接交付给消费者

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
queue.put(1);     // 满则阻塞
Integer x = queue.take();  // 空则阻塞

六、集合工具类

6.1 Collections

Collections 提供了一组操作集合的静态方法。

6.1.1 排序与查找

// 排序
Collections.sort(list);                          // 自然顺序
Collections.sort(list, comparator);              // 自定义比较器
Collections.reverse(list);                       // 倒序
Collections.shuffle(list);                       // 随机打乱
Collections.swap(list, i, j);                    // 交换
Collections.rotate(list, distance);               // 旋转

// 二分查找（要求已排序）
int idx = Collections.binarySearch(list, key);
int idx = Collections.binarySearch(list, key, comparator);

// 最大最小值
T max = Collections.max(coll);
T min = Collections.min(coll);

6.1.2 同步包装（装饰器模式）

List<T> syncList = Collections.synchronizedList(new ArrayList<>());
Set<T> syncSet  = Collections.synchronizedSet(new HashSet<>());
Map<K,V> syncMap = Collections.synchronizedMap(new HashMap<>());

// 用 synchronized 块包裹迭代
synchronized (syncList) {
    Iterator<T> it = syncList.iterator();
    while (it.hasNext()) { ... }
}

6.1.3 不可变包装

List<T> unmodList = Collections.unmodifiableList(list);
Set<T> unmodSet  = Collections.unmodifiableSet(set);
Map<K,V> unmodMap = Collections.unmodifiableMap(map);

// 直接生成不可变集合
List<String> emptyList = Collections.emptyList();
Set<String> singletonSet = Collections.singleton("x");
List<String> nCopies = Collections.nCopies(10, "x");

不可变集合对任何修改操作都会抛 UnsupportedOperationException。JDK 9+ 推荐用 List.of(...) / Map.of(...) / Set.of(...)。

6.1.4 单元素集合

List<String> single = Collections.singletonList("only");
Set<String> singleSet = Collections.singleton("only");
Map<String, Integer> singleMap = Collections.singletonMap("k", 1);

6.1.5 类型检查

Collections.checkedList(list, String.class);  // 防止绕过泛型插入错误类型

6.2 Arrays

6.2.1 数组与 List 互转

List<String> list = Arrays.asList("a", "b", "c");  // 固定大小 List
String[] arr = list.toArray(new String[0]);

Arrays.asList(...) 返回的是 Arrays.ArrayList（内部类），不能 add / remove，否则抛 UnsupportedOperationException。想要可变 List 用 new ArrayList<>(Arrays.asList(...))。

6.2.2 排序与搜索

Arrays.sort(arr);                          // 自然顺序
Arrays.sort(arr, fromIndex, toIndex);      // 部分排序
Arrays.sort(arr, comparator);              // 自定义
Arrays.parallelSort(arr);                  // 并行排序（JDK 8+，大数据量时性能更好）

int idx = Arrays.binarySearch(arr, key);

6.2.3 填充 / 比较 / 复制

Arrays.fill(arr, 0);                       // 全填
Arrays.fill(arr, fromIndex, toIndex, 0);   // 部分填

boolean eq = Arrays.equals(arr1, arr2);    // 元素相等
boolean deepEq = Arrays.deepEquals(o1, o2);// 多维数组

int[] copy = Arrays.copyOf(arr, newLength);
int[] range = Arrays.copyOfRange(arr, from, to);

6.2.4 JDK 8+ Stream 互转

IntStream stream = Arrays.stream(arr);
String[] arr = stream.toArray(String[]::new);

List<String> list = Arrays.stream(arr).collect(Collectors.toList());

6.2.5 JDK 9+ 便捷方法

int[] arr = { 3, 1, 4, 1, 5 };
int lo = Arrays.stream(arr).min().getAsInt();
int sum = Arrays.stream(arr).sum();
int[] sorted = Arrays.stream(arr).sorted().toArray();
boolean anyGt4 = Arrays.stream(arr).anyMatch(x -> x > 4);

6.3 不可变集合工厂（JDK 9+）

List<String> list = List.of("a", "b", "c");        // 不允许 null
Set<Integer> set = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("a", 1, "b", 2);
Map<String, Integer> m2 = Map.ofEntries(
    Map.entry("a", 1),
    Map.entry("b", 2)
);

// JDK 10+ 提供 copyOf
List<String> copy = List.copyOf(list);              // null 不允许

不可变集合优势：

节省内存（紧凑表示）
线程安全
防止误修改

七、Java 8 Stream API

Stream 是对集合（Collection / 数组）的函数式操作抽象，让链式转换、过滤、聚合、并行化变得简洁。Stream 不存储数据、不修改源集合（除非明确终止操作设计如此）。

7.1 创建 Stream

// 从集合
list.stream();                 // 顺序流
list.parallelStream();         // 并行流

// 从数组
Arrays.stream(arr);
Stream.of("a", "b", "c");     // Stream.of 静态方法

// 从文件 / 网络
Files.lines(Paths.get("a.txt"), StandardCharsets.UTF_8);

// 数值流（避免装箱）
IntStream.range(0, 100);
IntStream.rangeClosed(0, 100);
LongStream, DoubleStream 类似

// 构建器
Stream.Builder<String> b = Stream.builder();
b.add("a").add("b");
Stream<String> s = b.build();

7.2 中间操作（Intermediate）

惰性求值：不会立即执行，直到终止操作触发。

操作	说明
`filter(Predicate)`	过滤元素
`map(Function)`	一对一转换
`mapToInt / mapToLong / mapToDouble`	转数值流
`flatMap(Function)`	一对多展平
`distinct()`	去重（依赖 equals）
`sorted()` / `sorted(Comparator)`	排序
`peek(Consumer)`	调试用消费，不改变元素
`limit(n)`	截取前 n
`skip(n)`	跳过前 n
`takeWhile(Predicate)`	JDK 9+ 满足条件时取
`dropWhile(Predicate)`	JDK 9+ 满足条件时丢弃

7.3 终止操作（Terminal）

触发整个流水线的执行。

7.3.1 遍历与匹配

forEach(Consumer);
forEachOrdered(Consumer);  // 并行流中保证顺序
boolean anyMatch(Predicate);
boolean allMatch(Predicate);
boolean noneMatch(Predicate);

7.3.2 聚合

long count();
Optional<T> min(Comparator);
Optional<T> max(Comparator);

7.3.3 归约

Optional<T> reduce(BinaryOperator<T> accumulator);
T reduce(T identity, BinaryOperator<T> accumulator);   // 含初始值
<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);

7.3.4 收集（Collectors）

// 转集合
List<T> list = stream.collect(Collectors.toList());
Set<T> set = stream.collect(Collectors.toSet());
Map<K, T> map = stream.collect(Collectors.toMap(t -> t.getKey(), t -> t));

// 拼接
String s = stream.collect(Collectors.joining(", ", "[", "]"));

// 分组
Map<K, List<T>> groups = stream.collect(Collectors.groupingBy(t -> t.getCategory()));
Map<K, Long> counts = stream.collect(Collectors.groupingBy(t -> t.getCategory(), Collectors.counting()));

// 分区
Map<Boolean, List<T>> parts = stream.collect(Collectors.partitioningBy(t -> t.isActive()));

// 汇总（数值）
DoubleSummaryStatistics stats = stream.collect(Collectors.summarizingDouble(T::getScore));
// sum / avg / min / max / count

// 自定义收集器
Collector.of(supplier, accumulator, combiner, finisher);

7.4 数值流

IntStream is = IntStream.rangeClosed(1, 100);
int sum = is.sum();                       // 5050
OptionalDouble avg = is.average();
IntSummaryStatistics stat = is.summaryStatistics();

数值流提供 sum / average / max / min / range 等方法，避免装箱开销。

7.5 并行流

list.parallelStream().filter(x -> x > 0).forEach(System.out::println);

// 顺序保持
list.parallelStream().forEachOrdered(...);

注意：并行流底层是 ForkJoinPool.commonPool()。盲目使用反而更慢（线程切换开销），仅在数据量大、计算密集、源集合易切分（ArrayList / 数组）时考虑。

7.6 Stream 完整示例

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");

// 找出长度 > 3 的名字，按长度升序，转大写，用逗号拼接
String result = names.stream()
    .filter(n -> n.length() > 3)
    .sorted(Comparator.comparingInt(String::length))
    .map(String::toUpperCase)
    .collect(Collectors.joining(", "));
// "ALICE, CHARLIE, DAVE"

7.7 Optional

Stream 常与 Optional 搭配：

Optional<String> opt = list.stream().findFirst();
opt.ifPresent(System.out::println);
String v = opt.orElse("default");
String v2 = opt.orElseGet(() -> "lazy default");
String v3 = opt.orElseThrow(() -> new IllegalStateException("empty"));

八、并发集合（java.util.concurrent）

8.1 整体分类

Concurrent
├── ConcurrentMap
│   └── ConcurrentHashMap
├── ConcurrentQueue
│   ├── ConcurrentLinkedQueue   (无锁非阻塞)
│   └── ConcurrentLinkedDeque
├── BlockingQueue
│   ├── ArrayBlockingQueue
│   ├── LinkedBlockingQueue
│   ├── PriorityBlockingQueue
│   ├── SynchronousQueue
│   ├── DelayQueue
│   └── LinkedTransferQueue
├── CopyOnWrite
│   ├── CopyOnWriteArrayList
│   └── CopyOnWriteArraySet
└── 并发 List 接口包装
    └── Collections.synchronizedList

8.2 CopyOnWriteArrayList

8.2.1 原理

写操作时把原数组整体复制一份，在新数组上修改，然后用 CAS 替换引用。读操作完全无锁。

public boolean add(E e) {
    synchronized (lock) {
        Object[] es = getArray();
        int len = es.length;
        es = Arrays.copyOf(es, len + 1);
        es[len] = e;
        setArray(es);
        return true;
    }
}

private E get(Object[] a, int index) {
    return (E) a[index];
}

8.2.2 特性

读极快、写极慢（O(n) 拷贝）
线程安全
迭代器是 快照式，遍历时数据不变 → fail-safe
适合读多写极少、监听器列表、白名单等

8.2.3 CopyOnWriteArraySet

基于 CopyOnWriteArrayList，特性类似，但内部去重需要遍历比对，开销更大。一般并发场景优先用 ConcurrentHashMap.newKeySet() 替代。

8.3 ConcurrentLinkedQueue

无锁（CAS）的非阻塞线程安全队列，基于 Michael & Scott 算法实现的无界链表。size() 较慢（需要遍历），offer / poll 是 O(1)。

8.4 BlockingQueue 用法

8.4.1 核心方法

行为	抛异常	返回特殊值	阻塞	超时
插入	`add(e)`	`offer(e)`	`put(e)`	`offer(e, timeout, unit)`
取出	`remove()`	`poll()`	`take()`	`poll(timeout, unit)`
检查	`element()`	`peek()`	—	—

8.4.2 生产者-消费者模板

BlockingQueue<Task> queue = new LinkedBlockingQueue<>(1000);

// 生产者
new Thread(() -> {
    while (running) {
        Task t = produce();
        try { queue.put(t); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; }
    }
}).start();

// 消费者
new Thread(() -> {
    while (running) {
        try {
            Task t = queue.take();
            handle(t);
        } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; }
    }
}).start();

8.4.3 DelayQueue

元素实现 Delayed.getDelay(TimeUnit)，到期才能取出，常用于定时任务、缓存过期。

class DelayedTask implements Delayed {
    private final long deadline;
    public long getDelay(TimeUnit unit) { return unit.convert(deadline - System.nanoTime(), NANOSECONDS); }
    public int compareTo(Delayed o) { return Long.compare(this.deadline, ((DelayedTask) o).deadline); }
}

8.4.4 SynchronousQueue

容量为 0，每个插入必须等待对应取出。常用于线程间直接交付任务。

8.5 ConcurrentSkipListMap / ConcurrentSkipListSet

基于跳表（SkipList） 的并发有序 Map / Set，提供 O(log n) 的增删查，并发友好（无锁化分段 CAS）。

适用场景：需要并发 + 有序 + 范围查询。

8.6 集合并发方案速查

场景	推荐
高并发 KV 读写	`ConcurrentHashMap`
并发有序 KV	`ConcurrentSkipListMap`
高并发读多写少 List	`CopyOnWriteArrayList`
并发 Set	`ConcurrentHashMap.newKeySet()`
生产者-消费者	`LinkedBlockingQueue` / `ArrayBlockingQueue`
定时 / 延迟任务	`DelayQueue` / `ScheduledExecutorService`
线程间直接交换数据	`SynchronousQueue` / `Exchanger`
单线程	不用并发行列，会拖慢性能

九、选型指南（一图速查）

需要存什么？
├── 单列元素
│   ├── 允许重复 + 有序
│   │   ├── 随机访问多 → ArrayList
│   │   ├── 头尾操作多 → ArrayDeque
│   │   └── 高并发读少写 → CopyOnWriteArrayList
│   ├── 不可重复
│   │   ├── 无序 → HashSet
│   │   ├── 插入顺序 → LinkedHashSet
│   │   ├── 自然/比较器顺序 → TreeSet
│   │   ├── 枚举 → EnumSet
│   │   └── 高并发 → ConcurrentHashMap.newKeySet()
│   ├── FIFO 队列
│   │   ├── 单线程 → ArrayDeque
│   │   ├── 多线程无阻塞 → ConcurrentLinkedQueue
│   │   └── 多线程阻塞 → LinkedBlockingQueue / ArrayBlockingQueue
│   ├── LIFO 栈 → ArrayDeque
│   └── 优先级 → PriorityQueue / PriorityBlockingQueue
│
└── 键值对
    ├── 单线程
    │   ├── 无序 → HashMap
    │   ├── 插入顺序 → LinkedHashMap
    │   ├── LRU → LinkedHashMap(accessOrder=true)
    │   └── 有序 → TreeMap
    ├── 多线程 → ConcurrentHashMap
    ├── 多线程有序 → ConcurrentSkipListMap
    └── 已被淘汰 → Hashtable / Collections.synchronizedMap

9.1 通用最佳实践

面向接口编程：变量声明为 List / Map，按需选实现
预分配容量：构造时给出预期大小，避免扩容
正确实现 hashCode / equals：自定义 key / Set 元素必备
不可变对象做 key：String / Integer / Long 等是好的 key
避免在并发场景使用非线程安全集合：尤其注意 HashMap / ArrayList 在多线程下可能死循环（扩容链表环）、数据丢失
迭代时不要结构性修改：需要则用 Iterator.remove() 或 ListIterator
优先使用 ArrayDeque 替代 Stack 和 LinkedList 作为栈/队列
优先使用 JDK 9+ List.of(...) / Map.of(...) 表达不可变集合
大数据 + 简单操作考虑 Stream，但避免在循环中频繁创建 Stream
并行流谨慎使用，先 benchmark

9.2 常见容量规划公式

// Guava 的 Maps.newHashMapWithExpectedSize 同款
int expected = 1000;
int cap = (int) (expected / 0.75f + 1);
Map<K, V> map = new HashMap<>(cap);

十、高频面试题汇总

10.1 ArrayList vs LinkedList

维度	ArrayList	LinkedList
底层	动态数组	双向链表
随机访问	O(1)	O(n)
头插	O(n)	O(1)
尾插	均摊 O(1)	O(1)
中间插删	O(n)	O(n)（定位 + 改指针）
内存占用	紧凑	大（前后指针 + 包装对象）
缓存局部性	优	差

实际工程中ArrayList 在绝大多数场景下更优，因为 CPU 缓存命中率高、GC 压力小、连续内存访问快。

10.2 ArrayList 扩容机制

初始空数组，首次 add 才扩容到 10
每次扩容 1.5 倍（oldCapacity + oldCapacity >> 1）
通过 Arrays.copyOf 复制，开销是 O(n)

10.3 HashMap put 流程

计算 key 的 hash（高 16 位异或低 16 位）
若 table 为空则 resize
计算桶下标 i = (n - 1) & hash
桶为空 → 直接放
桶非空：
- 头节点匹配 → 覆盖
- 红黑树节点 → 树插入
- 链表 → 遍历到末尾追加；长度 ≥ 8 且 table 长度 ≥ 64 时树化
size > threshold → resize

10.4 HashMap 树化的两个条件

链表长度 ≥ TREEIFY_THRESHOLD (8)
table 长度 ≥ MIN_TREEIFY_CAPACITY (64)

否则优先扩容而不是树化。

10.5 HashMap 为什么线程不安全

扩容时多线程并发可能导致链表环（JDK 7 的 transfer 用头插法；JDK 8 改用尾插法降低了概率，但仍不保证）
put 时可能值覆盖（非原子）

解决方案：使用 ConcurrentHashMap 或 Collections.synchronizedMap。

10.6 ConcurrentHashMap 1.7 vs 1.8

版本	数据结构	并发控制
1.7	Segment + HashEntry + 链表	Segment 锁（ReentrantLock）
1.8	Node + 链表/红黑树	CAS + `synchronized` 锁桶头节点

JDK 8 简化了实现、减少了锁粒度、引入红黑树优化极端冲突场景。

10.7 为什么 ConcurrentHashMap 不允许 null key/value

containsKey + put 在并发下不能保证原子，若允许 null，无法区分"key 不存在返回 null"与"key 存在但 value 是 null"。

10.8 HashSet 怎么保证元素唯一

底层是 HashMap，元素作为 key、value 是固定常量 PRESENT。add(e) 通过 map.put(e, PRESENT) == null 判断是否新增。

10.9 fail-fast vs fail-safe

机制	触发	表现	典型代表
fail-fast	迭代时检测到 modCount 变化	抛 `ConcurrentModificationException`	ArrayList / HashMap / HashSet
fail-safe	迭代器在修改前的快照上工作	不抛异常，但数据弱一致	CopyOnWriteArrayList / ConcurrentHashMap

10.10 Collection 与 Collections 区别

java.util.Collection：接口，集合框架的根
java.util.Collections：工具类，提供静态方法

10.11 Iterator 与 ListIterator

特性	Iterator	ListIterator
适用	所有 Collection	仅 List
遍历方向	单向	双向
修改	`remove()`	`remove() / set() / add()`
索引	不支持	`nextIndex() / previousIndex()`

10.12 Arrays.asList 的坑

返回 Arrays.ArrayList（内部类），固定大小，不能 add/remove
修改数组会影响 List（视图）
期望可变用 new ArrayList<>(Arrays.asList(...))

10.13 equals 与 hashCode 契约

equals 相等 ⇒ hashCode 相等
hashCode 相等不一定 equals 相等（哈希冲突）
自定义对象作为 HashMap key / HashSet 元素必须同时重写两者，且参与 equals 比较的字段必须参与 hashCode 计算

10.14 HashMap 与 Hashtable 区别

维度	HashMap	Hashtable
线程安全	否	是（全方法 synchronized）
null	允许 1 个 null key、多个 null value	都不允许
性能	高	低
推荐	是	已淘汰

10.15 Comparable vs Comparator

维度	Comparable	Comparator
位置	类内部实现	外部独立类 / Lambda
方法	`compareTo(T)`	`compare(T, T)`
数量	一个自然顺序	多个独立策略
Collections.sort	sort(list)	sort(list, comparator)

10.16 哪些集合是线程安全的

旧：Vector / Stack / Hashtable / Enumeration 相关
工具包装：Collections.synchronizedXxx
并发包：ConcurrentHashMap / ConcurrentSkipListMap / ConcurrentLinkedQueue / CopyOnWriteArrayList 等

10.17 集合的快速失败（fail-fast）原理

迭代器内部维护 expectedModCount，每次 next/remove 前检查 modCount != expectedModCount，若不等则抛 ConcurrentModificationException。

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

10.18 优先级队列底层

二叉小顶堆（数组），父子通过下标计算：

左子 = 2*i + 1
右子 = 2*i + 2
父 = (i - 1) >> 1

10.19 BlockingQueue 核心方法

行为	抛异常	特殊值	阻塞	超时
插入	add	offer	put	offer(..., t, u)
取出	remove	poll	take	poll(..., t, u)
检查	element	peek	—	—

10.20 ConcurrentHashMap size 实现

类似 LongAdder，用 baseCount + CounterCell[]。每个线程优先更新自己槽位的 CounterCell.value，减少竞争，最后 sum 得到总数。

十一、补充：Java 9~17 的新特性

11.1 JDK 9

List.of(...) / Set.of(...) / Map.of(...) / Map.ofEntries(...) 不可变集合工厂
Stream.takeWhile / dropWhile / ofNullable
Optional.stream()

11.2 JDK 10

List.copyOf(...) / Map.copyOf(...) / Set.copyOf(...)
局部变量类型推断 var

11.3 JDK 11

Collection.toArray(IntFunction) 默认方法
集合 API 增强（如 Set.of 已有接口签名）

11.4 JDK 17

Sealed Classes 增强模式匹配
模式匹配 switch（预览）

这些特性在日常开发中可按需使用，最关键的还是集合本身的设计与原理。

十二、参考资料

《Effective Java》第 3 版 — Joshua Bloch（条目 45~58 集合与 lambda 最佳实践）
《Java 核心技术》第 12 版 — Cay S. Horstmann
《深入理解 Java 虚拟机》 — 周志明
OpenJDK 源码 java.util / java.util.concurrent
Java 官方文档：https://docs.oracle.com/en/java/javase/

本文目标：覆盖 Java 后端面试与日常开发中 90% 以上的集合知识。建议先理解各集合的底层数据结构与复杂度，再去记忆 API 与最佳实践。

开学第一篇

Tue, 01 Sep 2026 00:00:00 GMT

心态发生变化是第一个显著的感受

步入大三，心理感觉焦虑，同时拥有动力。我有了明确的方向：本科就业。

背景：有java开发基础、平时也爱捣鼓一点小项目。

优势：不用忍受做题，尽早步入社会，不付学费同时能去赚钱。

缺点：没法进一步在学术圈深造，不能从事高端核心岗位。

感觉身心疲惫但很充实

开学前，暑假每天也没有完全闲着，每天都有在刷hot100，还有就是断断续续学一些课程，做了一些小项目，看了一些系统和网络的八股。一天可能没学多久，但总体来说是没闲着。自己完全独立做的项目是一个叫Study-Copilot的rag智能学习辅助程序，不过很多都是我不熟悉的技术栈，借助ai完成了很多。项目大概就是可以让agent看到飞书文档，文件等多源个人知识库，然后用户可以进行各种各样的提问，然后定制化生成用户的答案（例如复盘总结、评价、查找、或者可以帮助用户按照一定的规范整理文档），现在还在完善中。

开学后，动力很足，每天都很充实，但这几天琐事还是太多了，算法和项目已经暂时停了。这几天在研究怎么在我服务器上搞一下小项目赚钱。虽然实现这个项目有点难度，同时还赚不到钱，但在这个过程中我学到了很多知识，只不过不是很深，但我的眼界变广了。而且有一个很重要的一点第一次把八股运用到实际中了

这个项目有关青龙面板，挂到服务器上自动做任务，但其中有很多困难，找cookie就是一个问题，有很多程序不开放cookie，个人很难拿到。需要很多计算机网络、系统相关知识（其实也并不需要，只不过教程里用到了，我恰好学过，于是就进一步深化了），例如CA证书等。同时了解到了客户端抓包工具的原理。

git命令和pr操作

Wed, 19 Aug 2026 00:00:00 GMT

[ ] 是否借助ai

本人写的带图飞书文档、更加详细具体的可以参考菜鸟

克隆远程仓库到本地

git clone <仓库地址https或ssh（需要key）>

展示当前仓库对应的远程仓库(展示推拉目的仓库链接)

git remote -v

展示当前分支名字

git branch --show-current

创建新分支（注意分支命名规范）

git checkout -b feature-login

展示本地文件跟踪、暂存情况

git status

:::note 输出：</br> 未跟踪（Untracked）：新创建的文件最初是未跟踪的。它们存在于工作目录中，但没有被 Git 跟踪。</br> 已跟踪（Tracked）：通过 git add 命令将未跟踪的文件添加到暂存区后，文件变为已跟踪状态。</br> 已修改（Modified）：对已跟踪的文件进行更改后，这些更改会显示为已修改状态，但这些更改还未添加到暂存区。</br> 已暂存（Staged）：使用 git add 命令将修改过的文件添加到暂存区后，文件进入已暂存状态，等待提交。</br> 已提交（Committed）：使用 git commit 命令将暂存区的更改提交到本地仓库后，这些更改被记录下来，文件状态返回为已跟踪状态。</br> 被 .gitignore 匹配的文件，即使存在于工作区，也不会显示为 Untracked。 :::

解释git的4个区域

工作区 (Working Directory) 实际修改文件的地方。在这里写代码、删删改改。
暂存区 (Staging Area) 添加到暂存区指令：

git add <filename or .> #意义：确认准备提交到本地仓库

本地仓库 (Local Repository) 提交到本地仓库指令：

git commit -m "feat: 添加登录功能的基础框架" # 意义：改动正式成为了项目历史的一部分。即便你之后改乱了，也可以随时从这里找回。

远程仓库 (Remote) 在推送本地更改之前，最好从远程仓库拉取最新的更改，以避免冲突：

git pull origin <main or feature-login>

提交指令：

git push -u origin feature-login #（第一次提交新分支要用 -u 创建） 意义：备份代码，并与团队共享进度。

合并更改

1. 切换到目标分支（接收方）

git checkout main

2. 确保目标分支是最新的（避免不必要的冲突）

git pull origin main

3. 执行合并命令

git merge feature-login

解决冲突

当合并过程中出现冲突时，Git 会标记冲突文件，你需要手动解决冲突。打开冲突文件，按照标记解决冲突。标记冲突解决完成后暂存提交：

git add <conflict-file-name>
git commit

删除分支

git branch -d <branch name>

基础操作(核心汇总版)

git reset # 撤销提交并取消暂存，改动还在工作区 回退到本地仓库的上一个版本
git rm filename.txt # 将文件从暂存区和工作区删除
git mv old_name.js new_name.js # 移动或重命名工作区文件
git checkout <branch-name> # 分支切换
git log # 查看提交记录
git pull # 下载远程代码并合并
git push # 推送并合并

分支管理

git checkout -b <branchname> # 创建并切换分支，没有-b 是切换
git branch # 查看所有分支
git branch -r # 查看远程分支
git branch -a # 查看所有本地和远程分支
git merge <branchname> # 将其他分支合并到当前分支

github贡献操作 pr（省略了常规git操作，包括分支等）

先fork下来，再跟踪上游仓库（原作者仓库）upstream：

git remote add upstream https://github.com/agegr/pi-web.git 
#

（不要忘了新建分支）完成工作后对无关改动还原：

git checkout upstream/main -- package-lock.json
# 解释：从远程追踪分支 upstream/main 中，强制恢复（或覆盖）当前工作区中的 package-lock.json 文件。

review+跑测试

两套测试：

node --experimental-strip-types --test lib/request-security.test.mjs 
npm test #（一般是作者设置的，看具体情况）
#命令分析
# 1. node --experimental-strip-types --test lib/request-security.test.mjs
# --experimental-strip-types: Node.js 的实验性标志，允许直接运行包含 TypeScript 类型注解的 .mjs 文件（无需编译）
# --test: 启用 Node.js 内置的测试运行器
# lib/request-security.test.mjs: 具体的测试文件
# 作用：直接使用 Node.js 原生测试框架运行一个特定的安全相关测试文件。
# 2. npm test
# 这是 npm 的标准脚本命令，会执行 package.json 中定义的 test 脚本。
# 作用：运行项目配置的完整测试套件。

pr提交和issue提交：提交issue注意模版。到compare界面再提交pr

compare url：

https://github.com/agegr/pi-web/compare/main...LCZcoding:fix/chromium-origin-port-stripping
# /agegr/pi-web/ 是原作者仓库位置，后面的是提交用户名字和提交内容标题

八股学习：探讨我学习八股的目的、方法

Tue, 18 Aug 2026 00:00:00 GMT

目的

补全知识体系、拓展视野广度、应对面试

方法

八股来源：小林coding、javaguide、牛客面经、代码随想录的《最强八股文》

挑重要的精度、有疑问的搜索、总结记笔记写博客。->费曼学习法

如果说递归是新手学算法的第一道坎，那么回溯一定是第二道坎

Sun, 16 Aug 2026 00:00:00 GMT

[ ] 是否借助ai

递归和回溯

递归是数学归纳法，不要去思考下一层，全程关注顶层就好。第一行一般是边界条件。怎么表示算法直觉或思想比较重要。

回溯是高级版递归，套路（path、ans、带不带循环）、是否恢复现场

时空复杂度的思考方向

时间复杂度要从结果出发，一般是复制path的n*结果的个数

空间复杂度不将结果的空间复杂度计算在内，计算的是辅助空间的复杂度，如果是引用也不计算在内。递归栈的深度+path的n一般就是空间复杂度

基础能力：如何编译通过

数据结构的选择、api的使用是算法的基础、是编译通过的保障。

关于我把经纬度看成ip这件事

Sun, 16 Aug 2026 00:00:00 GMT

生活迷茫，丧失热爱，缺乏自律怎么办

Sat, 15 Aug 2026 00:00:00 GMT

[ ] 是否借助ai

链条：面临未来选择->内心焦虑->行动了但有人否认你的方向->怀疑自己的方向->沉溺享乐以逃避焦虑->更加焦虑->探寻意义

于是，我打算静下心来好好看一个讲解的视频，相关链接：up主SuccessDiary_帅帅，并在此写下一篇学习笔记。

剖析无法改变现状（或迷茫）的原因以及解决方案

想了很多，做了很少
爱好无法养活自己
经济条件不允许
三分钟热度
顾虑别人的看法
问别人，但没得到答案
学习或工作太忙了（这一点我暂时没有❌️）

1. 想了很多，做了很少的原因和解决的代价

走出迷茫需要找到一个确定的指引，指引来自兴趣或选择。兴趣和选择都需要尝试。消耗时间金钱人际等成本。这意味着可能要承受风险，于是我们不敢迈出第一步，而待在迷茫的舒适圈中。有点像《被讨厌的勇气》中的理论。

:::important 沉溺舒适圈、害怕承担风险->不敢迈出第一步解决方案：自己渴望的真的是未来吗，如果是大胆做，勇敢承受可能到来的风险、尽自己所能降低风险。 :::

2. 爱好无法养活自己、经济条件不允许怎么办

:::important 爱好要寻找、要筛选、最关键的是要真正热爱。兴趣和生存和谐共生。量力而行 :::

3. 解决三分钟热度

缺少足够持久的驱动力、没有生活的主动权。没有驱动力的原因：初期目标太大、太远。（付出不及预期）

:::important 直接目标要可以累加（重复），而不是山峰的高度。将爬若干米作为直接目标，比一上来就将爬多高的山做为目标更重要。这只能是终极目标。 :::

4. 别人的答案、别人的看法的影响

任何人的观点，不能全部接受，要带有自己的见解，独立思考太重要

5. 学习或工作太忙了（这一点我暂时没有❌️未来可能会有吧，到时候再补充）

❤ 心法态度

问自己一个问题：你担心的事可以解决吗？可以就去解决，担心什么；不可以就坦然接受，然后转向，没必要担心。

😊 建议

1）. 理论和实践之间循环的做事方式（理论结合实践）

做事先有大致方向、目标，拆解目标，然后实践-补充理论-实践的循环。

2）. 慢下来找寻有趣的想法，并去实践。

离开短视频、游戏、工作等高强度、低发散的思维活动。静静地思考有哪些好玩的东西，然后去尝试实践，即使失败，在这个过程中，你也能学到很多有用的东西。

学会乐观生活，感恩世界。创造和奉献。

一句话

万物唯心所现，唯识所变 --改编自《严华经》

迷茫是心、行动、目标之间不匹配的结果。

浅谈学习算法的感受（非大模型算法）

Fri, 14 Aug 2026 00:00:00 GMT

[ ] 是否借助ai

目前学了30多天，每天1-2道hot100，目前已经刷完了50多道，预计开学能刷到80道左右。

之前因为有点想放松一下就耽搁了算法3天，今天刷第一题就感觉算法特别需要集中学习，一类题之间的关系特别紧密。应该长时间分类集中学习。复盘特别重要，算法直觉很重要，要同时关注算法思想和代码实现。

具体的也不说了，总结几点建议：

搞清楚自己为啥学算法：就业？喜欢？打比赛？其中每种目的都要有不同的学习算法的方法。hot100适合中大厂面试
分类集中学习、思索同类之间的关联、复盘、算法直觉、代码实现、复杂度分析都很重要
算法需要天赋，如果没有请及时看题解和大佬讲解。强推代码随想录和K神
每天坚持1道找手感很重要

浅谈在AI时代学习计算机技术的心态调整和学习方式(此篇之前发表的都是模版草稿，请忽略)

Wed, 12 Aug 2026 00:00:00 GMT

[ ] 是否借助ai

写在最前面 : 我认为啥也不会的情况下完全借助ai来学习新技术会有很多痛苦。我对ai已经有点祛魅了，或者说我发自内心地肯定了AI时代下个人永远保持学习的重要意义。AI最适合干的事是提高效率，而不是从无到有。 </br>

引入例子：搭建一个个人博客，面临的困难

更新：引入CICD，git push后github帮助服务器自动部署

最近刷到了一个白嫖服务器时长的视频，然后就学着领取了一下。

领取完要做点什么东西好呢? 和ai聊了很长时间发现我的服务器内存很有限，只能用不熟悉的技术部署完整的前后端服务.</br> 然后就各种折腾，结果最后发现了很多需要权衡取舍的地方，比如博客外观优美的框架基本上就很难二次开发，因为我不是很懂前端技术.

有几个核心问题:

服务器的内存有限，只有1g不能部署我熟悉的java后端.
想部署后端，建议用 Go 和 SQLlite 我不熟悉而且暂时还没走到这一步.
不想写前端，想抄模版，抄的模版基本上很难进行大的改变，也有可能是我的模版找的不合适。比较难接入后端。二创比较困难。要懂一点Astro，还要把框架的架构理解.

如果从根本原因出发就是在工作量、复杂度、外观、可扩展性、性能、学习难度中进行架构上取舍.</br> 其中学习难度是以人的角度出发考虑的，其他的角度AI可以帮助你，但你和AI的对话中，AI必然不清楚你的技术水平，你也无法判断AI给的方案是否可行，而且有时候在设计提示词的时候很可能会忽略一些重要因素，忽略自己的接受能力.

最后我怎么办了? 放弃了复杂的后端，专注于博客这一单一目标，减少AI带领我走迷宫的机会，多提出确定性强的问题。其他的技术，等我慢慢渗透，一次只做一件事，而不是一上来就从了解跳跃到做好。

浅谈AI时代的技术学习和心态调整

心态调整

网上都在唱衰技术，唱衰计算机，我认为这并不可取，反而徒增焦虑。现在明确的是AI可以提效，AI让懂某一技术的人干的更快甚至更好。如果需求不变的情况下，也就是工作任务不变的情况下，计算机就业环境会艰难很多。但不同的是，AI带来了更多和更加精细化的需求，AI正在赋能各行各业。和土木不同（国内的土木人才需求可能有点少？这个专业出国应该好点？）计算机需求减小可能有，但还是一个以技术为王的专业，完全靠技术吃饭。计算机的供需比在下降这是网上唱衰计算机的主要原因，我认为计算机确实是‘衰’了，但只不过是从高高在上的版本之子变成了普通的、有竞争压力的、需要卷的专业。踏踏实实认真学习依旧是最重要的一点。

技术学习

夯实基础还重不重要？

我认为重要或者说有必要。

有些才入行的程序员说很多技术没用了，我认为只是暂时没用到，或者他们没有真正深入的理解他们的技术，没有真正理性评估基础的重要性。况且，基础的练习是入行的第一步。

该怎样学习？（仅供参考）

不推荐的学习方式：

完全的培训班式学习（诚然，这种方法能够找到工作，不至于毕业就失业。但他有一个核心的问题就是这种学习方式可能忽略了人的主体性，人有自己的兴趣，有自己的选择。如果完全按照标准路线走可能会面临高度的同质化竞争，最后导向学历竞争等其他非核心方向。）
完全AI指导学习（具体原因可见最上面的博客例子）

推荐的学习方式：

以兴趣为导向（比如你喜欢玩什么游戏，你不要只去玩游戏，你可以寻找相关的开源项目，插件什么的，然后学习，使用，然后二次开发，然后完全独立开发.以开发这一目的为导向，不要过度在意自己学的东西到底有没有用。比如你喜欢看视频，那么有没有什么插件，可以优化你看视频的这一过程，比如一些互动，什么的。）
参考常见路线（这一点培训班做的比较好。技术栈要广，要杂，更要全! 假如你的兴趣就是做做游戏插件，写写小demo或个人用的项目，这很可能不足以在业界站稳脚跟。推荐大家去好好的系统学习一门编程语言，包括业界需要的大部分知识。系统的背一下常见八股，写一些基础算法。还有最重要的一点是拥抱新技术。）

我认为企业真正需要的是有能力,能够持续学习并且热爱这一行的人。

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Spoiler

You can add spoilers to your text. The text also supports Markdown syntax.

The content :spoiler[is hidden ayyy]!

The content :spoiler[is hidden **ayyy**]!

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili

LCZ's world

java知识1

1.java中的序列化和反序列化

对象不能直接传输：

静态变量（static）不参与序列化，

JDK自带序列化的问题

面试官追问

2.java中HashMap的原理

HashMap 是非线程安全的

hashCode 和 equals 的重要性

hashmap的扩容机制

面试官追问

3.解释equals和hashcode的关系

参考资料

mq学习过程中的疑问复盘

本次对话复盘总结

1. ReturnsCallback 是类还是方法？为什么里面还能有方法？

结论

代码拆解

关键点

2. 类里面的接口（嵌套接口）

结论

特点

常见例子

3. 为什么可以用 Lambda 表达式？

结论

函数式接口定义

匿名内部类 → Lambda

原理：目标类型推断

注意

4. Java 的 Future 是什么？

一句话

核心方法

基本用法

局限性

增强版：CompletableFuture

FutureTask

5. log.error 为什么第一个没有 {} 占位符？

结论

两条日志对比

SLF4J 参数匹配规则

正确写法

6. ReturnCallback 是怎么触发的？

一句话

与 ConfirmCallback 的区别

触发前提

触发流程

ReturnedMessage 包含

常见不触发原因

典型组合使用

7. 核心要点速查

8. 易混淆点提醒

微服务（部分）和mq学习日记

hmall 微服务项目排错与知识点总结

一、问题时间线（每个错误的根因一句话）

二、Maven 依赖机制

1. classpath（类路径）

2. 依赖范围 scope

3. 依赖传递

4. 复制外部 Maven 模块的标准手续（三步，缺一不可）

三、Spring Boot 自动装配

1. spring.factories

2. @ConditionalOnClass —— 可选依赖的标准兜底

四、RabbitMQ 排错三连

五、ThreadLocal 与用户信息透传

1. UserContext

2. 核心原则

3. 用户信息的完整传递链

4. 第一环：网关注入请求头（WebFlux，对象不可变）

5. 第二环：下游微服务接收（Spring MVC 拦截器）

6. MvcConfig：注册拦截器

7. 第三环：Feign 跨服务透传

六、异常栈（Stack Trace）排查方法论

七、其他零散知识点

八、本次涉及的关键文件清单

九、一句话总纲

python变量常量命令规范

PEP 8 命名规范总表

魔术方法与特殊变量

一、魔术方法

1. `ReturnsCallback` 是类还是方法？为什么里面还能有方法？

5. `log.error` 为什么第一个没有 `{}` 占位符？

`ReturnedMessage` 包含