Coder_Studio

关于

Sun, 05 Apr 2026 17:35:33 +0000

这里是我的个人技术博客,记录八股、算法和项目实战。

Coder_Studio - 个人技术博客

网站地址：https://iamxurulin.github.io

采用 Hugo 静态站点生成器 + GitHub Pages 托管，实现零服务器成本、全自动部署。

🚀 主要特性

全自动 CI/CD：代码 Push 即触发 GitHub Actions 自动构建与部署，支持并发控制与强制覆盖，避免部署冲突
文章图片自托管：Python 脚本自动迁移 CSDN 图床图片到本地仓库，彻底解决外链失效问题
Live2D 看板娘：集成 Natori 模型，支持拖拽，提升趣味性
用户体验优化：
- 响应式布局 + 暗色模式
- 长代码自动折叠（点击展开）
- 页面加载动画 + 音乐播放器（切换页面不中断）
- 自定义鼠标光标、时钟组件
- 浏览量统计（busuanzi）

🛠️ 技术栈

静态站点生成：Hugo (Go)
主题：hugo-theme-stack
部署：GitHub Actions + peaceiris/actions-gh-pages@v4
脚本：Python（requests + BeautifulSoup 迁移 CSDN 图片）
前端：SCSS、JavaScript、Live2D、APlayer
版本控制：Git + GitHub

📝 开发与部署流程

开发 Python 脚本按需从 CSDN 批量导出文章为标准 Markdown 格式
git push 到源码仓库
GitHub Actions 自动触发：
- 执行 Python 脚本下载并上传图片到仓库
- Hugo 构建静态站点
- 强制部署到 iamxurulin.github.io 仓库的 main 分支
GitHub Pages 自动更新，几分钟内新文章上线

博客首页

博客分类

博客标签

开发和维护者：@iamxurulin

欢迎交流!

搜索

Sun, 05 Apr 2026 17:35:33 +0000

友情链接

Sun, 05 Apr 2026 17:35:33 +0000

Spring Boot + Vue 前后端联调踩坑记录

Fri, 03 Apr 2026 18:24:30 +0000

哈希、对称_非对称加密、数字签名，一次性讲清

Thu, 02 Apr 2026 18:43:59 +0000

别再搞混了！Redis、Jedis、Lettuce、Spring Data Redis、Redisson、Spring Session Redis 一次讲透

Wed, 01 Apr 2026 19:17:35 +0000

Java线程与操作系统线程的生命周期

Wed, 01 Apr 2026 14:12:15 +0000

一篇搞懂：Java包名、Maven artifactId、Spring application.name到底有啥区别？

Fri, 27 Mar 2026 21:33:09 +0000

项目文件夹叫codeedge-backend，Java包名是codeedgebackend，Maven的artifactId是codeedge-backend，Spring配置里还有个spring.application.name叫codeedge-backend。

这几个到底有啥区别？必须要对上吗？

其实，这几个是完全不同维度、不同作用、没有任何强制绑定关系的配置，给谁用、管什么、能不能乱改，差别还是挺大的。

我就用 codeedge-backend 项目当例子，先从最核心、最容易踩语法坑的 Java 包名说起。

Java包名 `com.codeedgexu.codeedgebackend`

这是Java语言强制规范的代码组织方式，是给Java编译器、JVM、Spring Boot看的，用来唯一标识代码类，和项目功能强绑定。

作用

唯一标识代码类，避免重名冲突

你的controller、config、service这些类，全在com.codeedgexu.codeedgebackend这个包下面。

Java编译器靠【包名+类名】唯一确定一个类，比如你的启动类全限定名是com.codeedgexu.codeedgebackend.CodeEdgeBackendApplication，这个名字全局唯一，不会和别人的项目重名冲突。

决定Spring Boot的Bean扫描范围

Spring Boot启动的时候，默认只会扫描启动类所在的包以及它的子包。

比如你的启动类在com.codeedgexu.codeedgebackend下面，那它只会扫这个包下面的controller、service，把它们注册成Bean。

如果改了代码的包名，但启动类没跟着搬到新包，Spring 就扫不到新包里的 controller、service 这些类，导致这些类不会被注册成 Bean，项目启动失败。

小贴士

Java包名里，绝对不能用横杠-。

因为横杠在Java里是减号运算符，不能出现在包名、类名、变量名里，编译器会直接报错。

这也是为什么我文件夹名可以叫codeedge-backend，但包名必须写成codeedgebackend的根本原因——不是我不想写一样的，是Java语法不允许。

Java包名的所有部分必须全小写。

这是Java的行业通用规范，虽然语法允许大写，但不专业，且很多代码规范检查工具会报错。

Maven artifactId `codeedge-backend`

这是Maven项目的唯一标识，在同一个groupId下必须唯一，用来在Maven仓库里找到你的项目、打包发布、管理依赖。

作用

唯一标识你的Maven项目，和别人的项目区分开；
项目打包、发布到Maven仓库，全靠这个artifactId；
以后别人要引用你的项目，就是靠这个artifactId写依赖：

<dependency>
    <groupId>com.codeedgexu</groupId>
    <artifactId>codeedge-backend</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

小贴士

上线后如果修改了 artifactId，项目打包出来的jar包名字会变，别人引用你的项目也要同步改artifactId，不然就找不到依赖。

推荐用kebab-case短横线分隔的格式（比如codeedge-backend），可读性好，Maven全兼容，是行业里90%的项目都会用的写法。

`application.yml`文件中的`codeedge-backend`

1
2
3

spring:
  application:
    name: codeedge-backend

这是Spring Boot应用的官方服务名，核心作用是给微服务注册中心（Nacos）看的，是你这个服务在微服务集群里的唯一标识。

作用

Nacos服务注册的唯一标识

你的服务启动时，会去Nacos登记，登记的名字就是这个spring.application.name；

微服务之间调用的标识

以后有其他服务要调用你的接口，就是靠这个名字在Nacos里找到你的服务地址；

小贴士

同样地，上线后如果修改了这个服务名，Nacos里注册的服务名就变了，其他服务再用旧名字找你，就完全找不到了，微服务调用直接报错。

推荐和Maven的artifactId保持一致（比如也叫codeedge-backend），这样你在看Nacos控制台的时候，一眼就能对应上“这个服务对应Maven里的哪个项目”，不会混乱。

一篇搞懂：LangChain4j结构化输出、TokenStream、SSE、Flux、Reactor到底是什么？

Thu, 26 Mar 2026 20:42:49 +0000

结构化输出、TokenStream、SSE、Flux、Reactor这几个概念刚接触时感觉很混乱，本文就来理一理，我用【AI生成一个电商商品详情页】的真实项目场景，把这些概念串起来，从业务需求到底层技术，一次性搞明白。

LangChain4j结构化输出

结构化输出是LangChain4j里的一个核心功能，能强制大模型返回标准的JSON/POJO组件树对象，而不是一段诸如“我给你加个按钮、加个图片”的自然语言。

之前你让AI生成商品详情页，它可能返回：

“好的，我帮你生成了一个详情页，顶部有个轮播图放3张商品图，中间有商品标题、价格、库存，底部有个‘立即购买’的红色按钮…”

然后你还得写自己大量文本解析逻辑，甚至还要用正则去提取轮播图数量、按钮颜色，又繁琐又容易出错，而且根本没法直接渲染成 Web 组件。

用了结构化输出，AI 会直接返回标准 JSON，之后 LangChain4j 会自动把 JSON 转成 Java 对象。底层默认使用 Jackson（Java 最主流的 JSON 库），只需要提前定义好页面结构的模板类，系统就能自动完成字段映射，完全不用写任何解析代码，直接就能喂给前端的渲染引擎。

TokenStream + SSE

TokenStream是LangChain4j提供的流式API，大模型生成一个Token（大概是一个字、半个JSON键或值），就立刻推给你，不用等整个组件树JSON生成完；

SSE（Server-Sent Events），把TokenStream里的JSON片段，实时推给前端的渲染引擎，实现“轮播图先出来、标题再出来、按钮最后出来”的逐个渲染效果。

之前你让AI生成一个复杂的Web应用，要等10-30秒整个JSON生成完，才能一次性渲染给用户，用户需要在空白的预览区页面长时间等待。

用了TokenStream + SSE，AI生成完一个完整的组件JSON片段，前端就立刻渲染这个组件，用户能实时看到进度。

Flux & Reactor

Reactor是Spring官方的响应式编程框架，专门用来处理高并发、异步、流式的场景；

Flux是Reactor的核心类之一，代表0到N个元素的异步序列，刚好对应AI生成的JSON片段流（一个JSON片段就是一个元素）。

如果用传统的同步编程，几百个用户同时请求生成Web应用，你需要开几百个线程，每个线程都要等10-30秒AI生成完，服务器的CPU、内存直接就爆了，根本扛不住。

用了 Flux + Reactor，就能彻底解决这个问题：

它是完全异步非阻塞 + 事件驱动的模型 —— 发起 AI 调用后，线程立刻释放去处理其他请求，绝不死等；等 AI 生成 Token 后，再主动通知线程来处理推送，1 个线程能同时管理几百个请求，所以只用 10-20 个线程就能扛住几百甚至上千的并发。

另外，它还自带背压机制：前端网速慢，服务端就自动放慢推送速度；前端快，就加快推送，永远不会让前端浏览器因为数据堆积而卡死。

一张图搞懂

【面试真题拆解】十万用户并发下，Caffeine+Redis+MySQL多级缓存怎么设计？

Thu, 26 Mar 2026 14:59:06 +0000

面试官问了这么一道场景题：

“平台用了Caffeine本地缓存、Redis分布式缓存、MySQL数据库，现在有十万个用户同时访问，相当于每个用户对应一个请求，这多级缓存该怎么设计？”

多级缓存就是“分层扛压”，把十万用户的请求，从快到慢、从近到远，一层层分流，别让所有请求都直接打MySQL。

设计方案

定好每一层的职责

缓存层级	职责	放什么数据	容量/速度
Caffeine本地缓存	扛超级热点中的超级热点，大幅减少 Redis 压力	访问频率 Top10 的极致热门数据（比如首页轮播爆款、正在进行的秒杀活动）	容量小（几百MB）、速度极快（纳秒级）
Redis分布式缓存	扛全局通用数据，挡MySQL	全平台的业务数据（比如商品详情、用户信息、订单数据）	容量大（几十GB）、速度快（毫秒级）
MySQL数据库	数据最终兜底，保证数据不丢	所有的原始业务数据	容量无限、速度慢（秒级）

缓存预热

平台刚启动的时候，Caffeine和Redis里都是空的，如果这时候十万用户同时进来，所有请求都会直接打MySQL，直接把数据库打垮。

为了解决这个问题，考虑采用缓存预热：

平台启动前，先做两级缓存预热：

把访问频率最高的Top1000 个全量热门 Key（比如全平台热门商品、活动规则），提前从 MySQL 里查出来，全量加载到 Redis；
把其中访问频率最高的Top10 个超级热点 Key（比如首页轮播商品、正在进行的爆款活动），额外加载到每台服务器的 Caffeine 本地缓存，作为最外层的扛压层。

缓存雪崩、击穿、穿透

缓存雪崩：十万个Key同时过期

比如你给所有Key都设置了“1小时过期”，结果十万个Key在同一时间全部过期，所有请求直接打MySQL。

解决这个问题的话，就是别给所有Key都设一样的过期时间，可以设置“1小时 + 0~30分钟的随机值”，让Key的过期时间分散开，避免同时过期；

对于首页Top10商品这种超级热点数据，还可以设置成“永不过期”，只在数据更新的时候主动删除缓存。

缓存击穿：超级热门Key突然过期

比如“双11爆款商品详情”这个Key，每秒有十万个请求，结果它突然过期了，十万个请求同时打Redis，发现没有，又同时打MySQL，直接把两者都打垮。

这个问题也可以对超级热点Key不设过期时间，只在更新时主动删；

或者加Redis 分布式互斥锁：

如果 Key 真的过期了，只让第一个抢到锁的请求去查 MySQL，查出来后更新缓存并释放锁；

其他没抢到锁的请求，每隔 100ms 重试一次查缓存，直到缓存更新完成，彻底避免十万请求同时打 MySQL。

缓存穿透：查根本不存在的Key

比如有人恶意攻击，每秒发十万个请求查“id=999999999”的商品（这个商品根本不存在），缓存里没有，直接打MySQL，把数据库打垮。

这个问题优先采用布隆过滤器拦截：

平台启动时，提前把 MySQL 里所有商品的 id 全量加载到布隆过滤器里完成预热；
用户请求进来，先过布隆过滤器，如果布隆过滤器判定这个商品 id 不存在，直接返回【商品不存在】，完全不会打到缓存和 MySQL；
只有布隆过滤器判定 id 存在，才会继续走【Caffeine→Redis→MySQL】的查询流程。

兜底方案：

缓存空值。如果查 MySQL 发现这个 Key 真的不存在，就把【空值】缓存到 Redis 里（设置 5 分钟短过期时间），下次再查这个 Key，直接从 Redis 里拿空值返回，避免重复打 MySQL。

小贴士：

空值缓存必须设置短过期时间（3-5 分钟），同时限制单 IP 的请求频率，避免恶意攻击生成大量空值缓存撑爆 Redis 内存。

十万并发下的 Redis 压力分摊方案

十万个请求同时进来，如果都打到单实例 Redis 上，大概率会直接把 Redis 打宕机，必须做以下 3 件事分摊压力：

热点隔离，本地优先扛压：把访问频率 Top10 的极致超级热点 Key（比如首页轮播爆款、正在进行的秒杀活动），全量放在每台服务器的 Caffeine 本地缓存里。十万请求里 90% 都能直接在本地命中，Redis 的压力直接降 90%。
用 Redis Cluster 集群，把数据分片存储在多个节点上，每个节点只扛一部分请求，避免单节点压力过载；
Redis 主节点只负责数据更新的写请求，多个从节点负责处理十万级的读请求，把读压力分摊到多个从节点上。

多实例下的本地缓存一致性

服务基本都是多实例集群部署的（比如 10 台服务器），每台服务器都有自己独立的 Caffeine 本地缓存，很容易出现数据不一致的问题：

比如在 A 实例更新了商品价格，删了 A 实例的 Caffeine 和 Redis 缓存，但 B 实例的 Caffeine 里还存着旧价格，用户访问 B 实例就会看到脏数据。

考虑用延迟双删 + Redis 发布订阅的组合方案解决这个问题：

延迟双删：保证 Redis 和 MySQL 的数据一致

① 先删除 Redis 缓存，让缓存失效；

② 再更新 MySQL 数据库，写入新数据；

③ 等待 1 秒（延迟时间必须略大于你的业务接口平均耗时，根据实际压测结果调整，不能盲目设置），再次删除 Redis 缓存。

延迟的目的是等其他实例已经从 MySQL 读到旧数据、更新到缓存后，再删一次缓存，避免脏数据回写。

Redis 发布订阅：保证多实例 Caffeine 的数据一致

①A实例更新完数据、完成延迟双删后，通过 Redis 的发布订阅功能，给集群里所有服务实例广播一条消息：商品 id=123 的缓存已失效，请删除本地缓存；

②所有实例收到消息后，立刻删除自己本地Caffeine里对应的Key；

③下次用户访问任何实例，都会去 Redis 里查询新数据，再更新到本地 Caffeine，保证全集群所有实例的数据一致。

完整的请求+数据更新全流程

【面试真题拆解】你知道登录用到的Token是什么吗？

Thu, 26 Mar 2026 12:06:32 +0000

用户注册登录模块几乎是每一个项目都有的，有一次面试的时候，面试官问：

你既然说到了登录，那你知道Token是什么吗？

一句话：

Token = 用户登录成功后，服务器给你颁发的一张加密的临时电子通行证，最常用的就是 JWT 格式的 Token。

它本质上就是一段加密字符串，作用就是证明三件事：你是谁、你已登录、你有权限访问这个接口。

为什么登录必须用 Token？

因为 HTTP 请求是无状态的——服务器记不住你上一秒是不是登录过。
每一次请求，对服务器来说都是“陌生人”。

所以必须给你发一张 Token，让你每次访问都带着，证明你已登录。

不然你每次点一下页面都要重新输账号密码，根本没法用。

Token 的工作流程

Token 的作用

Token 和 Session 的区别

存的地方不一样
Session 把你的身份信息全存在服务器，用户一多就特别占内存；
Token 是把“电子通行证”直接存在你自己的前端设备里，服务器不用存任何用户状态，只需要验一下通行证的真假就行，几乎没额外负担。
分布式场景的适配能力不一样
Session 不适合多服务器的分布式场景——就像你在1号窗口办的会员，2号窗口根本不认，得来回同步数据，麻烦得很；
Token 就没这个烦恼，你手里的通行证全平台通用，不管哪个服务器，只要能验过真伪就直接放行，天生就适配分布式。

说白了，Token 就是为了解决 HTTP 无状态的痛点，给前端和后端之间搭了一座信任的桥梁，不用每次都输账号密码，不用服务器存储大量用户状态，还能完美适配现在的分布式项目。

一篇搞懂前后端所有的“器”

Wed, 25 Mar 2026 20:58:53 +0000

用一个电商场景中常见的用户下单流程，把前后端的所有“器”串起来：

前后端对比

层级	前端“器”	作用	后端“器”	作用
第一道关卡	路由守卫	页面访问权限控制	过滤器	跨域、编码、协议级过滤
第二道关卡	请求/响应拦截器	统一加Token、统一报错	拦截器	登录校验、权限验证
业务层	-	-	Controller	执行核心业务逻辑
业务增强层	-	-	AOP切面	日志、监控、事务增强，不侵入主业务代码
执行层	-	-	执行器	异步任务、线程池调度

其实啊，所有的“器”，本质上都是“关注点分离”的体现，即主业务代码只关心“下单”本身，而登录、跨域、日志、异步这些“脏活累活”，交给各种“器”去做。

【面试真题拆解】为什么用SSE做流式输出？和WebSocket有啥区别？

Wed, 25 Mar 2026 17:41:32 +0000

面试官问：

“你项目里用了SSE做流式输出，为什么选SSE？它的原理你知道吗？为什么不用WebSocket？”

为什么用SSE做流式输出？

一句话：

SSE 是为服务器单向给客户端推数据的场景量身定做的，完美匹配 AIGC 流式打字机的需求，开发简单、好用、运维成本低。

类比：

SSE 就像广播电台：电台单向给你播新闻、播音乐，你只能听，不能对着电台说话；
WebSocket 就像打电话：你和对方可以双向说话，你一句我一句，实时互动。

SSE流式输出的原理

SSE是Server-Sent Events（服务器发送事件），本质上是一条由服务器控制生命周期的持久化 HTTP 长连接，在数据推送周期内保持打开，不会像普通 HTTP 请求一样响应完成就立刻关闭。

完整的流程就是：

客户端发起请求

浏览器向服务器发起一个普通的HTTP GET请求，但请求头里要加 Accept: text/event-stream，告诉服务器：“我要接收流式数据，别给我返回普通网页”；

服务器建立长连接

服务器收到请求后，不立刻返回完整响应，而是保持这条HTTP连接一直打开，不关闭；

服务器持续推数据

服务器有新数据了（比如AI生成了一个字），就通过这条打开的连接，把数据推给客户端；

SSE 有固定的标准文本格式，每段数据以data:开头、\n\n结尾，刚好适配大模型逐 Token 生成的流式输出，后端生成一个 Token 就推一次，前端无需额外做格式解析，直接渲染成打字机效果；

客户端解析数据

浏览器收到数据后，自动解析，触发 onmessage 事件，前端把数据展示出来；

连接结束或自动重连

如果数据推完了，服务器就会主动关闭连接；

如果连接意外断开（非手动关闭、非服务器返回 204 状态码），SSE 自带自动重连机制，浏览器会自动重新发起请求，还会通过请求头Last-Event-ID带上最后接收的消息 ID，后端可据此补发丢失的内容，避免 AI 回答断句缺失，建立新连接后继续接收数据。

为什么不用WebSocket？

WebSocket 是为双向实时交互场景设计的，对于 AI 流式输出这个纯服务器单向推数据的场景，有点那什么杀鸡用牛刀了，并且额外增加了开发、运维成本，完全没有必要。

对比项	SSE（Server-Sent Events）	WebSocket
通信模式	单工，纯单向通信：仅支持服务器向客户端主动推送数据，客户端只能被动接收	全双工，双向通信：客户端和服务器可以同时、双向主动发送数据，无请求 - 响应的限制
协议本质	标准 HTTP 应用层协议，完全兼容所有 HTTP 基础设施（Nginx、CDN、网关、防火墙），无需额外配置	独立的应用层协议，底层基于 TCP，仅握手阶段复用 HTTP，握手完成后需协议升级，部分内网网关、WAF 会拦截升级请求
开发复杂度	极低：浏览器原生提供`EventSource` API，前端几行代码即可实现；后端仅需开发普通 HTTP 接口保持连接推送数据，无需额外处理协议逻辑	较高：需要自行处理连接握手、心跳保活、断线重连、TCP 粘包拆包、帧解析等逻辑，前后端都需要额外的开发工作量
自动重连	原生支持：浏览器内置自动断线重连机制，无需额外开发	无原生支持：需要自行实现心跳检测和断线重连逻辑
适用场景	服务器单向推送场景：AIGC 流式打字机效果、股票行情推送、直播弹幕、新闻实时更新	双向实时交互场景：即时通讯、实时多人游戏、视频会议、物联网设备双向控制

【面试真题拆解】平时会收发短信吧？你知道短信里那种 `CodeEdge` 的短链接，点击之后是怎么跳转到长链接的？它是怎么生成的？

Tue, 24 Mar 2026 21:34:02 +0000

面试官问：

“平时会收发短信吧？你知道短信里那种 xxxxx 的短链接，点击之后是怎么跳转到长链接的？它是怎么生成的？”

点击短链接后发生了什么？

两个字：重定向。

用户点击短链接

比如用户点击 t.cn/xu0324；

浏览器请求短链接服务器

浏览器向 t.cn 的服务器发送HTTP请求，要访问 /xu0324 这个路径；

服务器查映射关系

服务器去数据库或者Redis里查，发现 xu0324 对应的原始长链接是 https://www.CodeEdge.com/xxx；

服务器返回重定向响应

服务器不返回网页内容，而是返回一个 HTTP 302状态码，并在响应头 Location 里填上原始长链接；

浏览器自动跳转

浏览器收到302状态码，看到 Location 里的长链接，自动发起新的请求，访问原始长链接；

之后，用户就看到了原始长链接的页面。

那个短链接是怎么生成的？

目前主流的生成算法有3种：

自增ID + Base62编码

用分布式ID生成器（比如雪花算法），生成一个全局唯一的自增数字ID（比如 1, 2, 3, …），再把这个10进制的数字ID，转换成62进制的字符串（Base62）。

这种方案因为是自增ID，每个ID对应唯一的Base62字符串，所以绝对唯一，没有哈希冲突，而且不涉及复杂的哈希计算，生成速度极快。

小贴士

什么是Base62呢？平时用的是10进制（0-9），Base62其实是0-9（10个）、a-z（26个）、A-Z（26个），加起来总共62个字符，所以叫Base62。

哈希算法+截取

对原始长链接做MD5或SHA-1哈希，得到一个32位（或更长）的哈希字符串，再截取哈希字符串的前6位或8位，作为短链接后缀。

这种方案对于两个不同的长链接，哈希后的前6位可能会一样，从而导致映射错误；如果发现了冲突，需要换一种截取方式（比如截取中间6位），或者加盐重新哈希，但这样也增加了复杂度。

随机字符串生成

直接随机生成一个6位的Base62字符串，再去数据库里查，如果这个字符串已经被占用了，就重新生成，直到生成一个没有被占用的。

这种方案会随着链接越来越多，冲突概率越来越大，可能要重试很多次才能生成一个可用的；并且高并发下，多个请求可能会同时生成同一个随机字符串，导致数据库唯一键冲突，所以不适合高并发场景。

为什么要用短链接？

1. 短信的字数限制

因为一条短信最多只能发70个汉字（或160个英文字符），如果直接发一个几百个字符的长链接，一条短信根本发不下，要拆成好几条，成本也会相应增加；如果用短链接，只需要十几个字符，就能完美解决字数限制的问题。

2. 防拦截、防屏蔽

长链接里经常包含很多参数，很容易被运营商、手机安全软件识别为“营销链接”或“钓鱼链接”，直接拦截，但如果用短链接的话，看起来很干净，被拦截的概率就会大大降低。

3. 数据统计和追踪

短链接服务器可以记录谁在什么时候、通过什么设备、点击了这个链接，企业通过这些数据，可以分析营销效果、用户画像、转化率等等。

Spring Boot + 通义千问 AI 数据分析助手：一句话生成 SQL + 图表 + 智能结论

Tue, 24 Mar 2026 16:19:59 +0000

需求分析

在数据爆炸的时代，业务人员最痛苦的事就是：不会写 SQL，却每天都要查数据。

我用 Spring Boot 3.2 + 通义千问 API打造了一个AI 数据分析助手，实现了“一句话搞定一切”：

用户输入一句自然语言 → 系统自动解析意图 → 智能生成 SQL → 执行查询 → 自动出图表 + 专业分析结论

项目效果演示

1. 自动生成的 SQL

2. 查询结果数据表

3. ECharts 自动可视化 + 智能结论

技术栈

后端：Spring Boot 3.2 + MyBatis-Plus + JdbcTemplate + FastJSON2 + Lombok
AI：通义千问 Qwen（RestTemplate 调用）
前端：Vue3（CDN）+ Element Plus + ECharts 5（单文件 index.html）
数据库：MySQL 8（附 schema.sql + 200 条演示数据）
其他：SSE 流式响应、动态数据源、SQL 安全正则校验

核心功能

智能 SQL 生成：结合表结构元数据 + Few-Shot Prompt，准确率大幅提升
SQL 安全校验：自动拦截 DROP/DELETE 等危险操作
流式 SSE 实时推送：意图解析 → SQL 生成 → 查询执行 → 结论生成，每一步都有进度条
ECharts 自动适配：柱状图、折线图、饼图、表格智能选择
智能分析结论：通义千问生成 2-3 句专业总结
支持动态数据源：可随时接入企业已有业务数据库

3 步快速上手

下载项目（文末附源码）
配置环境变量：

`1`	`QWEN_API_KEY=你的通义千问密钥`

启动：

1
2

# 先执行 sql/schema.sql 初始化数据库
mvn spring-boot:run

浏览器打开：http://localhost:8080

可以作为学习 LLM + 数据库落地的案例。

完整源码 + schema.sql + 使用文档 已打包好：https://download.csdn.net/download/qq_44678890/92757775

【面试真题拆解】Java里面的线程池都有哪些参数？

Sun, 22 Mar 2026 15:09:10 +0000

那下一个问题，面试官接着问：

“ Java里面的线程池都有哪些参数？”

我当时就记得“核心线程数、最大线程数”，其他的应该还有5个，支支吾吾答不上来，直接就凉了。

线程池是用来管理线程的，避免频繁创建和销毁线程带来的性能开销。

类比一下工厂招工：

不用线程池

来一个任务就招一个新工人（创建线程），任务干完就辞退（销毁线程），频繁招工辞退，效率极低，还费钱；

用线程池

工厂提前招好一批固定工人（核心线程），任务来了直接让固定工人干，固定工人忙不过来就把任务放待办队列（工作队列），队列也满了就临时招几个临时工（非核心线程），临时工没活干了过段时间就辞退，效率高，还省钱。

线程池的7个核心参数

Java线程池的核心类是 ThreadPoolExecutor，它的构造方法有7个参数：

1. corePoolSize：核心线程数

工厂的正式工数量。

正式工是工厂的“长期工”，默认情况下，就算没活干，也不会被辞退；

任务来了，先让正式工干，正式工没满的话，直接创建正式工执行任务。

2. maximumPoolSize：最大线程数

工厂的正式工+临时工的总数量。

正式工忙不过来，待办队列也满了，就会招临时工；

正式工+临时工的总数，不能超过最大线程数。

3. keepAliveTime：空闲线程存活时间

工厂的临时工没活干的时候，多久会被辞退。

只有临时工（非核心线程）会被回收，正式工（核心线程）默认不会被回收；

但是，如果设置了 allowCoreThreadTimeOut(true)，正式工没活干了，过了这个时间也会被辞退。

4. unit：时间单位

空闲线程存活时间的单位。

比如 TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分钟）、TimeUnit.HOURS（小时）。

5. workQueue：工作队列

工厂的待办任务队列。

正式工（corePoolSize）都在忙，新任务来了就先放进待办队列，等正式工有空了再从队列里拿任务干。

6. threadFactory：线程工厂

给工厂的工人起名字的。

用来创建新线程，给线程设置名字、优先级、是否是守护线程等。

7. handler：拒绝策略

工厂的任务太多了，正式工、临时工、待办队列都满了，怎么处理新任务，就是靠这个参数定义的。

线程池的执行流程

提交新任务

工厂来了一个新任务；

判断核心线程数

先看正式工（corePoolSize）有没有满，没满的话，直接招一个正式工（创建核心线程）执行任务；

判断工作队列

如果正式工满了，就看待办队列（workQueue）有没有满，没满的话，把任务放进队列，等正式工有空了再拿；

判断最大线程数

如果队列也满了，就看正式工+临时工的总数（maximumPoolSize）有没有满，没满的话，招一个临时工（创建非核心线程）执行任务；

执行拒绝策略

如果最大线程数也满了，就执行拒绝策略（handler），处理这个新任务；

任务执行完

线程执行完任务，会从队列里拿下一个任务继续干；

空闲线程回收

如果是临时工（非核心线程），没活干的时间超过了 keepAliveTime，就会被回收（辞退）。

4种默认拒绝策略

拒绝策略	作用	适用场景
AbortPolicy（默认）	直接抛出RejectedExecutionException异常，拒绝执行新任务	对数据一致性要求高的场景，任务不能丢，必须让调用者知道任务被拒绝了
CallerRunsPolicy	由提交任务的线程（调用者线程）自己执行这个任务	对性能要求不高，任务不能丢的场景，比如日志记录
DiscardPolicy	直接丢弃新任务，不抛异常，也不做任何处理	对数据一致性要求不高，丢几个任务没关系的场景，比如非核心的监控数据上报
DiscardOldestPolicy	丢弃队列里最老的任务（等待时间最长的任务），然后把新任务放进队列	对数据一致性要求不高，但想尽量执行新任务的场景

ThreadPoolExecutor 的构造方法

import java.util.concurrent.*;

/**
 * 线程池示例
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 定义线程池的7个核心参数
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5, // corePoolSize：核心线程数（5个正式工）
                10, // maximumPoolSize：最大线程数（5个正式工+5个临时工）
                60, // keepAliveTime：空闲线程存活时间（60秒）
                TimeUnit.SECONDS, // unit：时间单位（秒）
                new ArrayBlockingQueue<>(100), // workQueue：有界队列（容量100）
                Executors.defaultThreadFactory(), // threadFactory：默认线程工厂
                new ThreadPoolExecutor.AbortPolicy() // handler：默认拒绝策略（抛异常）
        );

        // 提交任务
        for (int i = 0; i < 200; i++) {
            final int taskId = i;
            threadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务：" + taskId);
            });
        }

        // 关闭线程池
        threadPool.shutdown();
    }
}

【面试真题拆解】Java的Static关键字到底怎么用？

Sun, 22 Mar 2026 13:06:05 +0000

面试官上来就问：

“ 那个Java里面的Static关键字，一般是怎么用？”

一句话：

Static是“类级别的”，不是“实例级别的”。

被Static修饰的东西，属于整个类，所有实例共用一份，不用new对象就能直接用；

而没被Static修饰的东西，属于单个实例，每个实例有自己的一份，必须new对象才能用。

对比项	静态（Static）	实例（非Static）
归属	属于整个类	属于单个实例
内存位置	方法区（JDK8 之后叫元空间）	堆内存
访问方式	类名.（变量/方法），或（实例.变量/方法）（不推荐）	必须通过实例.变量/方法访问
共享性	所有实例共用一份	每个实例有自己的一份
初始化时机	类加载时初始化	创建实例时初始化
访问限制	只能直接访问静态成员	可以访问静态成员和实例成员

1. 静态变量

静态变量就像是整个类共享的“公共储物柜”，所有实例共用这一个柜子，你放进去的东西，别人也能拿到；而实例变量是每个实例自己的“私人储物柜”，互不干扰。

举个例子，用静态变量做全局计数器

/**
 * 网站访问计数器
 */
public class WebsiteCounter {
    // 静态变量：所有实例共用，统计总访问次数
    public static int totalVisitCount = 0;
    // 实例变量：每个实例自己的，统计单个用户的访问次数
    public int userVisitCount = 0;

    /**
     * 访问方法
     */
    public void visit() {
        // 修改静态变量：总访问次数+1
        totalVisitCount++;
        // 修改实例变量：单个用户访问次数+1
        userVisitCount++;
    }

    public static void main(String[] args) {
        // 用户1访问
        WebsiteCounter user1 = new WebsiteCounter();
        user1.visit();
        user1.visit();
        System.out.println("用户1访问次数：" + user1.userVisitCount); // 输出2
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出2

        // 用户2访问
        WebsiteCounter user2 = new WebsiteCounter();
        user2.visit();
        System.out.println("用户2访问次数：" + user2.userVisitCount); // 输出1
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出3
    }
}

2. 静态方法

静态方法是属于类的“公共工具”，不用new对象，直接通过【类名.方法名】就能调用，而实例方法是属于单个实例的，必须new对象之后才能调用。

举个例子，用静态方法做工具类

/**
 * 字符串工具类
 */
public class StringUtils {
    // 私有构造方法：从根源上禁止外部代码 new StringUtils()
    // 工具类全是静态方法，完全不需要实例化，这样做能强制大家用[类名.方法名]的正确用法
    private StringUtils() {}

    /**
     * 静态方法：判断字符串是否为空
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    /**
     * 静态方法：字符串反转
     */
    public static String reverse(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return new StringBuilder(str).reverse().toString();
    }

    public static void main(String[] args) {
        // 直接通过类名调用静态方法，不用new对象
        System.out.println(StringUtils.isEmpty("")); // 输出true
        System.out.println(StringUtils.reverse("hello")); // 输出olleh
    }
}

3. 静态代码块

静态代码块是类加载的时候执行一次，且只执行一次的代码块，用来初始化静态变量或者做一些类级别的准备工作（比如加载配置文件、初始化数据库连接池）。

举个例子，用静态代码块初始化静态配置

/**
 * 配置类
 */
public class Config {
    // 静态变量：数据库连接地址
    public static String dbUrl;
    public static String dbUsername;
    public static String dbPassword;

    // 静态代码块：类加载时执行一次，初始化静态变量
    static {
        System.out.println("静态代码块执行，开始初始化配置...");
        // 模拟从配置文件读取配置
        dbUrl = "jdbc:mysql://localhost:3306/test";
        dbUsername = "root";
        dbPassword = "123456";
    }

    // 实例代码块：创建实例时执行，每次new都执行
    {
        System.out.println("实例代码块执行...");
    }

    // 构造方法：创建实例时执行，每次new都执行
    public Config() {
        System.out.println("构造方法执行...");
    }

    public static void main(String[] args) {
        // 第一次访问Config类，触发类加载，静态代码块执行
        System.out.println("数据库地址：" + Config.dbUrl);
        System.out.println("---");
        // new第一个实例，实例代码块和构造方法执行
        new Config();
        System.out.println("---");
        // new第二个实例，实例代码块和构造方法执行，但静态代码块不再执行
        new Config();
    }
}

小贴士

静态代码块只在类第一次被加载时执行一次，之后不管new多少个实例，都不会再执行。

4. 静态内部类

静态内部类是属于外部类的“独立房间”，不用依赖外部类的实例就能直接创建，而非静态内部类是属于外部类实例的“附属房间”，必须先有外部类实例才能创建。

静态内部类的作用是：

利用 Java 的类加载时机，实现了懒加载（用的时候才创建）+ 线程安全（JVM 保证）+ 不用加锁（性能高）的完美单例。

举个例子，用静态内部类实现线程安全的单例模式

/**
 * 单例模式：静态内部类实现
 */
public class Singleton {
    // 私有构造方法：从根源上禁止外部代码直接 new Singleton()
    private Singleton() {}

    // 静态内部类：只有第一次被访问时才会加载（实现懒加载，用的时候才创建实例，不占内存）
    // 因为是在 Singleton 类内部，所以可以访问上面的 private 构造方法
    private static class SingletonHolder {
        // 静态变量：JVM 类加载过程是天然线程安全的，这里初始化唯一的单例实例（不用加锁，性能高）
        private static final Singleton INSTANCE = new Singleton();
    }

    // 全局唯一的访问点：外部代码只能通过这里获取单例实例
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) {
        // 获取单例实例
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        // 两个实例是同一个，完美实现单例
        System.out.println(instance1 == instance2); // 输出true
    }
}

小贴士

静态变量存放在JVM的方法区（元空间），不是堆内存。
静态变量可以通过【类名.变量名】直接访问，也可以通过【实例.变量名】访问（不过，不推荐，因为容易混淆）。
因为所有线程共用同一个静态变量，多线程同时修改会出现并发问题，需要加锁保证线程安全。
因为实例变量和方法依赖具体的实例，静态方法调用时可能还没new对象，所以，静态方法只能直接访问静态变量和静态方法，不能直接访问实例变量和实例方法。
this 代表当前实例，静态方法属于类，调用时可能还没创建实例，this 根本不存在，所以，静态方法不能用 this。
静态内部类只能直接访问外部类的静态变量和静态方法，不能直接访问实例变量和实例方法。

【面试真题拆解】你知道ThreadLocal是什么吗

Sat, 21 Mar 2026 17:34:29 +0000

ThreadLocal 是线程专属的本地变量，它的设计是给每个线程创建一份独立的变量副本，线程之间完全不共享数据，天然实现线程隔离，全程无锁竞争，性能远高于加锁保证线程安全的方案。

每个 Thread 内部都有一个专属的成员变量 ThreadLocalMap（不是 ThreadLocal 的！），Key 是 ThreadLocal 实例本身（弱引用），Value 是存的变量（强引用）。

官话太多，直接上例子。

以用户上下文传递举个例子

/**
 * 用户上下文工具类
 * 用ThreadLocal存当前登录用户的ID，避免层层传参
 */
public class UserContextHolder {
    // 定义ThreadLocal，存用户ID
    private static final ThreadLocal<Long> USER_ID_THREAD_LOCAL = new ThreadLocal<>();

    /**
     * 设置用户ID
     */
    public static void setUserId(Long userId) {
        USER_ID_THREAD_LOCAL.set(userId);
    }

    /**
     * 获取用户ID
     */
    public static Long getUserId() {
        return USER_ID_THREAD_LOCAL.get();
    }

    /**
     * 必须手动调用！清理ThreadLocal，防止内存泄漏
     */
    public static void clear() {
        USER_ID_THREAD_LOCAL.remove();
    }
}

和加锁保证线程安全的区别

对比项	加锁	ThreadLocal
思想	多线程排队用同一个变量，保证同一时间只有一个线程能访问	每个线程用自己的专属变量，完全不共享
性能	有锁竞争，高并发下性能差	无锁竞争，性能高
适用场景	多线程必须共享同一个变量的场景（比如共享计数器、共享资源修改）	每个线程需要独立变量副本的场景（比如用户上下文、SimpleDateFormat 线程安全）

小贴士

很多人以为ThreadLocalMap的Key是“线程ID”，其实Key是ThreadLocal实例本身，而不是线程ID。

一个线程可以有多个ThreadLocal实例，每个实例对应一个Value，存到同一个ThreadLocalMap里，Key不同，互不干扰。

ThreadLocal内存泄漏问题

Java中的4种引用强度

强引用

我们平时写的 Object obj = new Object() 就是强引用，只要强引用还在，GC就不会回收这个对象。

软引用

用 SoftReference 包装的引用，只有当内存不够用的时候，GC 才会回收这个对象。

弱引用

用 WeakReference 包装的引用，只要GC一运行，不管内存够不够，都会回收这个对象。

虚引用

用 PhantomReference 包装的引用，完全不影响对象的生命周期，只是用来在对象被 GC 回收前收到一个通知，做一些收尾工作。

ThreadLocalMap的Entry结构

ThreadLocalMap的Entry是继承自WeakReference的，结构如下：

static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
        super(k); // Key是弱引用
        value = v; // Value是强引用
    }
}

假设创建了一个 ThreadLocal 实例，有外部强引用指向它，同时把它作为 Key 存到了线程的 ThreadLocalMap 里；

当用完 ThreadLocal 后，没有手动 remove，而且外部的强引用也没了（比如 threadLocal = null），因为 Key 是弱引用，GC 一运行，Key 就被回收了，变成了 null。

但是， Value 是强引用，只要线程还活着，Value 就不会被 GC 回收，这就导致了内存泄漏。

更严重的还有，如果用了线程池，线程会被长期复用，不仅内存泄漏，还会导致用户信息串号、数据错误等严重的业务问题。

怎么避免内存泄漏

使用完ThreadLocal后，手动调用 remove() 方法。

举个例子，在Spring Boot的拦截器里：

@Component
public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 从Token里解析出用户ID，存到ThreadLocal
        Long userId = parseUserIdFromToken(request.getHeader("Authorization"));
        UserContextHolder.setUserId(userId);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 在这里清理，不管请求成功失败，都要清理。
        UserContextHolder.clear();
    }
}

【面试真题拆解】被问懵的计算机网络7层_5层_4层模型

Sat, 21 Mar 2026 09:04:13 +0000

好几次面试都被问了计算机网络模型，一次是让我讲讲7层模型，还有让我讲讲5层模型，4层模型的。

这群面试官完全不按套路出牌，昨天刚问完 7 层模型，今天就换成了 4 层模型。

我当场脑子一片空白，支支吾吾说不清楚，直接就凉了。

首先，为什么会有三个版本？

且看：

7层模型（OSI参考模型）

这是国际标准化组织定的理论学术标准，是网络分层的“祖宗”，但实际互联网几乎不用。

4层模型（TCP/IP模型）

互联网实际在用的工业落地标准，我们现在上网、写代码用的HTTP、TCP、IP，全是基于这个模型跑的，是真正“干活”的模型。

5层模型（教材简化模型）

国内计算机教材最常用的简化教学版，把4层模型的最底层拆成了2层，方便理解学习。

面试的时候，不管面试官问哪个模型，可以先把下面这张对应关系表讲出来，这样就能把三个模型的边界划清楚，也不容易搞混。

7 层 OSI 参考模型	5 层教材简化模型	4 层 TCP/IP 工业模型	作用
应用层	应用层	应用层	给用户/应用提供服务，比如浏览器、APP
表示层	（合并到应用层）	（合并到应用层）	数据加密、格式转换、统一编码
会话层	（合并到应用层）	（合并到应用层）	建立和维持应用之间的会话连接
传输层	传输层	传输层	给数据标端口，控制端到端的传输方式
网络层	网络层	网际层	给数据标 IP，规划端到端的传输路线
数据链路层	数据链路层	网络接口层	给数据标 MAC 地址，相邻节点之间的传输
物理层	物理层	（合并到网络接口层）	电信号、光信号的物理传输

7层OSI参考模型

7. 应用层

应用层主要是给用户/应用提供可操作的服务，定义数据的业务含义。

统称为消息/报文 (Message)。

我们写代码天天接触的HTTP、HTTPS、DNS、FTP、WebSocket、RPC协议，全在这一层。

浏览器发请求、APP调接口，都是在应用层完成的。

6. 表示层

表示层主要是统一数据格式，保证收发双方能看懂对方的数据，核心负责数据的加密解密、格式转换、压缩解压、编码统一。

理论上 OSI 模型把加密解密放在表示层；

但在实际 TCP/IP 模型中，TLS/SSL 属于应用层实现，工作在应用层与传输层之间。

5. 会话层

会话层主要是管理应用之间的会话，保证数据不会串线。

负责建立、维持、有序断开应用之间的会话连接，提供会话同步、全双工 / 半双工切换等管理能力；

该层仅存在于 OSI 理论模型中，实际 TCP/IP 体系中无独立对应层，相关会话逻辑由应用层 + 传输层共同实现。

4. 传输层

传输层是端到端的传输控制，保证数据能准确送到对应的应用程序。

数据单位称为段 (Segment)。

TCP（可靠传输）、UDP（不可靠传输），还有端口号（HTTP的80端口、HTTPS的443端口），都在这一层。

3. 网络层

作用是网络寻址和路由选择，保证数据能从源主机送到目标主机。

数据单位称为包 (Packet) 或分组。

IP 协议（IPv4/IPv6）、ARP（IP 转 MAC 地址）、ICMP（ping/tracert 命令）、OSPF/RIP 路由协议，都在这一层。

2. 数据链路层

相邻节点之间的可靠传输，负责成帧 (Framing)、差错检测和流量控制。

数据单位称为帧 (Frame)。
MAC地址、以太网协议、交换机转发，都在这一层。

给 IP 数据包加上 MAC 头部，标上源 MAC 和下一跳的 MAC 地址，保证相邻节点之间能准确传输。

1. 物理层

物理介质上的比特流传输。只负责传输0和1的比特流，不管数据是什么含义。

数据单位称为比特 (Bit)。

网线、光纤、网卡、集线器、电信号、光信号，都在这一层。

4层TCP/IP模型

OSI模型太理想化、太复杂，实际互联网落地的时候，做了两层合并，就成了现在真正在用的4层模型：

应用层：合并了OSI的应用层+表示层+会话层
传输层：同OSI的传输层
网际层：同OSI的网络层
网络接口层：合并了OSI的数据链路层+物理层

我们现在上网、写代码的所有网络请求，全是跑在这个4层TCP/IP模型上的，是真正的工业标准。

5层教材简化模型

国内教材为了兼顾教学易懂性和底层逻辑完整性，以 OSI 7 层模型为基础做简化，保留应用层、传输层、网络层，同时将底层拆分为数据链路层 + 物理层，形成了教学通用的 5 层简化模型。

这个模型既保留了底层的物理传输逻辑，又简化了上层的复杂分层。

举个例子

在浏览器输入网址，到页面显示出来，经过了网络模型的哪些层？

(1)客户端发送请求（从上到下封装数据包）

应用层

浏览器解析网址，先通过 DNS 协议解析域名，拿到服务器的 IP 地址，再生成对应的 HTTP 请求。

传输层

先通过三次握手与服务器建立 TCP 连接，再给 HTTP 请求加上 TCP 头部，标上源端口和目标端口，完成传输层封装。

网络层

给TCP数据包加上IP头部，标上源IP和目标IP，路由器根据IP地址规划路由，找到服务器的网络地址。

数据链路层

给IP数据包加上MAC头部，标上源MAC和下一跳的MAC地址，交换机根据MAC地址完成相邻节点转发。

物理层

把数据包转换成电信号/光信号，通过网线、光纤、基站等物理介质，传输到目标服务器。

(2)服务器接收并处理请求（从下到上解析数据包）

服务器收到数据后，从下到上逐层解包：物理层➡️数据链路层➡️网络层➡️传输层➡️应用层，最终解析 HTTP 请求、执行业务逻辑并返回响应。

(3) 客户端渲染页面

浏览器收到响应后，解析HTML/CSS/JS，渲染页面并显示给用户。

每层对应的协议

层级名称	协议
应用层	HTTP、HTTPS、DNS、FTP、SMTP（邮件发送）、POP3/IMAP（邮件接收）、WebSocket、SSH、Dubbo 等 RPC 协议
传输层	TCP（可靠传输）、UDP（不可靠传输）
网络层	IPv4、IPv6、ARP（IP 转 MAC 地址）、ICMP（ping/tracert）、OSPF、RIP 等路由协议
数据链路层	以太网协议、PPP 点对点协议、VLAN 协议、MAC 地址规范
物理层	无专属网络协议，相关规范：网线、光纤、网卡、集线器、RJ45 接口

小贴士：

ARP 协议逻辑上属于网络层（核心为 IP 协议提供地址解析服务，是 TCP/IP 网际层的核心配套协议），仅从报文封装形式来看，它被直接封装在以太网帧中，因此也有观点认为它属于数据链路层。

【面试真题拆解】5秒内限10次HTTP接口访问，结合数据结构和算法说说你的思路

Fri, 20 Mar 2026 15:00:00 +0000

面试官问：

做Web项目的时候，会暴露出一些HTTP接口，我现在想对它进行限流，限制5秒内只能访问10次，结合数据结构和算法，看如何实现，说说你的思路

当时只说了个滑动窗口就没说其他的，然后就没有然后了。。。

首先，为什么要限流？

主要有以下三个原因：

防止恶意刷接口，比如爬虫爬数据、黑客DDoS攻击。
保护服务器不被压垮，比如一个接口挂了，拖垮整个服务。
保证核心业务的可用性，比如大促场景下，支付接口优先，对普通接口进行限流。

技术选型

方案	数据结构+算法	核心思想	优缺点	适用场景
固定窗口计数器	数组/Map + 时间戳	把时间分成固定的窗口，每个窗口内计数	简单易实现；有临界问题（比如4.9秒刷10次，5.1秒又刷10次，实际0.2秒内刷了20次）	对精度要求不高的场景
滑动窗口计数器	本地：LinkedList（双向链表）分布式：Redis ZSet（有序集合） + 时间戳	窗口是“滑动”的，只保留当前窗口内的请求	解决了固定窗口的临界问题；本地版 LinkedList 删头加尾 O (1)，分布式版 ZSet 按时间范围操作高效；本地版不适合分布式集群	固定时间窗口内精确计数的场景
漏桶算法	队列 + 定时器	像漏桶一样，请求先存到队列里，然后匀速处理	可以削峰填谷；突发流量处理不了（秒杀时很多请求直接被拒）	对流量稳定性要求高的场景（比如消息队列）
令牌桶算法	队列 + 定时器	像令牌桶一样，匀速生成令牌，请求拿到令牌才能通过	可以削峰填谷，也可以处理突发流量	对流量稳定性和突发流量都有要求的场景（比如API网关）

滑动窗口计数器

滑动窗口的核心，是窗口不再是静止分段的，而是随当前时间连续移动、互相重叠的：

比如固定窗口，窗口是死的，0-5秒、5-10秒，边界固定不变。

而滑动窗口，窗口的右边界永远是当前请求的时间，左边界永远是当前时间 - 窗口大小，窗口会跟着每一次请求一直往前滑。

数据结构选型

本地：LinkedList（双向链表）

选择双向链表是因为我们需要频繁删除链表头部的过期时间戳，并且还需要频繁在链表尾部新增新的请求时间戳，而双向链表的删头、加尾操作时间复杂度都是O(1)，效率极高。

分布式：Redis ZSet（有序集合）

Web项目基本都是集群部署，本地计数器无法多实例同步，考虑用Redis实现。

选择Redis中的ZSet数据结构，ZSet的score字段可以存请求的时间戳，天然支持按时间范围排序。

实现逻辑

每次请求进来，执行 3 步：

删掉所有早于当前时间 - 窗口大小的请求
统计当前窗口内的请求数，超过 10 次直接拒绝
把当前请求的时间戳加入数据结构，放行请求

小贴士

令牌桶的令牌生成速度要合理

不能太快（等于没限流），也不能太慢（很多请求被拒），要根据业务场景调整。

Redis ZSet的过期时间要设置对

要设置成窗口大小+一点缓冲（比如1秒），防止数据提前过期，导致计数不准确。

【面试真题拆解】Spring事务机制

Fri, 20 Mar 2026 09:06:26 +0000

之前面试的时候还真的有一个面试官问过我：

什么是事务？

事务，说人话就是：

把多个数据库操作打包成一个“不可分割的整体”，要么全成功，要么全失败并回滚到最初状态，绝对不会出现“只做了一半”的情况。

以生活中最经典的银行转账举个例子那是再合适不过了。

且看：

A给B转100块钱，这一笔转账业务，其实是由两步独立的数据库操作组成的：

A的账户扣100块

B的账户加100块

这两步必须同时成功、一起生效。

如果A扣了钱B没收到，或者B收到了钱A没扣，那银行就乱套了。

事务的四大特性

用银行转账的例子加深理解：

特性	解释	银行转账例子
原子性（Atomicity）	要么全做，要么全不做，就像“原子”一样不可分割	A扣钱和B加钱必须同时成功，不能A扣了B没加
一致性（Consistency）	事务前后，数据要保持“一致”，总金额不变	转账前A有1000，B有0，总和是1000；转账后A有900，B有100，总和还是1000
隔离性（Isolation）	多个事务同时执行时，互相不干扰，就像“隔离开”一样	两个转账操作同时改A的账户，不能互相影响，不然钱就不对了
持久性（Durability）	事务提交后，数据就永久保存了，就算数据库挂了也不会丢	转账成功后，就算银行服务器断电重启，A和B的钱数也不会变

隔离级别

为什么要有隔离级别呢？

如果多个事务同时执行，没有隔离的话，会出现3个问题：

脏读

脏读就是读到了别人还没提交的数据。

比如A转给B100块，还没提交，B就查到自己多了100块，结果A回滚了，B白高兴一场。

不可重复读

不可重复读的意思是同一个事务里，两次读同一条数据的结果是不一样的。

比如A查自己有1000块，中间B转给了A100块提交了，A再查就变成1100了。

幻读

幻读就是同一个事务里，两次查的数量不一样。

比如A查账户里有10条记录，中间B插了一条提交了，A再查就变成11条了，就像“幻觉”一样。

这么看，不可重复读和幻读是由别的事务提交后导致的错误，而脏读是读到了别人还没提交的临时数据。

那不可重复读和幻读两者的区别在哪呢？

不可重复读是盯着一条记录看，发现这条记录的内容变了。

而幻读是盯着一堆记录数看，发现总数量变了。

类比一下就是不可重复读是你看自己的银行卡余额，钱数变了；而幻读是你数银行有多少张卡，卡的数量变了。

隔离级别	解决的问题	解释
读未提交（Read Uncommitted）	啥都解决不了	能读到别人没提交的数据，脏读、不可重复读、幻读都有，一般不用
读已提交（Read Committed）	脏读	只能读到别人提交后的数据，但会有不可重复读、幻读
可重复读（Repeatable Read）	脏读、不可重复读	Spring默认的隔离级别。同一个事务里，两次读同一个数据一样，但会有幻读（MySQL InnoDB用MVCC解决了幻读）
串行化（Serializable）	所有问题	事务一个接一个执行，就像“排队”一样，性能最差，一般不用

传播行为

传播行为就是：

当一个事务方法调用另一个事务方法时，这两个事务该怎么协作？是直接加入原事务？还是新建一个独立的事务？还是先挂起原事务，等新事务执行完再继续？

以下是3 个常用的传播行为:

传播行为	解释	适用场景
REQUIRED（默认）	有事务就加入，没有就新建一个事务	最常用，比如转账服务
REQUIRES_NEW	新建一个事务，挂起原事务，等新事务执行完再继续原事务	比如记录日志，不管主事务成功失败，日志都要记录
NESTED	嵌套事务，有一个保存点： 1. 子事务回滚：只回滚自己，不影响父事务和其他子事务 2. 父事务回滚：带着所有子事务一起回滚	系统批量发福利：某一个用户的福利发放失败，不影响其他用户；但整体回滚，所有用户的福利都会被收回

小贴士

Spring AOP 是基于代理的，@Transactional 只能用在 public 方法上，不然不生效。不管是 JDK 动态代理还是 CGLIB 代理，Spring 都只保证 public 方法的事务生效，非 public 的写了也白写。
内部调用不会走代理类，直接调用this.method()，所以，同一个类里方法调用，@Transactional不生效。
Spring默认只回滚非受检异常（RuntimeException、Error），受检异常（Exception）不回滚。如果要所有异常都回滚，需要在 @Transactional 里加rollbackFor = Exception.class。
MySQL的MyISAM引擎不支持事务，只有InnoDB支持。

告别腾讯云 COS，用 GitHub + jsDelivr 搭建零成本图床

Thu, 19 Mar 2026 17:10:48 +0000

我的个人项目中有这么一个功能，就是个人作品页面需要显示详情页的预览截图，这样会显得更专业一点。

但是，截图之前是存在腾讯云COS中的，最近我的腾讯云 COS 到期了，我就开始寻找替代方案。

想换 Cloudflare R2 吧，听说很香零费用，结果还要信用卡验证，我这种没有国际信用卡的人直接被拒之门外。

经过一番调研和实践，我锁定了一个纯白嫖、零成本、高速度的方案：

GitHub 仓库存储 + jsDelivr CDN 加速

本文将介绍一下如何在 Spring Boot 项目中集成这一方案。

技术选型

维度	腾讯云 COS	GitHub + jsDelivr
存储费用	按量计费/资源包（需续费）	完全免费 (建议单仓库 < 1GB，单文件 < 50MB，GitHub 有软限制)
流量费用	下行流量贵（容易被盗链刷爆）	完全免费 (jsDelivr 提供的全球加速)
支付门槛	需实名、绑定支付方式	仅需一个 GitHub 账号
国内访问	速度快，但费钱	通过 jsDelivr 加速，速度极快

准备工作

创建一个新的公开仓库（Public），例如 ObjectStorage。
生成 Personal Access Token (PAT)

在Github账户进入【Settings】➡️【Developer settings】➡️【Personal access tokens】➡️【 Tokens (classic)】。

小贴士

创建Token时必须要勾选 repo 权限，并且创建的时候就得保存好生成的 Token，因为它只会出现一次。

图片截图上传成功后，访问链接格式为：
https://cdn.jsdelivr.net/gh/用户名/仓库名@分支名/文件路径

代码实现

引入依赖

需要 OkHttp 处理网络请求，FastJSON 处理 JSON 数据。

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.10.0</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.32</version>
</dependency>

application-local

为了开源安全，将敏感信息放在 application-local.yml 中，并确保该文件在 .gitignore 中。

# application-local.yml
github:
  owner: github用户名
  repo: ObjectStorage
  branch: main
  token: ghp_你的TOKEN

GithubConfig

讲原CosConfig加上@Deprecated，新增GithubConfig

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "github")
public class GithubConfig {
    private String owner;
    private String repo;
    private String branch;
    private String token;
}

GithubManager

为了模仿对象存储的 SDK，将文件转为 Base64 并调用 GitHub API 进行 PUT 上传。

将原CosManager加上@Deprecated，新增GithubManager

@Component
@Slf4j
public class GithubManager {

    @Resource
    private GithubConfig githubConfig;

    private final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(15, TimeUnit.SECONDS)
            .readTimeout(15, TimeUnit.SECONDS)
            .build();

    /**
     * 上传文件到 GitHub 仓库
     *
     * @param key  存储路径
     * @param file 本地文件
     * @return jsDelivr CDN 访问地址
     */
    public String uploadFile(String key, File file) {
        // 1. 读取文件并转为 Base64
        byte[] fileBytes = FileUtil.readBytes(file);
        String base64Content = Base64.getEncoder().encodeToString(fileBytes);

        // 2. 构建 GitHub API 请求体
        JSONObject json = new JSONObject();
        json.put("message", "upload screenshot: " + file.getName());
        json.put("content", base64Content);
        json.put("branch", githubConfig.getBranch());

        // 注意：GitHub API 路径开头不能有 /
        if (key.startsWith("/")) {
            key = key.substring(1);
        }

        String url = String.format("https://api.github.com/repos/%s/%s/contents/%s",
                githubConfig.getOwner(), githubConfig.getRepo(), key);

        RequestBody body = RequestBody.create(
                json.toJSONString(),
                MediaType.parse("application/json; charset=utf-8")
        );

        Request request = new Request.Builder()
                .url(url)
                .addHeader("Authorization", "token " + githubConfig.getToken())
                .put(body)
                .build();

        // 3. 发送请求
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                // 返回 jsDelivr CDN 链接
                return String.format("https://cdn.jsdelivr.net/gh/%s/%s@%s/%s",
                        githubConfig.getOwner(),
                        githubConfig.getRepo(),
                        githubConfig.getBranch(),
                        key);
            } else {
                log.error("GitHub 上传失败, 错误码: {}, 详情: {}", response.code(), response.body().string());
                return null;
            }
        } catch (IOException e) {
            log.error("GitHub 上传网络异常", e);
            return null;
        }
    }
}

GithubScreenshotServiceImpl

为了保留原ScreenshotServiceImpl的逻辑，新增一个GithubScreenshotServiceImpl同样也实现ScreenshotService 接口。

/**
 * GithubScreenshotServiceImpl类实现了ScreenshotService接口，提供网页截图生成并上传到 GitHub 的服务
 */
@Service("githubScreenshotService") // 指定 Bean 名称，防止和原 COS 实现冲突
@Slf4j
public class GithubScreenshotServiceImpl implements ScreenshotService {

    @Resource
    private GithubManager githubManager; // 注入新写的 GithubManager

    @Override
    public String generateAndUploadScreenshot(String webUrl) {
        ThrowUtils.throwIf(StrUtil.isBlank(webUrl), ErrorCode.PARAMS_ERROR, "网页URL不能为空");
        log.info("开始生成网页截图(GitHub方案)，URL:{}", webUrl);

        // 1. 调用工具方法保存网页截图到本地
        String localScreenshotPath = WebScreenshotUtils.saveWebPageScreenshot(webUrl);
        ThrowUtils.throwIf(StrUtil.isBlank(localScreenshotPath), ErrorCode.OPERATION_ERROR, "本地截图生成失败");

        try {
            // 2. 调用方法将本地截图上传到 GitHub
            String githubUrl = uploadScreenshotToGithub(localScreenshotPath);
            ThrowUtils.throwIf(StrUtil.isBlank(githubUrl), ErrorCode.OPERATION_ERROR, "截图上传 GitHub 失败");

            log.info("网页截图生成并上传 GitHub 成功: {} -> {}", webUrl, githubUrl);
            return githubUrl;
        } finally {
            // 3. 清理本地文件
            cleanupLocalFile(localScreenshotPath);
        }
    }

    private String uploadScreenshotToGithub(String localScreenshotPath) {
        if (StrUtil.isBlank(localScreenshotPath)) {
            return null;
        }

        File screenshotFile = new File(localScreenshotPath);
        if (!screenshotFile.exists()) {
            log.error("截图文件不存在: {}", localScreenshotPath);
            return null;
        }

        // 生成文件名
        String fileName = UUID.randomUUID().toString().substring(0, 8) + "_compressed.jpg";
        // 生成 GitHub 存储路径
        String githubKey = generateScreenshotKey(fileName);

        // 调用 GitHub 管理器
        return githubManager.uploadFile(githubKey, screenshotFile);
    }

    private String generateScreenshotKey(String fileName) {
        String datePath = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
        // 注意：GitHub 路径不建议以 / 开头
        return String.format("screenshots/%s/%s", datePath, fileName);
    }

    private void cleanupLocalFile(String localFilePath) {
        File localFile = new File(localFilePath);
        if (localFile.exists()) {
            File parentDir = localFile.getParentFile();
            FileUtil.del(parentDir);
            log.info("本地截图临时文件已清理: {}", localFilePath);
        }
    }
}

小贴士

这里有一个问题需要注意，@Deprecated 只是给程序员看的“警告”标签，它并不能阻止 Spring 扫描并加载这个 Bean。

所以，为了避免Spring 在启动时发现有两个类都实现了 ScreenshotService 接口，并且都加上了 @Service 注解。

当其他地方需要注入 ScreenshotService 时，Spring 不知道该选哪一个的问题。

需要在ScreenshotServiceImpl类中添加@Deprecated 的同时，把@Service 注解注释掉。

// @Service  <-- 把这个注释掉，Spring 就不会把它当成一个 Bean 加载了
@Slf4j
@Deprecated
public class ScreenshotServiceImpl implements ScreenshotService {
    // ... 原有的代码
}

之后项目的预览界面就可以看到截图了：

23种设计模式，一次性讲明白

Thu, 19 Mar 2026 12:50:01 +0000

设计模式其实就是前辈们写代码踩了无数坑，总结出来的代码编写最佳实践，专门用来解决特定场景下的代码复用、解耦、扩展性问题。

可以分为创建型模式、结构型模式、行为型模式三类。

分类	核心作用	包含的设计模式	数量
创建型模式	解决对象怎么创建的问题，解耦对象的创建和使用	单例、工厂方法、抽象工厂、建造者、原型	5种
结构型模式	解决类/对象怎么组合的问题，不修改原有代码实现功能扩展	适配器、桥接、组合、装饰、外观、享元、代理	7种
行为型模式	解决类/对象之间怎么交互、职责怎么分配的问题，实现灵活的通信和流程控制	模板方法、命令、迭代器、观察者、中介者、备忘录、解释器、状态、策略、职责链、访问者	11种

记忆口诀

创建型口诀（5种）

单身汉在工厂抽象建原型。

一个单身汉，在工厂里用抽象方法，建造了一个原型。

结构型口诀（7种）

桥上代理卖装饰，组合适配享外观。

桥上的代理商在卖装饰品，把零件组合适配好，让你享受精美外观。

行为型口诀（11种）

访客观察定策略，模板迭代改状态，备忘命令交中介，解释责任一条链。

访客观察后定下策略，按模板迭代改变状态，把备忘录和命令交给中介，出了问题沿责任链逐一解释。

创建型模式

不让你自己new对象，把对象创建的逻辑封装起来，和业务代码解耦。

1. 单例模式

整个系统里，这个类有且只有一个实例对象，不管你在哪获取，拿到的都是同一个东西。

类比

就像公司里只有一个 CEO，不管哪个部门找，对接的都是同一个人。

适用场景

Spring容器里的单例Bean、全局配置类、日志对象

代码示例

public class Singleton {
    // 1. 私有构造方法：禁止外部new对象
    private Singleton() {}

    // 2. 私有静态实例，volatile禁止指令重排
    private static volatile Singleton instance;

    // 3. 公共静态方法，获取唯一实例
    public static Singleton getInstance() {
        // 第一次校验：实例已存在就直接返回，不用抢锁
        if (instance == null) {
            // 加锁，保证线程安全
            synchronized (Singleton.class) {
                // 第二次校验：防止多线程同时进入第一个if，重复创建
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 工厂方法模式

定义一个创建对象的工厂接口，让子类决定创建哪个对象，把对象的创建延迟到子类。

类比

就像奶茶店是工厂接口，蜜雪冰城、喜茶是子类工厂，你去哪个店，就喝哪个店的奶茶，不用管奶茶是怎么做的。

适用场景

不知道要创建的对象具体类型，交给子类决定
把对象创建和业务代码解耦
Spring的FactoryBean

代码示例

// 1. 产品接口：奶茶
public interface MilkTea {
    void make();
}

// 2. 具体产品：蜜雪冰城奶茶
public class MixueMilkTea implements MilkTea {
    @Override
    public void make() {
        System.out.println("蜜雪冰城奶茶做好了！");
    }
}

3. 抽象工厂模式

工厂方法的升级版，一个工厂可以创建一系列相关的产品，而不是只创建一个。

和工厂方法的区别是：

工厂方法是单个产品，而抽象工厂是一套相关产品。

类比

就像蜜雪冰城不仅能做奶茶，还能做冰淇淋、圣代，一个工厂搞定同品牌的一系列产品。

适用于需要创建一系列相关联的产品，而不是单个产品的场景（比如同一品牌的奶茶 + 冰淇淋 + 圣代）。

4. 建造者模式

把一个复杂对象的创建和表示分离，一步一步构建出复杂对象，不用管内部组装细节。

类比

就像组装电脑，你只需要告诉装机店你要什么 CPU、显卡、内存，装机店帮你一步步组装好，不用你自己焊主板。

适用场景

复杂对象的创建，参数特别多（比如超过4个参数）
Lombok的@Builder注解

代码示例

// 电脑类（复杂对象）
public class Computer {
    private String cpu;
    private String gpu;
    private int memory;
    private int storage;

    // 私有构造方法，只能通过Builder创建
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.gpu = builder.gpu;
        this.memory = builder.memory;
        this.storage = builder.storage;
    }

    // 建造者静态内部类
    public static class Builder {
        private String cpu;
        private String gpu;
        private int memory;
        private int storage;

        // 链式调用设置参数
        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder gpu(String gpu) {
            this.gpu = gpu;
            return this;
        }

        public Builder memory(int memory) {
            this.memory = memory;
            return this;
        }

        public Builder storage(int storage) {
            this.storage = storage;
            return this;
        }

        // 构建最终对象
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        // 链式调用，一步一步构建对象
        Computer computer = new Computer.Builder()
                .cpu("i7-14700K")
                .gpu("RTX4070")
                .memory(32)
                .storage(1024)
                .build();
    }
}

5. 原型模式

基于一个已有的对象，克隆出一个一模一样的新对象，不用重新new和初始化。

类比

就像打印机复印文件，不用重新手写一遍，直接复印一份一模一样的。

适用场景

对象创建成本很高（比如初始化要查数据库、调接口）
想要和原对象一模一样的新对象，又不想重新初始化
Spring的Bean的原型作用域

结构型模式

不修改原有代码，通过类/对象的组合，实现功能扩展和灵活组装。

1. 适配器模式

把一个不兼容的接口，转换成你想要的兼容接口，让两个不搭边的类能一起工作。

类比

就像 Type-C 转 3.5mm 耳机转接头，手机只有 Type-C 口，耳机是 3.5mm 口，转接头让它们能一起用。

适用场景

老系统接口复用，适配新的业务
Spring MVC的HandlerAdapter

2. 装饰器模式

在不修改原有类的基础上，动态给对象添加新功能，比继承更灵活。

类比

就像买奶茶，基础款是纯茶，你可以加珍珠、加椰果、加奶盖，一层一层加功能，不用重新做一杯新奶茶。

适用场景

动态给对象添加/撤销功能，不想用继承搞出一堆子类
Java IO流（FileInputStream + BufferedInputStream）
Spring的TransactionProxyFactoryBean

3. 代理模式

给目标对象创建一个代理对象，通过代理对象控制对目标对象的访问，还能在不修改目标对象的前提下加额外功能。

类比

就像租房找中介，你不用直接对接房东，中介帮你搞定看房、签合同，还能帮你做背景调查。

适用场景

远程代理：RPC调用
权限控制、日志记录、事务管理
Spring AOP的动态代理

4. 外观模式

给复杂的子系统提供一个统一的高层入口，隐藏子系统的复杂细节，调用方只需要和这个入口交互就行。

类比

就像酒店前台，你不用管酒店的保洁、维修、餐饮、安保各个部门，有任何事找前台就行，前台帮你对接所有部门。

适用场景

复杂系统简化调用，封装底层细节
Spring Boot的starter就是外观模式的思想

5. 桥接模式

把抽象和实现分离，让它们可以独立变化，解决多维度变化导致的类爆炸问题。

类比

就像手机和手机壳，手机有苹果、华为、小米，手机壳有透明、硅胶、卡通，两个维度独立变化，不用为每个手机做一套专属手机壳。

适用于类有多个独立变化的维度，用继承会导致子类数量爆炸的场景。

6. 组合模式

把对象组合成树形结构，用来表示整体-部分的层级关系，让调用方对单个对象和组合对象的使用是一致的。

类比

就像公司组织架构，总公司下面有分公司，分公司下面有部门，部门下面有员工，不管是总公司、分公司、部门还是员工，都可以统一用组织节点来表示。

适用场景

树形结构的数据，比如菜单、部门组织、文件目录
想要统一处理单个对象和组合对象，不用区分是整体还是部分

7. 享元模式

共享细粒度的对象，减少对象创建的数量，节省内存，核心是复用对象。

类比

就像共享单车，不是每个人都买一辆新自行车，而是大家共享一批单车，用完还回去，别人继续用。

适用场景

Java的字符串常量池、Integer缓存池
连接池、线程池（享元模式 + 单例模式的结合体）

行为型模式

解决类和对象之间的通信、职责分配问题，让对象之间协作更灵活、职责更清晰。

1. 策略模式

定义一系列算法，把每个算法封装起来，让它们可以互相替换，算法的变化不会影响使用算法的用户。

类比

就像出行，你可以选骑自行车、坐地铁、开车、坐飞机，这些都是不同的出行策略，你可以根据目的地、预算随便换，不用改变你要出门的目标。

适用场景

一个业务有多种实现方式，需要动态切换
想要避免大量的if-else/switch分支
Spring的Resource接口、BeanNameGenerator

代码示例

// 1. 策略接口：出行方式
public interface TravelStrategy {
    void travel();
}

// 2. 具体策略：坐地铁
public class SubwayStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("坐地铁出行，便宜又快");
    }
}

// 3. 具体策略：开车
public class CarStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("开车出行，自由方便");
    }
}

// 4. 用户
public class Traveler {
    private TravelStrategy strategy;

    // 动态设置策略
    public void setStrategy(TravelStrategy strategy) {
        this.strategy = strategy;
    }

    // 执行出行
    public void goTravel() {
        strategy.travel();
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Traveler traveler = new Traveler();
        // 今天坐地铁
        traveler.setStrategy(new SubwayStrategy());
        traveler.goTravel();
        // 明天开车
        traveler.setStrategy(new CarStrategy());
        traveler.goTravel();
    }
}

2. 观察者模式

定义了对象之间一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会收到通知并自动更新。

类比

就像你关注了一个CSDN博主，博主更新博客了，所有关注他的粉丝都会收到推送通知。

适用场景

事件驱动、消息通知、发布订阅
Spring的ApplicationEvent事件机制
Java的EventListener

3. 模板方法模式

定义一个操作的算法骨架，把其中一些步骤延迟到子类实现，子类可以不改变算法骨架，就可以重定义特定步骤。

类比

就像煮奶茶，固定骨架是煮茶➡️加奶➡️加料➡️装杯，不同的奶茶只是加料、煮茶时间不一样，骨架永远不变。

小贴士

煮奶茶是模板方法模式，关注的是怎么做奶茶，而开奶茶店造奶茶是工厂方法模式，关注的是造什么奶茶。

适用场景

多个子类有公共的流程，只有个别步骤不同
Spring的JdbcTemplate、RedisTemplate
Spring MVC的HttpServlet

4. 责任链模式

把请求的发送者和接收者解耦，让多个对象都有机会处理这个请求，把这些对象连成一条链，请求沿着链传递，直到有对象处理它为止。

类比

就像公司请假审批，1天以内组长批，3天以内经理批，7天以内总监批，超过7天老板批，你的请假申请沿着这个审批链传递，直到有人处理。

适用场景

一个请求需要多个对象依次处理
Spring MVC的HandlerInterceptor拦截器链
Servlet的Filter过滤器链

5. 状态模式

当一个对象的内部状态发生变化时，改变它的行为，看起来就像这个对象换了一个类。

类比

就像电梯，开门状态下只能关门，不能上下行；运行状态下只能停梯，不能开门；不同的状态，电梯的行为完全不一样。

适用场景

对象的行为由状态决定，运行时状态变化会改变行为
代码里有大量和状态相关的if-else/switch分支

小贴士

状态模式和策略模式容易混淆，不过两者的区别是：

状态模式是状态决定行为，对象的行为由当前状态决定；而策略模式是算法可替换，封装一系列平级算法，想换哪个换哪个。
状态模式有明确的状态流转图，状态之间不能随便跳，必须按规则流转；策略模式没有流转关系，策略之间是平级的，想换就换。
状态模式关注的是对象状态的变化以及状态变化带来的行为变化；策略模式关注的是算法的选择和替换，不关心算法之间的关系。

扯了那么多官话，好像没多大用，举个例子套一下大概就是：

比如电梯是状态模式，开门、上下行、关门有明确的流转规则；

而出行是策略模式，骑自行车、坐地铁、开车是平级的，想换就换。

6. 命令模式

把一个请求封装成一个命令对象，让你可以用不同的请求参数化对象，支持请求排队、撤销、重做。

类比

就像餐厅点餐，你点的菜就是一个命令，服务员把命令传给后厨，后厨执行，你不用管后厨是谁、怎么做的，还能随时加菜、退菜。

适用场景

Spring 的 JmsTemplate（JMS 消息队列）和 RabbitTemplate（RabbitMQ 消息队列）

7. 迭代器模式

提供一种统一的方式，遍历一个集合对象里的所有元素，不用暴露集合的内部结构。

类比

就像景区观光车，不管景区里的景点是怎么分布的，你坐观光车就能一个一个逛完所有景点，不用管景区内部的路线设计。

适用场景

Java的Iterator接口、增强for循环
Spring的CompositeIterator

8. 中介者模式

用一个中介对象封装一系列对象的交互，让对象之间不用直接互相引用，解耦对象之间的复杂依赖，只和中介者交互。

类比

就像机场塔台，所有飞机不用互相沟通，只需要和塔台沟通，塔台统一调度，避免撞机。

适用场景

想要解耦多个对象的交互，减少耦合
Spring MVC的DispatcherServlet，就是前端控制器中介者

9. 备忘录模式

在不破坏封装的前提下，捕获一个对象的内部状态，并保存下来，之后可以恢复到这个状态。

类比

就像游戏存档，你打BOSS之前存个档，打输了可以读档回到存档时的状态，不用重新从头玩。

适用场景

撤销、回滚操作
数据库的事务回滚
IDE的撤销操作

10. 访问者模式

在不修改数据结构的前提下，定义对数据结构中元素的新操作，把数据结构和操作分离。

类比

比如电商订单系统，数据结构是固定的订单和订单明细，操作是经常变化的计算总价、打印发票、生成物流单、发送短信通知。不用修改订单 / 订单明细的代码，只要新增一个访问者（比如生成电子发票），就能给订单增加新操作。

适用于想要给数据结构里的元素增加新操作，又不想修改数据结构的场景。

11. 解释器模式

给定一个语言，定义它的语法规则，然后定义一个解释器，用这个解释器来解释语言中的句子。

类比

就像翻译官，你说中文，翻译官根据中英文的语法规则，把你的话翻译成英文。

适用场景

SQL解析、正则表达式解析
Spring的SpEL表达式

【面试真题拆解】电商高并发场景下商品详情页系统设计

Wed, 18 Mar 2026 12:32:01 +0000

很多面试官早就对“Redis缓存、MySQL分库分表”这些东西形成免疫了，他们更想要听到的是一个完整的链路，比如从服务到数据、从接入到落地的全流程设计。

当时面试官问我：

一家电商公司，它主要是面向消费者的，公司的一些业务场景流量会很高，比如说展示商品的那个页面，它的流量就很高，假设现在由你来做这个系统，负责商品详情页的展示，你能从服务的层面，数据的层面等多个维度来设计一下，让它能够支持一个更高的查询能力。

场景梳理

业务背景
电商商品详情页，面对百万级QPS的高并发流量（比如大促、爆款商品）。

需求分析

性能：支持高并发查询，响应时间 < 100ms
一致性：商品价格、库存、标题修改后，能及时更新
高可用：服务挂了、Redis挂了，系统不崩
可扩展：新增商品、新增规格，能快速接入

关键数据
商品基本信息（标题、主图、详情图）、价格（实时/活动）、库存、规格参数、促销信息（优惠券/秒杀）、评价统计。

设计思路

以“多级缓存”为核心，配合“服务分层+数据分层+异步更新”，构建“读多写少”的高并发详情页系统。

系统架构

服务层面

采用前后端分离+网关层+服务分层架构：

层级	作用
CDN层	静态资源加速（图片、js、css、详情页HTML）
网关层	路由、限流、鉴权、接口聚合
API网关聚合层	聚合多个微服务接口（比如商品基础信息、价格、库存、评价），减少请求次数
商品服务层	核心业务逻辑（查商品、查库存、查价格）
数据服务层	专门做数据查询（缓存+数据库）

商品详情页是典型的读多写少场景，考虑服务层本地缓存 + 分布式缓存。

采用Caffeine作为服务层本地缓存，缓存极热点商品（比如爆款商品），避免每次请求都走Redis，

采用Redis作为分布式缓存，作为核心缓存层，缓存所有商品的详情数据。

调用流程：

先查本地缓存（Caffeine），如果命中就直接返回；

如果本地未命中，查 Redis，命中则写入本地缓存，返回；

如果Redis 未命中，查数据库，查到则写入 Redis + 本地缓存，返回。

数据层面

商品数据分为3类，不同类型用不同策略：

数据类型	例子	缓存策略
静态数据	商品标题、主图、详情图、规格参数	永久缓存（不过期），更新时主动删除
半动态数据	商品价格、促销信息（优惠券、满减）	短期缓存（5-10分钟），更新时主动删除
动态数据	库存（实时）、实时销量	单独缓存，库存用Redis原子操作；实时销量异步更新

缓存更新的原则：

为了避免高并发下的缓存不一致问题，采用的是先更新数据库，再删除缓存的方式。

高并发优化

1.热点数据预热

大促前，把热门商品（如销量TOP100）写入Redis和本地缓存。

限流+熔断+降级

对商品详情接口设置限流。

考虑使用服务熔断，当Redis/数据库不可用时，快速失败，避免系统雪崩。

或者考虑使用降级策略，当Redis挂了，降级到直接查数据库，如果数据库也挂了，降级返回默认商品信息。

页面静态化

对于完全静态的商品（比如虚拟商品或者不参与促销的商品），生成静态HTML页面，直接存到CDN，这样的话用户请求直接由CDN返回，不经过任何服务。

【面试真题拆解】高并发场景下“恶意登录设备识别”系统设计

Wed, 18 Mar 2026 10:41:34 +0000

这是面试遇到的一道场景题。

面试官问我：

有这么一个场景，现在有一个网站，这个网站访问的人非常多，在登录的时候有些坏人来这里捣乱，怎么去设计一个系统实现把这些坏人找到的逻辑。

条件说一下：

登录的时候你要的用户userid，时间，设备deviceid这些信息都有；

坏人的定义是：最近十分钟之内，一个设备上登录了大于等于5个user，我就认为这个是坏人。

场景梳理

输入信息：用户登录时的 userId（用户ID）、timestamp（登录时间戳）、deviceId（设备ID）；
坏人定义：最近10分钟（600秒）内，同一个deviceId上登录了≥5个不同的userId；
输出结果：标记该deviceId为“恶意设备”，后续可以做拦截、验证码、风控等处理。

实现方案

考虑用Redis ZSet实现滑动窗口。

为什么选Redis？

主要是因为：

单线程高性能，适合高并发场景
内存数据库，读写速度极快
支持丰富的数据结构（比如这次场景需要的ZSet）
支持过期时间，自动清理数据

为什么选ZSet？

ZSet（有序集合）是 Redis 中最适合做 “时间窗口、排行榜、去重 + 排序” 的数据结构。

它有以下几个特点：
Member（成员）唯一，Member 不能重复，天然去重；
每个 Member 对应一个 Score（分数），Score 是一个浮点数，用来排序；
ZSet 会自动按 Score 从小到大进行排序，如果Score 相同则按 Member 字典序排序。

ZSet 的底层是哈希表 + 跳表，哈希表保证 Member 唯一、O (1) 查找，跳表保证有序、O (log n) 范围查询。

数据模型

维度	说明
Key	`login:device:{deviceId}`（比如 `login:device:abc123`）
Value（ZSet Member）	`userId`（用户ID，保证唯一性，去重）
Score（ZSet Score）	`登录时间戳`（用于滑动窗口）

理一下整个流程

用户发起登录请求：携带 userId、deviceId、timestamp；
先查黑名单：如果已经是恶意设备，直接拦截；
写入登录记录到Redis ZSet：以 deviceId 为Key，userId 为Member，timestamp 为Score，写入ZSet；
清理过期数据：删除ZSet中Score < 当前时间 - 10分钟的元素；
统计最近10分钟内的不同userId数量：用 ZCard 命令统计ZSet的元素个数；
判断是否为坏人：如果数量≥5，标记该deviceId为恶意设备，存入Redis黑名单；
返回登录结果：如果是恶意设备，返回“请完成验证码”或“登录失败”；否则正常登录。

简化版的代码实现

用Spring Boot + RedisTemplate写一个简化版的实现，加深理解一下：

（1）先定义Redis Key的前缀和常量

public class RedisKeyConstants {
    // 设备登录记录Key前缀
    public static final String LOGIN_DEVICE_KEY_PREFIX = "login:device:";
    // 恶意设备黑名单Key前缀
    public static final String MALICIOUS_DEVICE_KEY_PREFIX = "malicious:device:";
    // 滑动窗口大小：10分钟（600秒）
    public static final int WINDOW_SIZE_SECONDS = 600;
    // 坏人阈值：≥5个不同userId
    public static final int MALICIOUS_THRESHOLD = 5;
    // 过期时间：10分钟
    public static final int EXPIRE_TIME_SECONDS = 600;
}

（2）服务实现

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class LoginRiskControlService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 检查是否为恶意设备
     * @param userId 用户ID
     * @param deviceId 设备ID
     * @return true-是恶意设备，false-正常设备
     */
    public boolean checkMaliciousDevice(String userId, String deviceId) {
        // 1. 构造Redis Key
        String loginKey = RedisKeyConstants.LOGIN_DEVICE_KEY_PREFIX + deviceId;
        String maliciousKey = RedisKeyConstants.MALICIOUS_DEVICE_KEY_PREFIX + deviceId;

        // 2. 先查黑名单：如果已经是恶意设备，直接返回true
        if (Boolean.TRUE.equals(redisTemplate.hasKey(maliciousKey))) {
            return true;
        }

        // 3. 获取当前时间戳（秒）
        long currentTime = System.currentTimeMillis() / 1000;
        // 计算窗口起始时间：当前时间 - 10分钟
        long windowStartTime = currentTime - RedisKeyConstants.WINDOW_SIZE_SECONDS;

        // 4. 写入当前登录记录到ZSet：Member=userId，Score=当前时间戳
        redisTemplate.opsForZSet().add(loginKey, userId, currentTime);

        // 5. 清理过期数据：删除Score < 窗口起始时间的元素
        redisTemplate.opsForZSet().removeRangeByScore(loginKey, 0, windowStartTime);

        // 6. 统计最近10分钟内的不同userId数量（ZSet的元素个数）
        Long count = redisTemplate.opsForZSet().zCard(loginKey);

        // 7. 设置Key的过期时间：10分钟（防止内存泄漏）
        redisTemplate.expire(loginKey, RedisKeyConstants.EXPIRE_TIME_SECONDS, TimeUnit.SECONDS);

        // 8. 判断是否为坏人：数量≥5
        if (count != null && count >= RedisKeyConstants.MALICIOUS_THRESHOLD) {
            // 标记为恶意设备，存入黑名单，过期时间可以设长一点（比如24小时）
            redisTemplate.opsForValue().set(maliciousKey, "1", 24, TimeUnit.HOURS);
            return true;
        }

        // 9. 正常设备，返回false
        return false;
    }
}

（3）在登录接口中调用

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/login")
public class LoginController {

    @Autowired
    private LoginRiskControlService riskControlService;

    @PostMapping
    public String login(String userId, String deviceId) {
        // 1. 先检查是否为恶意设备
        boolean isMalicious = riskControlService.checkMaliciousDevice(userId, deviceId);
        if (isMalicious) {
            return "登录失败：检测到异常设备，请完成验证码验证";
        }

        // 2. 正常登录逻辑（校验账号密码、生成Token等）
        // ...

        return "登录成功";
    }
}

高并发场景的优化

在访问量非常大的场景下，上面的代码肯定扛不住，所以还需要做一些优化。

1. 布隆过滤器快速过滤正常设备

如果每个登录请求都查Redis，Redis的压力会很大。

可以考虑用布隆过滤器先快速过滤：

在布隆过滤器里只存“潜在恶意设备”（比如最近10分钟内登录过≥3个userId的设备），登录时先查布隆过滤器，如果不在里面，直接放行，不查Redis；如果在里面，再查Redis确认。

2. 异步处理

如果Redis查询慢，会阻塞主登录流程，影响用户体验。

考虑把“写入ZSet、清理过期数据、统计数量、判断坏人”这些步骤用线程池或消息队列异步执行，这样的话主登录流程只做“账号密码校验、生成Token”，用户体验会更好一点。

小贴士：

异步会有极短的延迟，但是风控允许这种小误差。

3. 本地缓存+Redis双层缓存

如果恶意设备黑名单查询很频繁，每次都查Redis还是会有压力。

考虑用本地缓存（比如Caffeine）+ Redis 的双层缓存。

这样一来本地缓存存“最近1分钟内的恶意设备黑名单”，登录时先查本地缓存，命中直接返回，没命中再查Redis，查到后写入本地缓存。

小贴士：

本地缓存不能设 10 分钟，因为多实例部署时，本地缓存互不同步，会导致风控失效。

设 1 分钟既能减轻 Redis 压力，又能保证安全可控。

【面试真题拆解】Spring中的注解

Wed, 18 Mar 2026 08:53:48 +0000

面试官没有直接问我“@Autowired和@Resource的区别”这种题，而是：

先让我举几个Spring注解的例子，再问“Spring注解定义为什么都挺短，不会有大量代码”，直接考察你对注解本质和Spring AOP/IOC底层的理解。

举几个Spring注解的例子

1. IOC依赖注入类注解

注解	作用	区别
@Autowired	Spring原生注解，按类型（byType）自动注入依赖	优先byType，找不到唯一Bean时，会尝试按变量名（byName）匹配；可以配合 `@Qualifier` 指定Bean名称；可以用 `required=false` 允许依赖为空
@Qualifier	配合 `@Autowired` 使用，强制按名称（byName）注入依赖	当容器中有多个同类型Bean时，必须用它指定具体用哪个
@Resource	按名称（byName）优先注入，找不到再按类型（byType）匹配	JSR-250标准，跨框架兼容性好；可以用 `name` 属性显式指定Bean名称

2. IOC组件注册类注解

注解	作用
@Component	通用组件注册注解，把任意类标记为Spring容器的Bean
@Controller	`@Component` 的子类，专门标记Web控制器层的Bean
@Service	`@Component` 的子类，专门标记业务逻辑层的Bean
@Configuration	`@Component` 的子类，专门标记Java配置类，替代XML配置文件
@Repository	@Component 的子类，专门标记数据访问层的 Bean；还能把数据库的异常（如 SQLException）转换成 Spring 的 DataAccessException（非受检异常）

3. AOP切面类注解

横切关注点就是“和业务逻辑无关，但很多地方都要用的功能”，比如日志、事务、权限校验、性能监控这些。

注解	作用
@Aspect	把类标记为切面类
@Pointcut	定义切入点表达式，告诉Spring“哪些方法需要被增强”
@Before	前置通知：在目标方法执行之前执行增强逻辑
@After	后置通知：在目标方法执行之后（不管有没有异常）执行增强逻辑
@AfterReturning	返回通知：在目标方法正常返回之后执行增强逻辑
@AfterThrowing	异常通知：在目标方法抛出异常之后执行增强逻辑
@Around	环绕通知：最强大的通知，可以完全控制目标方法的执行（比如不执行目标方法、修改参数、修改返回值）

Lombok的常用注解

Lombok是一种代码简化工具，通过注解自动生成代码。

虽然不是Spring原生注解，但Lombok的注解是Java开发中经常会用到的。

注解	作用
@Slf4j	自动生成 SLF4J日志对象
@Data	自动生成 getter/setter、toString、equals、hashCode、无参构造器
@NoArgsConstructor	自动生成无参构造器
@AllArgsConstructor	自动生成全参构造器

Spring 注解定义为什么通常都挺短，不会有大量代码？

面试官这么问主要是想考察你对注解本质和Spring容器底层的理解。

先明确一下元数据（Metadata）的定义，元数据就是“描述数据的数据”，本身不是数据的内容，只是给数据打标签、加属性。

根本原因在于注解只是元数据标记，本身不包含任何逻辑。

举个Spring注解的例子，比如 @Transactional：

// @Transactional的核心定义（简化版，去掉了很多元注解和属性）
@Target({ElementType.METHOD, ElementType.TYPE}) // 元注解：标记这个注解能用在方法/类上
@Retention(RetentionPolicy.RUNTIME) // 元注解：标记这个注解保留到运行时
@Inherited // 元注解：标记这个注解可以被子类继承
@Documented // 元注解：标记这个注解会被生成到JavaDoc里
public @interface Transactional {
    // 只有属性，没有任何方法/逻辑！
    String value() default ""; // 事务管理器的名称
    Propagation propagation() default Propagation.REQUIRED; // 传播行为
    Isolation isolation() default Isolation.DEFAULT; // 隔离级别
    int timeout() default -1; // 超时时间
    boolean readOnly() default false; // 是否只读
}

可以看到@Transactional 的定义里只有属性，没有任何一行业务逻辑或容器逻辑。

它只是告诉Spring容器：“这个方法/类需要开启事务，传播行为是REQUIRED，隔离级别是DEFAULT…”，真正开启/提交/回滚事务的逻辑，全在Spring的事务管理器和AOP切面里。

除此之外，Spring注解的定义比较短，还有一个原因是Spring大量使用了元注解（Meta-Annotation）。

那什么是元注解呢？

元注解就是“标记注解的注解”，可以复用已有注解的功能，不用重复写代码。

比如上面的 @Transactional，它上面有@Target、@Retention、@Inherited、@Documented这4个元注解。

怎么自定义一个Spring注解？

简单来说有以下3步：

定义注解

用 @interface 定义，加上JDK原生元注解（至少需要 @Target 和 @Retention(RUNTIME)）；

编写后置处理器

实现 BeanPostProcessor 或 BeanFactoryPostProcessor 接口，或者用 AOP 切面（更适合方法级别的拦截，比如权限校验、记录执行时间），处理自定义注解的逻辑；

注册后置处理器

把自定义后置处理器交给Spring容器管理（比如用 @Component 标记）。

举个例子@AuthCheck：

@Target(ElementType.METHOD)
//规定这个标签能贴在哪里,ElementType.METHOD 意思是“只能贴在方法上面”。
@Retention(RetentionPolicy.RUNTIME)
//规定这个标签的有效期,RUNTIME的意思是“程序运行的时候，这个标签依然存在”
public @interface AuthCheck {

    /**
     * @interface 不是接口（interface），而是专门用来定义注解的语法。
     * String mustRole()：表示用这个标签时，
     * 你可以写上一个角色名，比如 @AuthCheck(mustRole = "admin")。
     * default ""：如果你只写了 @AuthCheck
     * 而没填角色，那默认值就是一个空字符串 ""
     * （表示不需要特定角色，只要登录就行，具体看你怎么实现业务逻辑）。
     *
     */
    String mustRole() default "";
}

【面试真题拆解】Java文件操作的异常类型与受检_非受检异常

Tue, 17 Mar 2026 21:09:31 +0000

以往面试的时候问Java异常好像背一背题就行，但是这个面试官水平还是很高的，换了一种问法，大概是这么问的：

Java中写了一个函数，打开了一个文件，读这个文件然后关闭，中间没有写try-catch，保存之后，编辑器自动在这个函数声明后面加了throws exception，你觉得这些exception会有哪些呢？

如果把这个函数进行修改，不读写文件，只进行简单的数据处理，这时保存之后，发现函数声明的后面没有throws这些异常了，在这种情况下是不是就不会抛出异常了？

有点懵了，完犊子。。。

主要有以下几点，掌握了应该问题不大：

文件操作的异常主要是IOException及其子类，属于受检异常，必须显式处理（要么 try-catch，要么 throws）；

简单数据处理的异常多是RuntimeException 及其子类（如空指针、数组越界），属于非受检异常，无需强制 throws 或 try-catch；

受检异常要求“编译时必须处理”，非受检异常是“运行时才可能出现”，编译器不强制要求。

文件操作会抛出哪些异常？

复现一下面试题里的场景：

写一个文件读写函数，没加 try-catch，编辑器自动加了 throws Exception。

import java.io.*;

public class FileReadExample {
    // 编辑器自动加了 throws Exception，因为里面有受检异常
    public void readFile(String filePath) throws Exception {
        // 1. 打开文件流
        FileInputStream fis = new FileInputStream(filePath);
        // 2. 读取文件内容
        byte[] buffer = new byte[1024];
        int len = fis.read(buffer);
        // 3. 关闭文件流
        fis.close();
    }
}

有以下几种文件操作中常见的异常

异常类型	触发场景
FileNotFoundException	文件路径不存在、文件是目录、没有读权限
IOException	读取文件时IO错误（如磁盘损坏、网络文件系统（NFS）的连接意外中断）
EOFException	读取到文件末尾仍尝试读取

小贴士：

FileNotFoundException 是 IOException 的子类，如果 throws IOException，也能覆盖 FileNotFoundException。

为什么简单数据处理不需要 `throws`？

面试题里的第二个场景：

把函数改成只做简单数据处理，编辑器就不加 throws 了。

复现一下这个场景：

public class SimpleDataProcessExample {
    // 编辑器不会加 throws，因为里面都是非受检异常
    public void processData(int[] arr, String str) {
        // 1. 数组越界：ArrayIndexOutOfBoundsException（非受检）
        int num = arr[10];
        // 2. 空指针：NullPointerException（非受检）
        int len = str.length();
        // 3. 非法参数：IllegalArgumentException（非受检）
        if (arr.length == 0) {
            throw new IllegalArgumentException("数组不能为空");
        }
    }
}

这里的主要原因是：

简单数据处理的异常都是 RuntimeException 的子类，是非受检异常，编辑器不会强制要求 throws 或 try-catch。

受检异常 vs 非受检异常

对比维度	受检异常（Checked Exception）	非受检异常（Unchecked Exception）
定义	编译时必须处理的异常，不处理编译不通过	运行时才可能出现的异常，编译器不强制要求处理
所属类	`Exception` 及其子类（除了 `RuntimeException` 及其子类）	`RuntimeException` 及其子类、`Error` 及其子类
典型例子	`IOException`、`FileNotFoundException`	`NullPointerException`、`ArrayIndexOutOfBoundsException`、`IllegalArgumentException`
处理要求	必须 `try-catch` 或 `throws`	可以不处理，也可以处理
设计目的	提醒开发者“这里可能有外部不可控的错误，必须处理”	提醒开发者“这里有代码逻辑错误，需要修复代码”

实际开发中，文件操作的异常怎么处理？

不要直接 throws Exception，推荐显式抛出具体异常（如 throws IOException）或者 try-catch 处理，记录日志并给出友好提示。

举个例子：

public void readFile(String filePath) {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(filePath);
        byte[] buffer = new byte[1024];
        int len = fis.read(buffer);
    } catch (FileNotFoundException e) {
        System.err.println("文件不存在：" + filePath);
        e.printStackTrace();
    } catch (IOException e) {
        System.err.println("文件读取失败");
        e.printStackTrace();
    } finally {
        // 必须在 finally 里关闭流，防止内存泄漏
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

前后端分离+微服务架构下的用户认证

Tue, 17 Mar 2026 19:38:35 +0000

先明确一些核心组件：

组件	作用
前端	页面展示、用户交互、存储Token
API网关	统一入口、路由转发、Token校验
认证中心	用户登录验证、生成/刷新Token
微服务	处理业务逻辑、获取用户信息
数据库	存储用户账号密码、权限信息

当时面试官跟我说，你可以从前端打开一个页面开始讲。

那我们就举个例子：

以用户打开一个电商网站首页➡️跳转登录➡️输入账号密码登录➡️携带Token请求商品列表为例，说一下这个完整的流程。

1.前端打开页面，检查本地是否有Token

用户在浏览器输入 https://www.example.com，前端代码首先检查本地存储中是否存在有效的Token。

2.没有Token，前端跳转登录页，用户输入账号密码

如果本地没有Token，前端路由跳转到 /login 登录页，用户输入账号和密码，点击【登录】按钮。

3.前端发送登录请求到API网关

前端将账号密码封装成POST请求，发送到API网关。

需要注意的是：前端不直接请求认证中心，所有请求都走网关统一入口。

4.API网关转发登录请求到认证中心

API网关收到 /auth/login 请求，根据路由规则，将请求转发到认证中心服务。

5.认证中心验证用户信息，生成JWT Token

认证中心做以下3件事：

从数据库查询用户信息，验证账号密码是否正确；
验证通过后，生成 JWT Token（分为 Access Token 和 Refresh Token）；
将 Token 返回给前端。

那什么是JWT呢？

JWT（JSON Web Token）是一种无状态的Token，由三部分组成，用 . 分隔：

Header：头部，存算法和类型；
Payload：载荷，存用户信息（比如userId、username、过期时间）；
Signature：签名，用密钥对Header和Payload签名，防止Token被篡改。

6.前端收到Token，存储到本地

前端收到认证中心返回的 access_token 和 refresh_token，存到本地存储中。

7.前端携带Token请求业务接口

用户登录成功后，前端请求商品列表接口，在请求头 Authorization 中携带 Bearer Token。

Bearer 这个单词的意思是“持票人”、“持有者”。

Bearer Token 就是：“谁持有这个 Token，谁就是合法的访问者，服务器就认谁”。

8.API网关校验Token

API网关收到 /product/list 请求，通过全局过滤器校验Token的有效性：

从请求头 Authorization 中取出Token；
验证Token的签名是否正确；
验证Token是否过期；
校验通过后，将用户信息（比如userId）放入请求头，转发给微服务；
如果校验失败，直接返回401未授权。

9.微服务获取用户信息，处理业务逻辑

微服务（比如商品服务）收到网关转发的请求，从请求头 X-User-Id 中取出userId，处理业务逻辑（比如查询该用户的商品列表）。

10.Token过期，前端用Refresh Token刷新

Access Token有效期比较短（比如只有2小时），过期后前端请求会收到401；

此时前端不用让用户重新登录，而是用Refresh Token去认证中心刷新Access Token。

【面试真题拆解】Java锁机制：synchronized、ReentrantLock、锁升级、可重入锁

Tue, 17 Mar 2026 13:23:22 +0000

一句话速通：

Java 锁机制核心是 synchronized 和 ReentrantLock，两者都是可重入锁；

JDK 1.6+ 后 synchronized 引入锁升级（无锁➡️偏向锁➡️轻量级锁➡️重量级锁），性能大幅提升；

简单场景优先用 synchronized，需要高级功能（比如可中断、可超时、公平锁）时用 ReentrantLock。

为什么需要锁？

在并发场景下，多个线程同时修改同一个共享变量，会出现线程安全问题。

举个例子说明一下：

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这行代码不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

如果1000个线程同时调用 increment()，最终 count 的值很可能小于1000。

因为 count++ 不是原子操作，它分为读取count、count+1、写回count三步，多线程同时执行会互相覆盖。

锁的作用就是把这段代码加锁，让同一时间只有一个线程能执行，从而保证操作的原子性。

synchronized

synchronized 是JVM内置的关键字，不需要手动释放锁。

用法	锁的对象	示例
锁实例方法	锁当前对象 `this`	`public synchronized void increment()`
锁静态方法	锁当前类的 `Class` 对象	`public static synchronized void increment()`
锁代码块	锁指定的对象	`synchronized (lock) { ... }`

可以用synchronized给之前的例子上锁：

public class SafeCounter {
    private int count = 0;

    // 锁实例方法：同一时间只有一个线程能执行
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock

ReentrantLock 是 java.util.concurrent（JUC）包下的锁，是基于代码实现的锁，比 synchronized 更灵活，但需要手动释放锁。

也可以用ReentrantLock给之前的例子上锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    // 创建 ReentrantLock 实例
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 里释放锁，防止死锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock 有3个 synchronized 没有的功能：

功能	说明	示例
可中断	线程在等待锁的过程中，可以被中断，停止等待	`lock.lockInterruptibly()`
可超时	尝试获取锁，等待一段时间后如果还没拿到，就放弃	`lock.tryLock(1, TimeUnit.SECONDS)`
公平锁	按线程请求锁的顺序分配锁（先来先得），默认是非公平锁	`new ReentrantLock(true)`

可重入锁

synchronized 和 ReentrantLock 都是可重入锁。

那什么是可重入呢？

可重入的意思就是同一个线程，可以多次获取同一把锁，不会被自己阻塞。

那又为什么需要可重入呢？

举个递归调用的例子：

public class ReentrantExample {
    //  synchronized 是可重入的
    public synchronized void methodA() {
        System.out.println("执行 methodA");
        methodB(); // 调用 methodB，methodB 也需要同一把锁
    }

    public synchronized void methodB() {
        System.out.println("执行 methodB");
    }

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

如果锁是不可重入的，那么线程在执行 methodA() 时已经拿到了锁，调用 methodB() 时会因为拿不到锁而被自己阻塞，导致死锁。

synchronized 的锁升级

在 JDK 1.6 之前，synchronized 是重量级锁，性能很差；

JDK 1.6 之后，引入了锁升级机制，提升了 synchronized 的性能。

锁升级的意思是：

随着多线程竞争的加剧，锁会从【无锁】➡️【偏向锁】➡️【轻量级锁】➡️【重量级锁】逐步升级，而且升级是单向的，只能升不能降。

Java对象在内存中分为3部分：

对象头、实例数据、对齐填充，其中对象头里的 Mark Word 会记录锁的状态。

而synchronized 的锁是存放在【对象头】里的。

Mark Word 的结构（32 位 JVM）：

锁状态	25位	4位	1位（是否偏向锁）	2位（锁标志位）
无锁	对象的哈希码	分代年龄	0	01
偏向锁	偏向线程ID	分代年龄	1	01
轻量级锁	指向栈中锁记录的指针			00
重量级锁	指向重量级锁（monitor）的指针			10

锁升级的四个阶段

1. 无锁

没有线程竞争锁，对象处于无锁状态。

2. 偏向锁

只有一个线程多次获取同一把锁，没有其他线程竞争。
第一个线程获取锁时，会在对象头的 Mark Word 里记录【偏向线程ID】，这个线程以后再次获取锁时，只需要检查偏向线程ID是不是自己，如果是，直接获取锁。
当有第二个线程来竞争这把锁时，偏向锁会撤销，升级为轻量级锁。

3. 轻量级锁

多个线程交替获取锁，但是竞争不太激烈（比如线程A获取锁，执行完释放了，线程B再获取）。

线程在自己的栈帧里创建一个锁记录（Lock Record），用 CAS（Compare And Swap，比较并交换）操作，尝试把对象头的 Mark Word 替换成指向自己栈中锁记录的指针。

如果 CAS 成功，就获取到了轻量级锁。

当有多个线程同时竞争锁，CAS 失败多次，就会升级为重量级锁。

4. 重量级锁

多个线程同时竞争锁，竞争激烈。
锁升级为重量级锁后，对象头的 Mark Word 会指向一个monitor（监视器）对象。

没有获取到锁的线程会进入阻塞队列，被操作系统挂起，等待持有锁的线程释放锁后唤醒。

【面试真题拆解】Java锁机制：synchronized、ReentrantLock、锁升级、可重入锁

Tue, 17 Mar 2026 13:23:22 +0000

一句话速通：

Java 锁机制核心是 synchronized 和 ReentrantLock，两者都是可重入锁；

JDK 1.6+ 后 synchronized 引入锁升级（无锁➡️偏向锁➡️轻量级锁➡️重量级锁），性能大幅提升；

简单场景优先用 synchronized，需要高级功能（比如可中断、可超时、公平锁）时用 ReentrantLock。

为什么需要锁？

在并发场景下，多个线程同时修改同一个共享变量，会出现线程安全问题。

举个例子说明一下：

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这行代码不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

如果1000个线程同时调用 increment()，最终 count 的值很可能小于1000。

因为 count++ 不是原子操作，它分为读取count、count+1、写回count三步，多线程同时执行会互相覆盖。

锁的作用就是把这段代码加锁，让同一时间只有一个线程能执行，从而保证操作的原子性。

synchronized

synchronized 是JVM内置的关键字，不需要手动释放锁。

用法	锁的对象	示例
锁实例方法	锁当前对象 `this`	`public synchronized void increment()`
锁静态方法	锁当前类的 `Class` 对象	`public static synchronized void increment()`
锁代码块	锁指定的对象	`synchronized (lock) { ... }`

可以用synchronized给之前的例子上锁：

public class SafeCounter {
    private int count = 0;

    // 锁实例方法：同一时间只有一个线程能执行
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock

ReentrantLock 是 java.util.concurrent（JUC）包下的锁，是基于代码实现的锁，比 synchronized 更灵活，但需要手动释放锁。

也可以用ReentrantLock给之前的例子上锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    // 创建 ReentrantLock 实例
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 里释放锁，防止死锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock 有3个 synchronized 没有的功能：

功能	说明	示例
可中断	线程在等待锁的过程中，可以被中断，停止等待	`lock.lockInterruptibly()`
可超时	尝试获取锁，等待一段时间后如果还没拿到，就放弃	`lock.tryLock(1, TimeUnit.SECONDS)`
公平锁	按线程请求锁的顺序分配锁（先来先得），默认是非公平锁	`new ReentrantLock(true)`

可重入锁

synchronized 和 ReentrantLock 都是可重入锁。

那什么是可重入呢？

可重入的意思就是同一个线程，可以多次获取同一把锁，不会被自己阻塞。

那又为什么需要可重入呢？

举个递归调用的例子：

public class ReentrantExample {
    //  synchronized 是可重入的
    public synchronized void methodA() {
        System.out.println("执行 methodA");
        methodB(); // 调用 methodB，methodB 也需要同一把锁
    }

    public synchronized void methodB() {
        System.out.println("执行 methodB");
    }

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

如果锁是不可重入的，那么线程在执行 methodA() 时已经拿到了锁，调用 methodB() 时会因为拿不到锁而被自己阻塞，导致死锁。

synchronized 的锁升级

在 JDK 1.6 之前，synchronized 是重量级锁，性能很差；

JDK 1.6 之后，引入了锁升级机制，提升了 synchronized 的性能。

锁升级的意思是：

随着多线程竞争的加剧，锁会从【无锁】➡️【偏向锁】➡️【轻量级锁】➡️【重量级锁】逐步升级，而且升级是单向的，只能升不能降。

Java对象在内存中分为3部分：

对象头、实例数据、对齐填充，其中对象头里的 Mark Word 会记录锁的状态。

而synchronized 的锁是存放在【对象头】里的。

Mark Word 的结构（32 位 JVM）：

锁状态	25位	4位	1位（是否偏向锁）	2位（锁标志位）
无锁	对象的哈希码	分代年龄	0	01
偏向锁	偏向线程ID	分代年龄	1	01
轻量级锁	指向栈中锁记录的指针			00
重量级锁	指向重量级锁（monitor）的指针			10

锁升级的四个阶段

1. 无锁

没有线程竞争锁，对象处于无锁状态。

2. 偏向锁

3. 轻量级锁

多个线程交替获取锁，但是竞争不太激烈（比如线程A获取锁，执行完释放了，线程B再获取）。

如果 CAS 成功，就获取到了轻量级锁。

当有多个线程同时竞争锁，CAS 失败多次，就会升级为重量级锁。

4. 重量级锁

多个线程同时竞争锁，竞争激烈。
锁升级为重量级锁后，对象头的 Mark Word 会指向一个monitor（监视器）对象。

没有获取到锁的线程会进入阻塞队列，被操作系统挂起，等待持有锁的线程释放锁后唤醒。

【面试真题拆解】Redis的8种内存淘汰策略

Mon, 16 Mar 2026 22:54:44 +0000

Redis 内存淘汰策略共 8 种，分两大类：不淘汰和淘汰数据；

纯缓存场景优先选 allkeys-lru，混合场景选 volatile-lru，数据不能丢的话选 noeviction。

`maxmemory` 参数

只有设置了 maxmemory（Redis 最大内存限制），内存淘汰策略才会生效。

设置 `maxmemory`的两种方式

配置文件 redis.conf：

1
2

# 限制 Redis 最大使用 1GB 内存
maxmemory 1gb

命令行动态设置（重启后会失效）：

`1`	`127.0.0.1:6379> CONFIG SET maxmemory 1gb`

Redis 的8种内存淘汰策略

可以分为两大类：

大类	策略名称	含义
不淘汰数据	`noeviction`	内存满了，新写入直接报错，不淘汰任何数据
淘汰过期键	`volatile-lru`	淘汰设置了过期时间的键中，最近最少使用的
	`volatile-lfu`	淘汰设置了过期时间的键中，最不经常使用的
	`volatile-ttl`	淘汰设置了过期时间的键中，即将过期的
	`volatile-random`	随机淘汰设置了过期时间的键
淘汰所有键	`allkeys-lru`	淘汰所有键中，最近最少使用的
	`allkeys-lfu`	淘汰所有键中，最不经常使用的
	`allkeys-random`	随机淘汰所有键

1. `noeviction`

当内存满了，新写入的请求（比如 SET、LPUSH）会直接报错 (error) OOM command not allowed when used memory > 'maxmemory'，不淘汰任何数据。

适用于数据绝对不能丢，且有完善的内存监控和扩容机制（比如金融级核心数据）的场景。

2. 淘汰过期键的4种策略

这类策略只淘汰设置了 expire 过期时间的键，不会碰永久键，适合“缓存+持久化”混合的场景（比如永久键存重要数据，过期键存缓存）。

`volatile-lru`

LRU = Least Recently Used（最近最少使用）。

在设置了过期时间的键中，淘汰最久没被访问过的键。

比如缓存场景，往往会希望保留“最近刚用过的热数据”。

`volatile-lfu`

LFU = Least Frequently Used（最不经常使用）。

在设置了过期时间的键中，淘汰访问次数最少的键。

`volatile-ttl`

TTL = Time To Live（剩余生存时间）。

在设置了过期时间的键中，淘汰剩余时间最短、即将过期的键。

`volatile-random`

在设置了过期时间的键中，随机淘汰一个。

3. 淘汰所有键的3种策略

这类策略不管键有没有设置过期时间，都会淘汰，适合纯缓存场景（所有数据都是缓存，丢了也没关系，可以从数据库重新加载）。

`allkeys-lru`

在所有键中，淘汰最近最少使用的键。

比较适合电商商品缓存、用户Session缓存这些纯缓存场景。

`allkeys-lfu`

在所有键中，淘汰访问次数最少的键。

`allkeys-random`

在所有键中，随机淘汰一个。

LRU vs LFU，到底有啥区别？

对比维度	LRU（最近最少使用）	LFU（最不经常使用）
核心依据	看最近多久没被访问	看访问次数多少
优点	实现简单，符合“热数据最近常用”的直觉	更精准，能识别“真正的热数据”（比如某个键虽然最近没被访问，但总访问次数极高）
缺点	可能误删“偶尔访问一次的冷数据，但其实总访问次数很高”	实现复杂，需要额外空间记录访问次数

举个例子

假设键A昨天被访问100次，今天没被访问；

键B今天被访问1次。

因为最近没被访问，所以LRU会删键A。

但是，因为总访问次数只有1次，所以LFU会删键B。

【手撕真题】合并区间

Mon, 16 Mar 2026 17:02:46 +0000

题目意思很好理解：

给定一个区间集合，每个区间由 [start, end] 组成，要求合并所有重叠的区间，返回一个不重叠的区间数组，且这个数组要恰好覆盖输入中的所有区间。

思路

首先，先按每个区间的起始值从小到大排序，这样重叠的区间就会挨在一起，方便后续合并；

然后初始化一个结果列表，把排序后的第一个区间放进去，作为初始的待合并区间；

接着遍历剩下的所有区间，每次取出结果列表的最后一个区间和当前区间比较：

如果当前区间的起始值小于等于最后一个区间的结束值，说明两个区间重叠，就把最后一个区间的结束值更新为两者的最大值，完成合并；

如果不重叠，就直接把当前区间加入结果列表；

最后把结果列表转换成二维数组返回即可。

代码实现

    public int[][] merge(int[][] intervals) {
        // 区间个数为0或1，直接返回
        if (intervals.length <= 1) {
            return intervals;
        }

        // 1. 按区间的start值从小到大排序
        // a[0]-b[0]表示按start升序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

        // 2. 初始化结果列表，存储合并后的区间
        List<int[]> res = new ArrayList<>();
        // 先将排序后的第一个区间加入结果列表，作为初始合并区间
        res.add(intervals[0]);

        // 3. 遍历剩下的所有区间，逐个合并
        for (int i = 1; i < intervals.length; i++) {
            // 取出结果列表中最后一个区间
            int[] last = res.get(res.size() - 1);
            // 取出当前遍历的区间
            int[] curr = intervals[i];

            // 判断是否重叠：当前区间的start <= 最后一个区间的end
            if (curr[0] <= last[1]) {
                // 重叠：合并区间，更新最后一个区间的end为两者最大值
                last[1] = Math.max(last[1], curr[1]);
            } else {
                // 不重叠：直接将当前区间加入结果列表
                res.add(curr);
            }
        }

        // 4. 将List<int[]>转换为int[][]
        return res.toArray(new int[res.size()][]);
    }

MySQL的三层B+树能存多少数据？

Mon, 16 Mar 2026 13:09:19 +0000

InnoDB读写磁盘的最小单位是页（Page），默认大小16KB。
而MySQL的主键索引B+树，每一个树节点（不管是根节点、中间节点、叶子节点），本质上就是一个16KB的页。
所有计算，都是围绕【1个16KB的页，能存多少东西】展开的。

节点类型	存的内容	特点
非叶子节点（根节点、中间层节点）	只存主键值 + 指向下一层页的指针	不存完整用户数据，体积极小，一个页能存上千个
叶子节点（最底层节点）	存用户的完整一行行数据	存真实业务数据，体积大，一个页能存的行数有限

1.先算1个非叶子节点，能存多少个索引项

非叶子节点存的是「主键值 + 指针」，我们先算单个索引项的大小：

主键大小：假设主键是bigint类型，MySQL里bigint固定占8字节；
指针大小：InnoDB里指向页的指针，固定占6字节；
单个索引项总大小：8字节（主键） + 6字节（指针） = 14字节。

一个页是16KB，换算成字节是 16 × 1024 = 16384字节。
所以一个非叶子页能存的索引项数量：
16384 ÷ 14 ≈ 1170个

2.再算1个叶子节点，能存多少行数据

叶子节点存的是用户的完整一行行数据，假设一行业务数据占1KB（比如一张表有id、name、age、create_time等字段，加起来差不多1KB）。

一个页是16KB，所以一个叶子页能存的行数：
16KB ÷ 1KB/行 = 16行

3.最后算三层B+树的总数据量

顺着三层结构，从根节点往下算：

第一层（根节点）：1个非叶子页，能存1170个索引项 → 能指向1170个第二层的页；
第二层（中间非叶子节点）：1170个非叶子页，每个页又能存1170个索引项 → 能指向 1170 × 1170 = 1368900 个第三层的叶子页；
第三层（叶子节点）：每个叶子页能存16行数据。

最终总数据量 = 叶子页总数 × 每个叶子页的行数：
1170 × 1170 × 16 ≈ 2190万条

所以，三层B+树大约能存2000万条记录。

【面试真题拆解】Java字节流、字符流

Mon, 16 Mar 2026 10:00:59 +0000

Java IO流的分类

Java IO流主要从两个维度分类：

分类维度	分类结果	说明
按数据流向分	输入流（Input）	从磁盘/网络/内存「读」数据到程序
	输出流（Output）	从程序「写」数据到磁盘/网络/内存
按处理单元分	字节流（Byte Stream）	以「字节（byte）」为单位处理数据，是万能流
	字符流（Character Stream）	以「字符（char）」为单位处理数据，专门处理文本

字节流

什么是字节流？

计算机里所有数据（图片、视频、音频、文本、PDF）本质上都是字节（0和1的组合），所以字节流是万能流，可以处理任何类型的数据。

字节流的核心类

字节流的抽象基类是 InputStream（输入流）和 OutputStream（输出流），开发中最常用的是它们的子类：

类名	作用
`FileInputStream`	从文件中读取字节
`FileOutputStream`	向文件中写入字节
`BufferedInputStream`	带缓冲的字节输入流，提升读性能
`BufferedOutputStream`	带缓冲的字节输出流，提升写性能

举个例子

字节流典型的应用——复制非文本文件（图片、视频、PDF）

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        // 源文件路径（一张图片）
        String srcPath = "C:/test/photo.jpg";
        // 目标文件路径
        String destPath = "C:/test/photo_copy.jpg";

        // 用try-with-resources自动关闭流，避免内存泄漏
        try (
            // 1. 创建文件字节输入流：从源文件读字节
            FileInputStream fis = new FileInputStream(srcPath);
            // 2. 创建文件字节输出流：向目标文件写字节
            FileOutputStream fos = new FileOutputStream(destPath)
        ) {
            // 3. 定义一个字节数组作为缓冲区（一次读1024字节，即1KB，提升性能）
            byte[] buffer = new byte[1024];
            int len; // 记录每次实际读到的字节数

            // 4. 循环读写：fis.read(buffer)返回-1表示读到文件末尾
            while ((len = fis.read(buffer)) != -1) {
                // 只写实际读到的len个字节，避免最后一次写多余的空字节
                fos.write(buffer, 0, len);
            }
            System.out.println("图片复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

什么是字符流？

字符流是专门处理文本数据的流，它以【字符】为单位处理数据，内部会自动处理编码转换（比如把UTF-8编码的字节转成Java的char字符）。

为什么不用字节流处理文本？

因为中文等非ASCII字符占多个字节（比如UTF-8编码的中文占3个字节）。

如果用字节流读，可能会把一个汉字的3个字节截断，从而导致乱码；

而字符流会自动识别编码，按字符读取，不会乱码。

字符流的核心类

字符流的抽象基类是 Reader（输入流）和 Writer（输出流），开发中最常用的是它们的子类：

类名	作用
`FileReader`	从文件中读取字符
`FileWriter`	向文件中写入字符
`BufferedReader`	带缓冲的字符输入流
`BufferedWriter`	带缓冲的字符输出流
`InputStreamReader`	转换流：字节流转字符流
`OutputStreamWriter`	转换流：字符流转字节流

举个例子

BufferedReader的readLine()方法可以按行读取文本，非常方便。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class CharacterStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/test/中文文章.txt";

        // 用转换流InputStreamReader，显式指定UTF-8编码，避免乱码
        try (
            // 1. 先创建字节输入流
            FileInputStream fis = new FileInputStream(filePath);
            // 2. 用转换流把字节流转成字符流，显式指定UTF-8编码
            InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
            // 3. 用缓冲流包装，提升性能，且有readLine()方法
            BufferedReader br = new BufferedReader(isr)
        ) {
            String line;
            int lineNum = 1;
            // readLine()返回null表示读到文件末尾
            while ((line = br.readLine()) != null) {
                System.out.println("第" + lineNum + "行：" + line);
                lineNum++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

【面试真题拆解】Java类加载过程+双亲委派机制

Sun, 15 Mar 2026 22:44:04 +0000

什么是类加载？

简单来说，类加载就是把.class文件（编译后的字节码）从磁盘/网络加载到JVM内存里，并生成对应的Class对象的过程。

Java类加载的5个核心阶段

类加载不是一步到位的，而是分成了5个阶段： 加载➡️验证➡️准备➡️解析➡️初始化，其中加载、验证、准备、初始化的顺序是固定的，解析可能在初始化之后（为了支持动态绑定）。

1. 加载（Loading）

这是类加载的第一步，举个例子：假如你要加载User类，JVM会先找到User.class文件，把它的信息存到方法区，然后在堆里生成一个Class对象，以后你要访问User类的信息，都通过这个Class对象。

2. 验证（Verification）

这一步是为了保证JVM的安全，防止恶意或不规范的.class文件搞破坏，主要验证四个方面：

文件格式验证：检查.class文件的魔数（开头的CAFEBABE）、版本号（JDK版本兼容）等；
元数据验证：检查类的继承关系（比如不能继承final类）、方法重写是否合法等；
字节码验证：检查字节码指令是否安全（比如不会跳转到非法指令、不会访问越界的数组）；
符号引用验证：检查符号引用（比如类名、方法名）是否能找到对应的类/方法。

3. 准备（Preparation）

这一步是在方法区里为类的静态变量（static修饰的变量）分配内存，并设置初始默认值。

需要注意的是：不是代码里写的初始值，而是以下这些初始值：

数据类型	默认值
int	0
long	0L
float	0.0f
double	0.0d
boolean	false
引用类型	null

4. 解析（Resolution）

这一步是把常量池里的符号引用（比如类名com.example.User、方法名getUser），转换成直接引用（比如内存地址、指针）。

解析的话，主要针对的是类、接口、字段、方法等符号引用。

举个通俗一点的例子：

符号引用就是一个“代号”，比如你用“张三”指代一个人，不管他在哪，“张三”这个代号都能用；

而直接引用就是“具体的地址”，比如张三现在在“XX小区XX号楼XX室”，你可以直接找到他。

5. 初始化（Initialization）

这是类加载的最后一步，也是真正执行程序员写的代码的阶段。

这一步只做一件事：执行类构造器<clinit>()方法。

<clinit>()方法是编译器自动生成的，它会把类里的静态变量赋值语句和静态代码块（static {}）按顺序合并起来执行。

举个例子

public class User {
    static int num = 10; // 静态变量赋值
    static { // 静态代码块
        num = 20;
        System.out.println("静态代码块执行");
    }
}

以上代码在初始化阶段，JVM会执行<clinit>()方法：

先把num设为10，再设为20，然后打印“静态代码块执行”。

什么时候会触发类的初始化？

有以下6种情况：

创建类的实例（new User()）；
访问类的静态变量或静态方法（User.num、User.getUser()）；
用Class.forName("com.example.User")反射加载类；
初始化子类时，会先初始化父类；
JVM启动时，会先初始化包含main()方法的主类；
JDK 7+的动态语言支持，MethodHandle解析结果为REF_getStatic/REF_putStatic/REF_invokeStatic的句柄，且对应的类未初始化。

双亲委派机制（Parent Delegation Model）

什么是类加载器？

类加载器（ClassLoader）就是负责加载类的工具，JVM内置了三种类加载器：

启动类加载器（Bootstrap ClassLoader）

用C++写的，不是ClassLoader的子类，开发者无法直接获取它的引用。

负责加载JDK核心类库（比如java.lang.Object、java.lang.String），这些类在jre/lib/rt.jar里。

扩展类加载器（Extension ClassLoader）

是ClassLoader的子类，开发者可以获取它的引用，负责加载JDK扩展类库（比如jre/lib/ext目录下的类）。

应用程序类加载器（Application ClassLoader）

是ClassLoader的子类，也是默认的类加载器。负责加载用户自己写的类（比如com.example.User），也就是classpath下的类。

什么是双亲委派机制？

这里的“双亲”不是指“父母”，而是指“父类加载器”，是翻译的问题，理解成“父委派机制”更准确一点。

双亲委派机制的核心规则是：“向上委托，向下加载”

当一个类加载器收到加载类的请求时，它不会自己先加载，而是把请求委托给父类加载器去加载；
如果父类加载器能加载这个类，就由父类加载器加载；
如果父类加载器加载不了（比如在它的加载范围内找不到这个类），才会向下交给子类加载器自己加载。

举个例子

比如说：加载java.lang.Object

应用程序类加载器收到加载Object的请求，它不自己加载，委托给扩展类加载器；
扩展类加载器也不自己加载，委托给启动类加载器；
启动类加载器在rt.jar里找到了Object类，直接加载它；
加载完成，返回Class对象，不会再向下交给子类加载器。

为什么需要双亲委派机制？

双亲委派机制的目的是保证Java程序的安全性和稳定性，主要解决了两个问题：

避免类的重复加载

如果没有双亲委派，用户自己写一个java.lang.Object类，应用程序类加载器就会加载它，导致JVM里有两个Object类，程序就乱了。

保证核心类库的安全

防止用户恶意篡改核心类库（比如写一个恶意的java.lang.String类），因为核心类库只会由启动类加载器加载，用户写的同名类不会被加载。

破坏双亲委派机制的情况

常见的破坏双亲委派机制的场景：

JDBC的DriverManager

JDBC需要加载不同数据库的驱动（比如MySQL驱动），但驱动类是用户写的，启动类加载器加载不了，所以DriverManager用了线程上下文类加载器（Thread Context ClassLoader），打破了双亲委派，让启动类加载器能委托应用程序类加载器加载驱动。

Tomcat的类加载器

Tomcat需要隔离不同Web应用的类（比如两个应用都用了不同版本的Spring），所以它有自己的类加载器结构，每个Web应用有独立的类加载器，优先加载自己的类，而不是向上委托。

【面试真题】能讲讲MySQL的锁机制吗

Sun, 15 Mar 2026 16:44:46 +0000

MySQL的锁按两个维度分，刚好对应开发中最常遇到的问题：

按解决并发冲突的思路分，是悲观锁和乐观锁——这俩决定了“你是先占坑再干活，还是先干活最后再检查”；

按锁的范围大小分，是表锁、行锁，还有 InnoDB 特有的间隙锁 + 临键锁 —— 这三类锁决定了 “你是锁整个仓库（表锁）、只锁你要的那一件商品（行锁），还是锁仓库里的某个货架区间（间隙锁 + 临键锁）”。

先建一张最简单的电商商品表 product，插几条测试数据，等会更好理解举的例子：

CREATE TABLE `product` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `name` varchar(100) NOT NULL COMMENT '商品名称',
  `stock` int(11) NOT NULL DEFAULT '0' COMMENT '库存',
  `version` int(11) NOT NULL DEFAULT '0' COMMENT '乐观锁版本号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品表';

-- 插入测试数据：id=1是iPhone，库存100；id=3是华为，库存200；id=5是小米，库存150
INSERT INTO `product` (`id`, `name`, `stock`, `version`) VALUES
(1, 'iPhone 17', 100, 0),
(3, 'Mate 70', 200, 0),
(5, 'Xiaomi 15', 150, 0);

悲观锁

举个电商秒杀扣库存的真实例子，也是悲观锁最典型的应用：

比如有两个用户同时秒杀iPhone 17，库存100。

如果不用锁，俩人同时查出来库存100，都扣减1，就超卖了。
用悲观锁的话，就是在查库存的时候用 SELECT ... FOR UPDATE 显式加排他锁——

第一个用户的事务先把这行数据锁住，第二个用户的查询就会阻塞，等第一个用户扣减完库存、提交事务释放锁，第二个用户才能拿到最新的库存，这样就保证了不超卖。

乐观锁

这也是开发中很常见的场景：两个运营同时修改同一件商品的标题。

这种场景并发冲突概率很低（因为很少会有两个人同时改同一个商品的标题），如果用悲观锁，每次修改都要加锁，太影响性能了，所以用乐观锁更合适。

乐观锁的意思就是：我假设没人跟我抢，所以我先直接修改，最后提交的时候再检查一下：

在我修改的这段时间里，有没有别人也改过这条数据？

如果没有，就修改成功；

如果有，就提示用户“数据已被修改，请刷新后重试”。

举个具体的SQL操作实例

我们打开两个命令行窗口，分表代表两个会话。

1.会话A（运营A先查商品）

1
2

-- 1. 运营A查出来iPhone的信息，此时 version = 0
SELECT * FROM product WHERE id = 1;

2.会话B（运营B同时查商品）

1
2

-- 1. 运营B也查出来iPhone的信息，此时 version 也是 0
SELECT * FROM product WHERE id = 1;

3.会话A（运营A先提交修改）

-- 1. 运营A把标题改成“iPhone 17 Pro Max”，WHERE条件带上 version = 0
UPDATE product 
SET name = 'iPhone 17 Pro Max', version = version + 1 
WHERE id = 1 AND version = 0;
-- 现象：返回更新行数为 1，修改成功！此时数据库里的 version 变成了 1

4.会话B（运营B后提交修改）

-- 1. 运营B把标题改成“iPhone 17 特价版”，WHERE条件也带上 version = 0
UPDATE product 
SET name = 'iPhone 17 特价版', version = version + 1 
WHERE id = 1 AND version = 0;
-- 现象：返回更新行数为 0，修改失败！
-- 因为数据库里的 version 已经变成 1 了，找不到 id=1 AND version=0 的行
-- 此时业务代码就可以提示用户：“商品已被其他运营修改，请刷新页面后重试”

表锁

直接锁整张表，其他会话对这张表的任何读写（不管是查哪一行、改哪一行）都会被阻塞。

举个例子

-- 会话A：给全表商品库存+10，显式加表锁
LOCK TABLES product WRITE;
UPDATE product SET stock = stock + 10;

-- 此时会话B想查id=1的商品，会直接阻塞！
SELECT * FROM product WHERE id = 1;

-- 会话A提交事务并释放表锁后，会话B才能执行
UNLOCK TABLES;

表锁的优点是加锁开销小、速度快，不会死锁，但缺点就是并发度极低，一锁全表，电商场景下用它会直接让网站卡死。

行锁

只锁具体的某一行数据，其他行完全不受影响，是InnoDB支持高并发的核心。

需要注意的是行锁的前提是【走索引】。

如果你的查询没走索引，InnoDB会退化成表锁。

举两个例子对比一下

先看走索引的情况（行锁生效）：

-- 会话A：用主键id=1查，加排他锁（走主键索引，只锁id=1这行）
BEGIN;
SELECT * FROM product WHERE id = 1 FOR UPDATE;

-- 会话B：查id=3的商品，完全不阻塞！直接拿到锁
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 执行成功

-- 会话B：查id=1的商品，会阻塞！需要等会话A释放锁
SELECT * FROM product WHERE id = 1 FOR UPDATE; -- 阻塞

再看没走索引的情况（退化成表锁）：

-- 先确认name字段没加索引（前面建表的时候只给id加了主键）
-- 会话A：用name='iPhone 17'查，加排他锁（没走索引，锁全表！）
BEGIN;
SELECT * FROM product WHERE name = 'iPhone 17' FOR UPDATE;

-- 会话B：查id=3的商品，居然也阻塞了！因为锁了全表
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 阻塞

行锁的优点是并发度极高，只锁需要的行，不影响其他操作；但缺点是加锁开销大、速度慢，可能产生死锁。

间隙锁+临键锁

这俩是InnoDB特有的，专门用来解决【幻读】问题的。

先举个电商场景的例子说明一下什么是幻读？

-- 会话A：查id>1的所有商品（此时表里只有id=1、3、5）
BEGIN;
SELECT * FROM product WHERE id > 1 FOR UPDATE; -- 第一次查：查到id=3、5两条

-- 会话B：插了一条id=2的商品，提交事务
INSERT INTO product (id, name, stock, version) VALUES (2, 'OPPO Find X8', 100, 0);
COMMIT;

-- 会话A：再查id>1的商品，居然查到了id=2、3、5三条！
SELECT * FROM product WHERE id > 1 FOR UPDATE; -- 第二次查：多了一条，像产生了幻觉

这就是幻读：同一个事务里，两次相同的范围查询，结果却是不一样的。

间隙锁（Gap Lock）

间隙锁，间隙锁，顾名思义，它不锁具体的行，锁的是两个索引值之间的“间隙”，也就是只锁两个相邻索引值之间的空白区间，以防止别人在这个区间里插数据。

以刚开始建的那个product表为例：

id=1、3、5，间隙就是：(-∞,1)、(1,3)、(3,5)、(5,+∞)。

临键锁（Next-Key Lock）

临键锁其实是【行锁】+【间隙锁】的组合，锁的是左开右闭的区间。

比如(1,3]（锁id=3这一行，同时锁1到3之间的间隙）。

还是以刚开始建的那个product表为例，临键区间就是：(-∞,1]、(1,3]、(3,5]、(5,+∞)。

举个例子

-- 会话A：用id=3查，加排他锁（走主键索引，加临键锁(1,3]）
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE;

-- 会话B：想插id=2的商品，直接阻塞！因为间隙(1,3)被锁了
INSERT INTO product (id, name, stock, version) VALUES (2, 'OPPO Find X8', 100, 0); -- 阻塞

-- 会话B：想插id=6的商品，不阻塞！因为(5,+∞)没被锁
INSERT INTO product (id, name, stock, version) VALUES (6, 'Vivo X200', 100, 0); -- 执行成功

小贴士

间隙锁 + 临键锁只在 InnoDB 的默认隔离级别【可重复读（RR）】下生效。

如果是【读提交（RC）】隔离级别，会关闭间隙锁，只保留行锁。

夺命连环问：什么是死锁？又怎么避免呢？

两个或多个会话，互相持有对方需要的锁，都在等待对方释放，导致谁都执行不下去，形成“死循环”，这就是死锁。

举个例子

-- 会话A：先锁id=1，再想锁id=3
BEGIN;
SELECT * FROM product WHERE id = 1 FOR UPDATE; -- 持有id=1的锁
-- 此时会话A想拿id=3的锁，但被会话B持有了，阻塞
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 阻塞

-- 会话B：先锁id=3，再想锁id=1
BEGIN;
SELECT * FROM product WHERE id = 3 FOR UPDATE; -- 持有id=3的锁
-- 此时会话B想拿id=1的锁，但被会话A持有了，阻塞
SELECT * FROM product WHERE id = 1 FOR UPDATE; -- 阻塞

-- 结果：死锁！

死锁的四个必要条件

只要破坏其中任意一个，就能避免死锁：

互斥条件：一个锁只能被一个会话持有（行锁就是这样，没法破坏）；
请求与保持条件：持有一个锁的同时，又请求另一个锁；
不剥夺条件：锁只能由持有者主动释放，不能被别人强行抢走；
循环等待条件：会话之间形成循环等待链（A等B，B等A）。

怎么避免死锁？

① 按固定顺序加锁

所有会话都按相同的顺序加锁，比如都先锁id小的，再锁id大的，这样就不会形成循环等待。

② 减少锁的范围和持有时间

尽量用行锁不用表锁；

事务尽量小，不要在事务里做无关操作（比如不要在事务里调第三方接口、查无关表），锁持有时间越短，死锁概率越低。

③ 避免大事务

大事务持有锁的时间长，涉及的行多，更容易死锁，把大事务拆成多个小事务。

小贴士

InnoDB 有自动死锁检测机制，它会实时扫描锁等待链，一旦发现死锁，会自动回滚其中一个，一般是代价较小的那个事务，比如更新行数少的那个，让另一个事务继续执行，不会让系统无限期卡死。

TCP的核心参数-MTU、MSS、RTT、RTO、cwnd、ssthresh

Sun, 15 Mar 2026 11:36:23 +0000

MTU和MSS，管【单个TCP包到底发多大最合适】，是整个传输的基础；

RTT和RTO，管【包发出去之后，怎么保证对方一定收到，丢包了怎么办】，是TCP可靠传输的核心；

cwnd和ssthresh，管【一次能连续发多少个包，怎么既跑满带宽，又不把网络堵死】，是TCP拥塞控制的核心。

MTU & MSS

MTU（最大传输单元，Maximum Transmission Unit）

平时用的以太网、WiFi，硬件层面就规定了一个完整的IP数据包，最大不能超过1500字节，这个上限就是MTU。
如果IP包超过MTU，就会被拆成好几个小分片传输，只要有一个分片丢了，整个包就得全量重传，特别影响效率，还可能被防火墙拦截。

MSS（最大报文段长度，Maximum Segment Size）

这是基于MTU算出来的、TCP包里真正能装的业务数据的最大长度——要把IP头、TCP头的空间提前扣掉。
以太网默认MTU1500字节，标准IP头和TCP头各占20字节，所以默认MSS就是1460字节。

它是TCP三次握手的时候，客户端和服务端协商出来的，最终取两边的最小值，目的就是从源头避免IP拆包。

RTT & RTO

RTT（往返时延，Round-Trip Time）

我发一个TCP包出去，到我收到对方回的【我收到了】的ACK确认包，这一来一回花的时间，就是RTT。
它是网络环境决定的客观值，网络越拥堵、跨的路由越多，RTT就越长，会实时波动，是算RTO的唯一基础。

RTO（重传超时时间，Retransmission TimeOut）

我发出去一个包，会设一个定时器，要是超过这个时间还没收到ACK，我就认为这个包丢了，马上重发一个，这个定时器的时间就是RTO。
RTO完全是基于RTT算出来的，不是固定死的。

它必须比RTT大一点。

如果太小了，ACK还在路上就瞎重传，浪费带宽；

但太大了，真丢包了半天不重传，传输变慢。

所以，网络波动RTT变了，RTO也会跟着实时调整。

cwnd & ssthresh

这两个参数是TCP拥塞控制的核心，TCP刚建连的时候，根本不知道当前网络能扛住多大流量，发少了浪费带宽，发多了直接把网络堵死，所以用这两个参数控制发送节奏。

cwnd（拥塞窗口，Congestion Window）

TCP发送端自己维护的【油门】，单位是MSS。这个参数决定了在没收到对方ACK之前，我最多能连续发多少个包。

比如cwnd=10，就是最多连续发10个MSS大小的包，不用等ACK。
需注意的是，cwnd不是固定的，网络越好、丢包越少，cwnd就越大，发送速度就越快；一旦丢包，就会马上降下来。

ssthresh（慢启动阈值，Slow Start Threshold）

cwnd的【换挡开关】，用来划分两个发送阶段，单位也是MSS。
当cwnd ＜ ssthresh时，进入慢启动阶段，cwnd每过一个RTT就直接翻倍，指数级快速涨速，尽快把带宽跑满；

当cwnd ≥ ssthresh时，进入拥塞避免阶段，cwnd每过一个RTT才加1，线性慢慢涨，避免冲太猛把网络堵死。
一旦检测到网络拥堵丢包，ssthresh会立刻降到当前cwnd的一半，再根据丢包的严重程度调整cwnd，重新控制发送节奏。

【面试真题】讲讲JVM的垃圾回收机制？

Sat, 14 Mar 2026 19:26:46 +0000

为什么需要垃圾回收？

首先得说清楚，JVM的垃圾回收（GC）到底是干嘛的。

其实就像租房子住，时间长了会产生垃圾，要是不打扫，房子就没法住了。

在Java里，我们写代码会创建很多对象（比如new Person()、new ArrayList()），这些对象都存在堆内存里。

但是，堆内存是有限的，要是对象用完了不清理，内存就会被占满，最后报OutOfMemoryError（OOM），程序就挂了。

所以GC的作用就是：自动找到堆里那些“没人用的垃圾对象”，把它们清理掉，腾出内存空间。

堆内存划分

JVM把堆分成了新生代和老年代两大块：

新生代：刚创建的对象优先放在这里。就像“幼儿园”，大部分对象“朝生夕死”（比如方法里的临时变量，方法执行完就没用了）。
老年代：在新生代里“熬过好几次GC”的对象，会被放到这里。就像“养老院”，这里的对象大多活得比较久（比如Spring容器里的单例Bean）。

那为什么要这么划分呢？

主要还是因为不同生命周期的对象，用不同的回收算法，效率会更高一点。

各代用什么垃圾回收算法？

我当时面试的时候突然懵了，说的不知道，裂开。。。

对新生代来说，它的特点是：垃圾多，存活对象少（比如100个对象里，可能只有2个活着）。

采用的是复制算法。

JVM把新生代分成三块：

1个Eden区（占80%）和2个Survivor区（From和To，各占10%）。

平时只用Eden区和其中一个Survivor区（比如From）。

新对象先在Eden区分配，当Eden区满了，触发Minor GC（新生代GC），把Eden和From区里活着的对象，复制到To区，然后直接清空Eden和From区，From和To交换角色（下次用Eden和新的From区）。

对老年代来说，它的特点是：存活对象多，垃圾少，而且没有额外的大空间做复制担保，所以不用复制算法，采用的是**标记-清除 **或 标记-整理算法。

标记-清除算法（Mark-Sweep）

这种算法的实现逻辑是，从“GC Roots”（比如主线程、静态变量这些“根”）出发，找到所有活着的对象，做上标记，然后遍历堆内存，把没标记的对象（垃圾）清理掉。

优点是实现简单，但是会产生内存碎片（比如清理后剩下很多小空间，大对象可能放不下）。

标记-整理算法（Mark-Compact）

为了解决内存碎片问题，在“标记-清除”基础上加了个“整理”步骤。

实现逻辑和标记清除算法一样，先标记存活对象，把所有存活对象往内存的一端移动，按顺序排好，最后，直接清空边界以外的内存。

这种算法的优点是没有内存碎片，但缺点是需要移动对象，效率比“标记-清除”低。

常见的垃圾回收器

Serial：单线程回收，适合客户端应用（比如桌面软件）；
ParNew：Serial的多线程版，常和CMS配合用；
CMS（Concurrent Mark Sweep）：主打低延迟（垃圾回收时尽量不让程序停顿太久），适合互联网应用（比如电商后台），用的是“标记-清除”算法；
G1（Garbage-First）：把堆分成很多小区域，优先回收垃圾多的区域，平衡了吞吐量和延迟。

【面试真题】Java中什么是反射

Sat, 14 Mar 2026 12:16:58 +0000

首先，官方的定义是这样的：

Java反射（Reflection）是指在程序运行时，动态获取类的完整结构信息（如构造方法、字段、方法），并能直接操作对象的属性或方法的机制。

正射 vs 反射

用【创建对象并调用方法】举个例子：

正射

就是我们平时写代码的方式，编译期就知道要操作的类是什么，直接 new 对象调用方法：

1
2
3

// 正射：编译期就确定是User类
User user = new User();
user.setName("张三"); // 直接调用方法

反射

动态的方式**，编译期**不知道要操作的类是什么，运行期才通过类名字符串动态获取类信息并操作：

// 反射：运行期才通过字符串"com.example.User"获取类
Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance(); // 动态创建对象
Method setNameMethod = clazz.getDeclaredMethod("setName", String.class);
setNameMethod.invoke(user, "张三"); // 动态调用方法

原理

反射的底层，其实是操作JVM加载类后生成的 Class对象。

先回顾一下类的加载过程：

编译期：.java文件被编译成 .class字节码文件；
类加载期：JVM的类加载器（ClassLoader）把 .class文件加载到内存，生成一个 java.lang.Class对象（这个对象包含了类的所有结构信息）；
运行期：反射就是通过这个 Class对象，逆向获取类的构造方法、字段、方法等信息，并进行操作。

说人话就是：Class对象是反射的入口，所有反射操作都从获取Class对象开始。

手撕一下，加深理解

1. 获取Class对象的3种方式

// 方式1：类名.class（最常用，编译期就能获取）
Class<User> clazz1 = User.class;

// 方式2：对象.getClass()（已有对象时用）
User user = new User();
Class<? extends User> clazz2 = user.getClass();

// 方式3：Class.forName("全类名")（最灵活，框架常用）
Class<?> clazz3 = Class.forName("com.example.User");

2. 操作构造方法：动态创建对象

Class<?> clazz = Class.forName("com.example.User");

// 获取无参构造方法并创建对象
Constructor<?> noArgConstructor = clazz.getDeclaredConstructor();
Object user1 = noArgConstructor.newInstance();

// 获取有参构造方法并创建对象
Constructor<?> argConstructor = clazz.getDeclaredConstructor(String.class, int.class);
Object user2 = argConstructor.newInstance("张三", 25);

3. 操作字段：动态获取/设置属性

Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance();

// 获取public字段并赋值
Field nameField = clazz.getField("name");
nameField.set(user, "张三");

// 获取private字段并赋值（需打破封装）
Field ageField = clazz.getDeclaredField("age");
ageField.setAccessible(true); // 关键：打破private访问限制
ageField.set(user, 25);

4. 操作方法：动态调用方法

Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance();

// 获取public方法并调用
Method setNameMethod = clazz.getMethod("setName", String.class);
setNameMethod.invoke(user, "张三");

// 获取private方法并调用（需打破封装）
Method getAgeMethod = clazz.getDeclaredMethod("getAge");
getAgeMethod.setAccessible(true);
int age = (int) getAgeMethod.invoke(user);

实际应用场景

Java生态里的核心框架几乎都用到了反射，比如：

1. Spring框架的IOC/DI

Spring的IOC容器就是通过反射创建对象并注入依赖的：

在XML里写 <bean id="user" class="com.example.User"/>➡️Spring读取XML，拿到全类名 com.example.User➡️Spring通过 Class.forName() 获取Class对象，动态创建Bean对象➡️如果Bean有依赖（比如 userService 依赖 userDao），Spring再通过反射注入依赖。

2. JDBC加载数据库驱动

Class.forName("com.mysql.cj.jdbc.Driver")，底层就是反射：首先加载驱动类到JVM，接下来驱动类的静态代码块会自动执行，把驱动注册到 DriverManager 里。

3. 注解处理

比如JUnit的 @Test 注解：JUnit启动后，通过反射扫描所有类，找到带 @Test 注解的方法，再通过反射动态调用这些方法执行测试。

反射的优缺点

优点

灵活性高：运行期才确定要操作的类，不需要在编译期写死；
动态性强：适合开发通用框架（如Spring、MyBatis），框架不需要知道用户会写什么类，通过反射就能动态适配。

缺点

性能低：反射比直接调用方法慢10-100倍（因为需要动态解析类信息），所以高频调用的场景（比如循环里）尽量不用反射；
破坏封装性：可以通过 setAccessible(true) 访问private字段/方法，破坏了Java的封装原则；
安全性问题：反射可以执行任意代码，可能被恶意利用。

【面试真题】缓存和数据库的一致性问题如何保证？

Fri, 13 Mar 2026 14:14:10 +0000

坦白说，这个问题本质上不是个纯技术方案题，而是高并发场景下，平衡【性能、可用性、一致性强度】的工程题。

核心是先看业务的一致性容忍度，再选对应方案，而且必须做好异常兜底，不然线上一定会出永久脏数据。

在电商场景中，绝大多数情况下优先保证最终一致性，只有金融级核心链路才会考虑强一致性。

先说标准流程：

读请求：先查缓存，命中直接返回；没命中就读数据库，把结果写回缓存再返回。
写请求：先更新数据库，再删除缓存。

为什么是【删除缓存】，而不是【更新缓存】？

一是并发写场景下，更新缓存一定会有数据覆盖的风险；

二是电商场景很多缓存值是多表关联算出来的，更新缓存的成本极高，不如删除后懒加载；

三是写多读少的场景，频繁更新缓存全是无效操作，浪费性能。

为什么是【先更库，再删缓存】，不能反过来？

如果你刚把缓存删了，数据库还没更新完，这时候高并发的读请求进来，缓存查不到，直接去数据库拉了旧数据，还写回了缓存。

等你数据库更新完，缓存里的旧数据就一直躺在那，除非缓存过期，不然用户一直看到的是错的数据。

但是，如果是先更库再删缓存，只有极小概率会出问题，比如：

读请求缓存没命中，正在读数据库的瞬间，写请求更新了数据库并删了缓存，之后读请求把旧数据写回缓存。

但是，但是啊，这个场景发生的条件太苛刻了，因为写数据库的耗时远大于读数据库，基本卡不中这个时间窗口，线上出问题的概率几乎可以忽略。

就算真的撞上了，还有缓存 TTL 兜底，最多就是短时间不一致，绝对不会出永久脏数据。

其实，这个方案最大的风险，是第二步删缓存失败。

同步删缓存如果失败，立刻把这个key丢到消息队列里做异步指数退避重试，设置最大重试次数，绝对不让缓存操作阻塞主流程。

高并发下的两个进阶方案

第一个是延迟双删，解决基础方案的极端并发问题。
“针对商品详情、营销活动这种超高并发读的场景，用延迟双删做加固，流程是：

先删除缓存➡️更新数据库➡️延迟500ms-1s，二次删除缓存。
第二次延迟删除，刚好能覆盖掉【数据库更新过程中，读请求写回缓存的旧数据】，彻底解决极端并发的脏数据问题。
其中，延迟时间必须大于【业务读请求的最大耗时 + 数据库主从同步延迟】。

第二个是基于Binlog的异步缓存淘汰。
用Binlog异步淘汰缓存，完全解耦业务和缓存操作。

业务代码只做一件事：更新数据库，完全不碰缓存。

然后用Canal监听数据库的binlog增量日志，只有主库事务提交成功，才会拿到数据变更事件，再异步去删除对应的缓存key。如果删除失败，就丢进死信队列重试，超过阈值直接触发告警。

强一致性方案

只有像支付账户余额、核心库存扣减这种，一分钱都不能错、零容错的场景，才会考虑强一致性方案，因为它的性能代价极大。
用Redisson的分布式读写锁，写请求加写锁，读请求加读锁，读写互斥，强制串行化，彻底避免并发问题。

但这个方案会严重降低系统吞吐量，高并发下很容易出现锁等待、超时问题，所以非核心场景，绝对不会用。

兜底机制

不管方案设计得多完美，线上一定会有意外，比如：

缓存集群炸了、消息队列挂了、binlog消费延迟了，没有兜底，就等着出线上事故。
可以采用以下兜底策略：

TTL兜底：所有缓存key必须设置合理的过期时间，哪怕所有机制都失效了，最多就是一段时间的不一致，缓存一过期，就自动拉取最新数据，绝对不会出现永久脏数据。
失败重试机制：所有缓存删除操作，必须有异步重试兜底，不能一次失败就放任脏数据存在。
降级开关：大促场景下，如果缓存集群扛不住了，直接开降级开关，所有请求切到读数据库，先保证用户能下单，别的都好说。

手撕真题-计算二叉树中两个节点之间的距离

Wed, 11 Mar 2026 22:26:31 +0000

思路

求解代码

 public class TreeDistance {

        /**
         * 计算两个节点在二叉树中的距离
         *
         * @param root 二叉树的根节点
         * @param p    第一个节点
         * @param q    第二个节点
         * @return 两个节点之间的距离
         */
        public int distanceBetweenNodes(TreeNode root, TreeNode p, TreeNode q) {
            // 首先找到两个节点的最近公共祖先(LCA)
            TreeNode lca = findLCA(root, p, q);
            // 计算节点p到LCA的深度
            int depthP = findDepth(lca, p);
            // 计算节点q到LCA的深度
            int depthQ = findDepth(lca, q);
            // 两个节点之间的距离等于它们到LCA的深度之和
            return depthP + depthQ;
        }

        /**
         * 查找二叉树中两个节点的最近公共祖先(LCA)
         *
         * @param root 二叉树的根节点
         * @param p    第一个目标节点
         * @param q    第二个目标节点
         * @return 最近公共祖先节点，如果其中一个节点是根节点，则返回该节点；如果两个节点分别在左右子树中，则返回它们的根节点
         */
        private TreeNode findLCA(TreeNode root, TreeNode p, TreeNode q) {
            // 如果根节点为空，或者根节点是p或q中的一个，直接返回根节点
            if (root == null || root == p || root == q) {
                return root;
            }
            // 递归查找左子树中的LCA
            TreeNode left = findLCA(root.left, p, q);
            // 递归查找右子树中的LCA
            TreeNode right = findLCA(root.right, p, q);
            // 如果左右子树都找到了非空节点，说明p和q分别在左右子树中，当前节点就是LCA
            if (left != null && right != null) {
                return root;
            }
            // 如果左子树找到非空节点，则返回左子树的结果，否则返回右子树的结果
            return left != null ? left : right;
        }


        /**
         * 查找目标节点在给定祖先节点下的深度
         *
         * @param ancestor 起始祖先节点
         * @param target   目标节点
         * @return 目标节点相对于祖先节点的深度，如果未找到则返回-1
         */
        private int findDepth(TreeNode ancestor, TreeNode target) {
            // 如果祖先节点为空，说明无法找到目标节点，返回-1
            if (ancestor == null) {
                return -1;
            }
            // 如果当前节点就是目标节点，深度为0
            if (ancestor == target) {
                return 0;
            }
            // 递归查找左子树
            int left = findDepth(ancestor.left, target);
            // 如果在左子树中找到目标节点，返回左子树深度+1
            if (left != -1) {
                return left + 1;
            }
            // 递归查找右子树
            int right = findDepth(ancestor.right, target);
            // 如果在右子树中找到目标节点，返回右子树深度+1，否则返回-1
            return right != -1 ? right + 1 : -1;
        }
    }

BISHI103 【模板】有依赖的背包问题

Tue, 10 Mar 2026 20:41:45 +0000

思路

求解代码

// 存储并查集中节点 i 的父节点
    private static int[] parent;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价钱
    private static int[] cost;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价值
    private static int[] value;

    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取基础配置：n 朵云, m 个搭配关系, w 现有的钱
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int m = Integer.parseInt(strA[1]);
        int w = Integer.parseInt(strA[2]);

        parent = new int[n + 1];
        cost = new int[n + 1];
        value = new int[n + 1];

        // 2. 初始化每朵云的属性，并初始化并查集（每个节点初始父节点为自己）
        for (int i = 1; i <= n; i++) {
            String[] strB = br.readLine().trim().split("\\s+");
            cost[i] = Integer.parseInt(strB[0]);
            value[i] = Integer.parseInt(strB[1]);
            parent[i] = i;
        }

        // 3. 处理搭配购买关系：使用并查集将必须一起买的云“联通”起来
        for (int i = 0; i < m; i++) {
            String[] strC = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(strC[0]);
            int v = Integer.parseInt(strC[1]);
            union(u, v);
        }

        // 4.将同一集合内所有云的价钱和价值全部累加到该集合的“根节点”上
        for (int i = 1; i <= n; i++) {
            int root = find(i);
            // 如果当前节点不是根节点，则将其属性转移给根节点
            if (root != i) {
                cost[root] += cost[i];
                value[root] += value[i];
                // 清空当前非根节点的属性，防止在后续背包计算中被重复统计
                cost[i] = 0;
                value[i] = 0;
            }
        }

        // 5. 执行 0/1 背包算法
        // dp[j] 表示在花费 j 元钱的情况下能获得的最大价值
        int[] dp = new int[w + 1];
        for (int i = 1; i <= n; i++) {
            // 只处理根节点（代表一个完整的“捆绑商品组”）
            if (parent[i] == i) {
                // 0/1 背包内层循环必须“逆序遍历”，防止同一商品被多次购买
                for (int j = w; j >= cost[i]; j--) {
                    // 状态转移方程：不买当前组 vs 买当前组（消耗钱，加价值）
                    dp[j] = Math.max(dp[j], dp[j - cost[i]] + value[i]);
                }
            }
        }

        // 6. 输出预算 w 内能获得的最大总价值
        out.println(dp[w]);

        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 查找根节点（带路径压缩优化）
     */
    private static int find(int i) {
        if (parent[i] == i) {
            return i;
        }
        // 将查找路径上的所有节点直接挂在根节点下，加速后续查找
        return parent[i] = find(parent[i]);
    }

    /**
     * 合并两个集合
     */
    private static void union(int i, int j) {
        int rootI = find(i);
        int rootJ = find(j);
        if (rootI != rootJ) {
            // 将 I 树合并到 J 树下
            parent[rootI] = rootJ;
        }
    }

BISHI102 【模板】并查集

Tue, 10 Mar 2026 20:04:55 +0000

思路

求解代码

// 存储节点 i 的父节点编号；当 parent[i] == i 时，i 为该集合的根节点
    private static int[] parent;
    // 仅在 i 为根节点时有效，记录以 i 为根的集合中包含的元素总数
    private static int[] size;

    public static void main(String[] args) throws IOException {
        // 使用高性能输入输出流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 解析输入首行的 n (元素总数) 和 q (操作总数)
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);

        parent = new int[n + 1];
        size = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            // 初始状态下，每个元素自成一个集合，父节点指向自己
            parent[i] = i;
            // 每个初始集合的大小均为 1
            size[i] = 1;
        }

        while (q-- > 0) {
            String[] strB = br.readLine().trim().split("\\s+");
            int op = Integer.parseInt(strB[0]); // 操作类型编号

            switch (op) {
                case 1: {
                    // 合并操作：将 i 和 j 所在的两个集合合并为一个
                    int i = Integer.parseInt(strB[1]);
                    int j = Integer.parseInt(strB[2]);
                    union(i, j);
                    break;
                }
                case 2: {
                    // 判断 i 和 j 是否属于同一个集合
                    int i = Integer.parseInt(strB[1]);
                    int j = Integer.parseInt(strB[2]);
                    // 若两者的根节点相同，则在同一集合，输出 YES
                    out.println(find(i) == find(j) ? "YES" : "NO");
                    break;
                }
                case 3: {
                    // 获取 i 所在集合的元素总数
                    int i = Integer.parseInt(strB[1]);
                    // 必须先通过 find(i) 找到根节点，因为只有根节点的 size 是准确的
                    out.println(size[find(i)]);
                    break;
                }
            }
        }

        // 刷新缓冲区并释放 IO 资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 查找元素 i 所在集合的根节点
     * 在递归查找过程中，将路径上所有节点的父节点直接指向根节点
     */
    private static int find(int i) {
        // 如果自己就是根节点，直接返回
        if (parent[i] == i) {
            return i;
        }
        // 将查找到的根节点赋值给当前节点的 parent 数组
        return parent[i] = find(parent[i]);
    }

    /**
     * 将包含 i 和 j 的两个集合合并
     *
     * @param i 第一个元素
     * @param j 第二个元素
     */
    private static void union(int i, int j) {
        // 分别获取两个元素当前的根节点
        int rootI = find(i);
        int rootJ = find(j);

        // 如果根节点不同，说明处于不同集合，执行合并
        if (rootI != rootJ) {
            // 将 I 集合的根节点挂载到 J 集合的根节点之下
            parent[rootI] = rootJ;
            // 将被合并集合的规模累加到新的根节点 (rootJ) 上
            size[rootJ] += size[rootI];
        }
    }

BISHI101 世界树上找米库

Mon, 09 Mar 2026 22:05:01 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量T
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- > 0) {
            // 读取树的节点数n
            int n = Integer.parseInt(br.readLine().trim());
            // 创建邻接表表示树
            List<Integer>[] adj = new ArrayList[n + 1];
            // 初始化邻接表
            for (int i = 1; i <= n; i++) {
                adj[i] = new ArrayList<>();
            }
            // 创建度数数组
            int[] deg = new int[n + 1];

            // 读取n-1条边，构建邻接表和度数数组
            for (int i = 0; i < n - 1; i++) {
                String[] edge = br.readLine().trim().split("\\s+");
                int u = Integer.parseInt(edge[0]);
                int v = Integer.parseInt(edge[1]);
                // 无向图，双向添加边
                adj[u].add(v);
                adj[v].add(u);

                // 更新节点的度数
                deg[u]++;
                deg[v]++;
            }
            // 创建距离数组，初始化为-1
            int[] dist = new int[n + 1];
            Arrays.fill(dist, -1);
            // 创建队列用于BFS
            Queue<Integer> queue = new LinkedList<>();

            // 将所有度为1的节点（叶子节点）加入队列，距离设为0
            for (int i = 1; i <= n; i++) {
                if (deg[i] == 1) {
                    dist[i] = 0;
                    queue.add(i);
                }
            }

            // BFS遍历树，计算每个节点到最近叶子节点的距离
            while (!queue.isEmpty()) {
                int u = queue.poll();
                // 遍历当前节点的所有邻接节点
                for (int v : adj[u]) {
                    if (dist[v] == -1) {
                        // 更新距离并加入队列
                        dist[v] = dist[u] + 1;
                        queue.add(v);
                    }
                }
            }

            // 找到最大距离
            int maxDist = -1;
            for (int i = 1; i <= n; i++) {
                // 只考虑非叶子节点
                if (deg[i] > 1) {
                    maxDist = Math.max(maxDist, dist[i]);
                }
            }

            // 收集所有距离为最大距离的非叶子节点（中心点）
            List<Integer> mikuPoints = new ArrayList<>();
            for (int i = 1; i <= n; i++) {
                if (deg[i] > 1 && dist[i] == maxDist) {
                    mikuPoints.add(i);
                }
            }

            // 输出中心点的数量
            out.println(mikuPoints.size());

            // 输出所有中心点
            for (int i = 0; i < mikuPoints.size(); i++) {
                out.print(mikuPoints.get(i) + (i == mikuPoints.size() - 1 ? "" : " "));
            }
            out.println();
        }

        // 刷新输出缓冲区，确保所有输出都被写入
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

BISHI100 【模板】二分图结构Ⅰ-A ‖ 染色判定：DFS

Mon, 09 Mar 2026 20:51:45 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入的第一行，包含两个整数n和m，分别表示顶点数和边数
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 顶点数
        int m = Integer.parseInt(strA[1]);  // 边数

        // 创建邻接表表示的无向图
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取所有边的信息，构建无向图
        for (int i = 0; i < m; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            adj[u].add(v);  // 添加边到邻接表
            adj[v].add(u);  // 无向图，双向添加
        }

        // color数组用于记录每个顶点的颜色，0表示未染色，1和2表示两种不同的颜色
        int[] color = new int[n + 1];
        boolean flag = true;  // 标记是否为二分图

        // 使用队列实现BFS
        Queue<Integer> queue = new LinkedList<>();

        // 从顶点1开始染色，并将其加入队列
        queue.add(1);
        color[1] = 1;

        // BFS遍历图
        while (!queue.isEmpty()) {

            int cur = queue.poll();  // 取出队首顶点

            // 遍历当前顶点的所有邻接顶点
            for (int neighbor : adj[cur]) {

                // 如果邻接顶点未被染色
                if (color[neighbor] == 0) {

                    // 将邻接顶点染成与当前顶点不同的颜色
                    color[neighbor] = 3 - color[cur];
                    queue.add(neighbor);  // 将邻接顶点加入队列
                } else if (color[neighbor] == color[cur]) {
                    // 如果邻接顶点与当前顶点颜色相同，则不是二分图
                    flag = false;
                    break;
                }
            }
        }

        // 输出结果：如果是二分图输出"YES"，否则输出"NO"
        out.println(flag ? "YES" : "NO");
        // 刷新输出缓冲区，确保所有输出都被写入
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

BISHI99 我朋友的朋友不是我的朋友

Sun, 08 Mar 2026 21:13:49 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取成员数 n 和 好友关系数 m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int m = Integer.parseInt(strA[1]);

        // nameToID: 将字符串姓名映射为整数 ID，方便作为数组下标处理
        HashMap<String, Integer> nameToID = new HashMap<>();
        // idToName: 将整数 ID 映射回姓名，用于最后的结果输出
        String[] idToName = new String[n];
        // adj: 邻接表，存储每个人的好友列表
        List<Integer>[] adj = new ArrayList[n];
        // deg: 存储每个人的“社牛指数”（即节点的度数）
        int[] deg = new int[n];
        int idCount = 0; // 记录当前已分配的 ID 数量

        // 2. 构建图结构
        for (int i = 0; i < m; i++) {
            String[] pair = br.readLine().trim().split("\\s+");

            // 处理每一对好友关系中的两个姓名
            for (String name : pair) {
                // 如果是第一次见到的姓名，分配一个新的 ID 并初始化其邻接表
                if (!nameToID.containsKey(name)) {
                    idToName[idCount] = name;
                    adj[idCount] = new ArrayList<>();
                    nameToID.put(name, idCount++);
                }
            }

            // 获取两个好友对应的 ID
            int u = nameToID.get(pair[0]);
            int v = nameToID.get(pair[1]);

            // 无向图：双方互相添加进对方的好友列表
            adj[u].add(v);
            adj[v].add(u);

            // 双方的度数各加 1
            deg[u]++;
            deg[v]++;
        }

        // 3. 判定“社牛”成员
        List<String> res = new ArrayList<>();
        for (int i = 0; i < idCount; i++) {
            // 孤立点（没有好友的人）不符合社牛定义
            if (deg[i] == 0) {
                continue;
            }

            // sum: 累计该成员所有好友的度数总和
            long sum = 0;
            for (int neighbor : adj[i]) {
                sum += deg[neighbor];
            }

            /**
             * 判定公式推导：
             * 原条件：deg(x) > (sum_of_friends_deg / deg(x))
             * 变形得：deg(x) * deg(x) > sum_of_friends_deg
             *
             * 优点：避免浮点数除法导致的精度丢失。
             * 注意：deg 最大为 10^5，平方后达 10^10，超过了 int 范围，必须强转为 long 计算。
             */
            if ((long) deg[i] * deg[i] > sum) {
                res.add(idToName[i]);
            }
        }

        // 4. 输出处理
        if (res.isEmpty()) {
            // 若不存在任何社牛，输出 None
            out.println("None");
        } else {
            // 题目要求按字典序升序输出
            Collections.sort(res);
            for (int i = 0; i < res.size(); i++) {
                // 格式化输出：姓名之间用单个空格分隔
                out.print(res.get(i) + (i == res.size() - 1 ? "" : " "));
            }
            out.println();
        }

        // 5. 刷新缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

BISHI98 谍中谍中谍中谍中谍.

Sun, 08 Mar 2026 20:21:01 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取学生总人数 n
        int n = Integer.parseInt(br.readLine().trim());

        // 2. 读取指认关系字符串并按空格拆分
        String[] strA = br.readLine().trim().split("\\s+");

        // p[i] 存储学生 i 指认的学生编号
        // 使用 n+1 大小以便让下标 1~n 对应学生编号 1~n，符合直觉
        int[] p = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            p[i] = Integer.parseInt(strA[i - 1]);
        }

        // 3. 题目要求：假设老师最初抓到的是第 i 个学生
        // 我们需要对 1 到 n 每一个起点都模拟一遍追踪过程
        for (int i = 1; i <= n; i++) {
            // 获取从起点 i 开始追踪，最后被老师劝退的学生编号
            int res = findStu(i, p, n);

            // 格式化输出：除了最后一个数，后面都加空格
            out.print(res + (i == n ? "" : " "));
        }

        // 4. 刷新缓冲区确保数据完整写出，并按规范关闭流资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 追踪退学警告的过程
     *
     * @param start 老师最初抓到的学生编号
     * @param p     指认关系数组（图的邻接关系）
     * @param n     学生总数
     * @return      第一个收到两次警告（即导致退学）的学生编号
     */
    private static int findStu(int start, int[] p, int n) {
        // visited[i] 记录学生 i 是否已经收到过一次警告
        // 每一轮新起点都需要一个全新的标记数组
        boolean[] visited = new boolean[n + 1];

        int cur = start; // 从老师抓到的第一位学生开始

        // 由于学生数量有限且出度为 1，追踪过程必然会进入一个环并死循环
        // 我们通过 while(true) 配合内部 return 退出
        while (true) {
            // 如果当前学生 cur 的 visited 标记已经是 true，
            // 说明这是他第二次被抓到了，触发“劝说退学”逻辑，直接返回他
            if (visited[cur]) {
                return cur;
            }

            // 第一次抓到该学生，打上标记（发出第一次退学警告）
            visited[cur] = true;

            // 根据供述，抓取下一个被指认的人
            cur = p[cur];
        }
    }

BISHI97旺仔哥哥走迷宫

Sat, 07 Mar 2026 20:12:40 +0000

思路

求解代码


    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，获取节点数n和边数m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 节点数量
        int m = Integer.parseInt(strA[1]);  // 边的数量
        int[] t = new int[n + 1];  // 存储每个节点的类型，索引从1开始
        // 读取第二行输入，获取每个节点的类型
        String[] strB = br.readLine().trim().split("\\s+");

        // 将节点类型数据存入数组t，索引从1开始
        for (int i = 1; i <= n; i++) {
            t[i] = Integer.parseInt(strB[i - 1]);
        }

        // 创建邻接表表示的图结构
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取所有边的信息，构建无向图
        for (int i = 0; i < m; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            adj[u].add(v);  // 添加边到邻接表
            adj[v].add(u);  // 无向图，双向添加
        }

        // 检查起点或终点是否为类型1，如果是则直接输出"No"
        if (t[1] == 1 || t[n] == 1) {
            out.println("No");
        } else {
            // 调用BFS算法判断路径是否可行
            if (bfs(n, adj, t)) {
                out.println("Yes");
            } else {
                out.println("No");
            }
        }

        // 刷新缓冲区确保数据完整写出并关闭流
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用广度优先搜索(BFS)算法判断从节点1到节点n是否存在有效路径
     *
     * @param n   节点总数
     * @param adj 邻接表，表示图的连接关系
     * @param t   数组，标记节点的状态(0表示可通过，非0表示不可通过)
     * @return 如果存在从节点1到节点n的有效路径则返回true，否则返回false
     */
    private static boolean bfs(int n, List<Integer>[] adj, int[] t) {
        // 创建队列用于BFS遍历
        Queue<Integer> queue = new LinkedList<>();
        // 创建访问标记数组，记录节点是否被访问过
        boolean[] visited = new boolean[n + 1];

        // 从节点1开始搜索
        queue.add(1);
        visited[1] = true;

        // 当队列不为空时，继续搜索
        while (!queue.isEmpty()) {
            // 取出队首节点
            int cur = queue.poll();
            // 如果到达目标节点n，返回true
            if (cur == n) {
                return true;
            }

            // 遍历当前节点的所有邻接节点
            for (int neighbor : adj[cur]) {
                // 如果邻接节点可通过且未被访问过
                if (t[neighbor] == 0 && !visited[neighbor]) {
                    // 标记为已访问并入队
                    visited[neighbor] = true;
                    queue.add(neighbor);
                }
            }
        }
        // 队列已空未到达目标节点，返回false
        return false;
    }

BISHI96 先序遍历、中序遍历和后序遍历

Sat, 07 Mar 2026 19:38:45 +0000

思路

求解代码

// 使用数组模拟指针，lc[i] 存储节点 i 的左孩子，rc[i] 存储右孩子
    private static int[] lc, rc;

    // 使用 StringBuilder 缓存结果
    private static StringBuilder preOrder = new StringBuilder();
    private static StringBuilder inOrder = new StringBuilder();
    private static StringBuilder postOrder = new StringBuilder();

    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine().trim());

        // 边界情况：空树
        if (n == 0) {
            return;
        }

        // 初始化结构：n+1 长度是为了匹配从 1 开始的节点编号
        lc = new int[n + 1];
        rc = new int[n + 1];
        boolean[] hasParent = new boolean[n + 1]; // 用于寻找根节点（根节点没有父节点）

        // 使用邻接表暂时存储“父 -> 子”的原始指向关系，随后再按规则分配左右
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取 n-1 条边，构建树的层级关系
        for (int i = 0; i < n - 1; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]); // 父节点
            int v = Integer.parseInt(edge[1]); // 子节点
            adj[u].add(v);
            hasParent[v] = true; // 只要被指向，就说明该节点不是根节点
        }

        /**
         * 根据题目定义的规则，将 adj 里的子节点分配到 lc 或 rc
         */
        for (int i = 1; i <= n; i++) {
            // 父节点拥有两个孩子
            if (adj[i].size() == 2) {
                int c1 = adj[i].get(0);
                int c2 = adj[i].get(1);
                // 编号小者为左，大者为右
                lc[i] = Math.min(c1, c2);
                rc[i] = Math.max(c1, c2);
            }
            // 父节点仅有一个孩子
            else if (adj[i].size() == 1) {
                int child = adj[i].get(0);
                // 子节点编号 > 父节点编号 ➜ 视为左孩子；反之 ➜ 视为右孩子
                if (child > i) {
                    lc[i] = child;
                } else {
                    rc[i] = child;
                }
            }
        }

        // 寻找整棵树的唯一根节点
        int root = 1;
        for (int i = 1; i <= n; i++) {
            if (!hasParent[i]) {
                root = i;
                break;
            }
        }

        // 从根节点开始DFS
        traverse(root);

        // 格式化输出
        out.println(preOrder.toString().trim());
        out.println(inOrder.toString().trim());
        out.println(postOrder.toString().trim());

        // 刷新缓冲区确保数据完整写出并关闭流
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 深度优先遍历 (DFS) 方法
     *
     * @param cur 当前正在访问的节点索引
     */
    private static void traverse(int cur) {
        // 基准情形：如果当前节点为 0，说明触碰到了空叶子节点，停止向下延伸
        if (cur == 0) {
            return;
        }

        /**
         * 1. 先序遍历 (Pre-order)：[中] -> 左 -> 右
         * 刚进入当前节点时立即记录。
         */
        preOrder.append(cur).append(" ");

        // 向左延伸
        traverse(lc[cur]);

        /**
         * 2. 中序遍历 (In-order)：左 -> [中] -> 右
         * 当左子树全部处理完毕回溯到当前点时记录。
         */
        inOrder.append(cur).append(" ");

        // 向右延伸
        traverse(rc[cur]);

        /**
         * 3. 后序遍历 (Post-order)：左 -> 右 -> [中]
         * 当左右子树全部处理完毕，即将彻底离开当前点时记录。
         */
        postOrder.append(cur).append(" ");
    }

BISHI95 【模板】链式前向星

Fri, 06 Mar 2026 21:04:50 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割字符串并转换为整数n和m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 节点数
        int m = Integer.parseInt(strA[1]);  // 边数

        // 创建邻接表，大小为n+1（节点从1开始编号）
        List<Integer>[] adj = new ArrayList[n + 1];
        // 初始化每个节点的邻接表
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取m条边，构建无向图的邻接表
        for (int i = 0; i < m; i++) {

            // 读取边的两个端点
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            // 无向图，两个方向都添加
            adj[u].add(v);
            adj[v].add(u);
        }

        // 遍历每个节点，输出其邻接节点
        for (int i = 1; i <= n; i++) {
            // 如果节点没有邻接节点，输出"None"
            if (adj[i].isEmpty()) {
                out.println("None");
            } else {
                // 对邻接节点进行排序
                Collections.sort(adj[i]);

                // 输出排序后的邻接节点
                for (int j = 0; j < adj[i].size(); j++) {
                    // 如果是最后一个节点，直接输出，否则输出空格
                    out.print(adj[i].get(j) + (j == adj[i].size() - 1 ? "" : " "));
                }
                out.println();
            }
        }


        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

BISHI94 【模板】马拉车算法

Fri, 06 Mar 2026 20:32:16 +0000

思路

求解代码

 public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果，提高IO效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入字符串并去除首尾空格
        String s = br.readLine().trim();

        // 处理空字符串或null值的情况
        if (s == null || s.length() == 0) {
            out.println(0);  // 输出0
            out.flush();     // 确保所有输出都被刷新
            return;          // 提前返回
        }

        // 调用manacher算法处理字符串并输出结果
        out.println(manacher(s));
        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();   // 关闭输入流
    }

    /**
     * Manacher算法实现，用于查找字符串中的最长回文子串的长度
     * 该算法通过预处理字符串和利用回文对称性来高效地找到最长回文子串
     *
     * @param s 输入的字符串
     * @return 返回最长回文子串的长度
     */
    private static int manacher(String s) {
        // 构造新的字符串，以^开头，$结尾，并在每个字符间插入#，这样可以统一处理奇数和偶数长度的回文
        StringBuilder sb = new StringBuilder("^");

        // 在原字符串的每个字符前后添加特殊字符#
        for (char c : s.toCharArray()) {
            sb.append("#").append(c);
        }

        // 添加结尾标记
        sb.append("#$");

        // 将构造好的字符串转换为字符数组
        char[] t = sb.toString().toCharArray();

        // 获取新字符串的长度
        int n = t.length;
        // 创建数组p，p[i]表示以t[i]为中心的最长回文半径
        int[] p = new int[n];
        // c表示当前回文中心，r表示当前回文右边界
        int c = 0, r = 0;
        // 记录最长回文半径
        int maxLen = 0;

        // 遍历字符串，跳过首尾的特殊字符
        for (int i = 1; i < n - 1; i++) {
            // 利用回文对称性，如果i在当前回文范围内，则获取其对称位置的回文半径
            p[i] = r > i ? Math.min(r - i, p[2 * c - i]) : 0;

            // 尝试扩展以i为中心的回文
            while (t[i + p[i] + 1] == t[i - p[i] - 1]) {
                p[i]++;
            }

            // 如果当前回文右边界超过了r，更新中心和右边界
            if (i + p[i] > r) {
                c = i;
                r = i + p[i];
            }

            // 更新最大回文半径
            maxLen = Math.max(maxLen, p[i]);
        }

        // 返回最长回文半径，也就是最长回文子串的长度
        return maxLen;
    }

BISHI93 【模板】Trie 字典树

Thu, 05 Mar 2026 22:07:17 +0000

思路

求解代码

/**
     * trie[p][i]: 字典树的节点存储。
     * 第一维 p 代表节点的编号（行号）；
     * 第二维 i 代表字符的映射索引（0-51）。
     * 值存储的是该字符指向的下一个节点的编号。
     */
    private static int[][] trie = new int[1000005][52];

    /**
     * count[p]: 前缀统计的核心。
     * 记录有多少个模式串在插入过程中经过了编号为 p 的节点。
     * 因为我们要统计“以某串为前缀的个数”，所以每经过一个点都要加1。
     */
    private static int[] count = new int[1000005];

    /**
     * nodes: 记录当前字典树已经创建的节点总数。
     * 编号 0 始终代表根节点（不存储具体字符）。
     */
    private static int nodes = 0;

    public static void main(String[] args) throws IOException {
        // 使用高效的输入输出流处理百万级数据，防止超时
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行：模式串数量 n 和查询次数 q
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);

        // 1. 构建字典树阶段
        for (int i = 0; i < n; i++) {
            insert(br.readLine().trim());
        }

        // 2. 查询阶段
        for (int i = 0; i < q; i++) {
            // 直接输出以该文本串为前缀的模式串数量
            out.println(query(br.readLine().trim()));
        }

        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 将字符映射到 0-51 的索引空间。
     * 区分大小写：'A'-'Z' 映射到 0-25，'a'-'z' 映射到 26-51。
     */
    private static int getIndex(char c) {
        return c >= 'A' && c <= 'Z' ? c - 'A' : c - 'a' + 26;
    }

    /**
     * 模式串插入方法
     * 核心逻辑：沿着路径在每个经过的节点打标记计数。
     */
    private static void insert(String s) {
        int p = 0; // 从根节点 (编号 0) 开始
        for (char c : s.toCharArray()) {
            int i = getIndex(c);
            // 如果当前字符在当前节点下没有对应的子节点，则新建一个
            if (trie[p][i] == 0) {
                trie[p][i] = ++nodes;
            }
            // 移动到子节点
            p = trie[p][i];
            /**
             * 关键：只要经过这个节点，count 就自增。
             * 这样 count[p] 就代表了有多少个单词是以“从根到当前点”这一串字符为前缀的。
             */
            count[p]++;
        }
    }

    /**
     * 文本串查询方法
     * 核心逻辑：在字典树中顺着文本串寻找路径，若能走完路径，返回最后的 count。
     */
    private static int query(String t) {
        int p = 0; // 从根节点开始
        for (char c : t.toCharArray()) {
            int i = getIndex(c);
            /**
             * 如果在路径中发现某个字符没有对应的分支，
             * 说明没有任何一个模式串包含这个前缀，直接返回 0。
             */
            if (trie[p][i] == 0) {
                return 0;
            }
            p = trie[p][i]; // 顺着路径向下走
        }
        /**
         * 成功走完文本串 t 的所有字符，
         * 此时节点 p 的 count 值就是在插入阶段经过该点的字符串总数。
         */
        return count[p];
    }

BISHI92 【模板】前缀函数（kmp）

Thu, 05 Mar 2026 20:58:37 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 创建缓冲读取器，用于从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 创建打印输出器，用于向标准输出打印数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        // 读取测试用例的数量T
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- > 0) {
            // 读取一行输入并分割成字符串数组
            String[] s = br.readLine().trim().split("\\s+");
            // 获取字符串的长度n
            int n = Integer.parseInt(s[0]);

            // 计算前缀函数数组
            int[] pi = computePre(s[1], n);

            // 输出前缀函数数组，元素间用空格分隔
            for (int i = 0; i < n; i++) {
                out.print(pi[i] + (i == n - 1 ? "" : " "));
            }
            // 换行
            out.println();
        }

        // 刷新输出缓冲区，确保所有输出都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 计算字符串的前缀函数（Prefix Function）
     * 前缀函数pi[i]表示字符串s[0..i]的最长相等前后缀的长度（不包括s[0..i]本身）
     *
     * @param s 输入的字符串
     * @param n 字符串的长度
     * @return 返回前缀函数数组pi，其中pi[i]表示s[0..i]的最长相等前后缀长度
     */
    private static int[] computePre(String s, int n) {
        int[] pi = new int[n];  // 初始化前缀函数数组，长度为n

        // 从第二个字符开始遍历字符串
        for (int i = 1; i < n; i++) {
            int j = pi[i - 1];  // 初始化j为前一个字符的前缀函数值

            // 当j大于0且当前字符不匹配时，通过前缀函数回退
            while (j > 0 && s.charAt(i) != s.charAt(j)) {
                j = pi[j - 1];  // 回退到前一个可能匹配的位置
            }

            // 如果当前字符匹配，则增加匹配长度
            if (s.charAt(i) == s.charAt(j)) {
                j++;
            }

            // 将当前字符的前缀函数值存入数组
            pi[i] = j;
        }
        return pi;  // 返回计算得到的前缀函数数组
    }

【DFS+剪枝】BISHI91 拼接木棍

Wed, 04 Mar 2026 22:20:09 +0000

思路

求解代码

// n: 小木棒总数, sum: 所有木棒总长度, targetL: 目标原始长度, numbers: 目标原始木棒根数
    private static int n, sum, targetL, numbers;
    private static Integer[] a; // 存储砍断后的小木棒长度

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        n = Integer.parseInt(br.readLine().trim());
        String[] s = br.readLine().trim().split("\\s+");
        a = new Integer[n];
        boolean[] used = new boolean[n]; // 标记每根小木棒是否已被乔治使用
        sum = 0;
        int maxL = 0;

        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(s[i]);
            sum += a[i];
            maxL = Math.max(maxL, a[i]); // 原始长度至少要等于最长的那根小木棒
        }

        // 【剪枝优化 1】：降序排序。
        // 优先尝试长木棒。因为长木棒对位置要求更苛刻，如果它拼不通，能更早触发回溯。
        Arrays.sort(a, (x1, x2) -> (x2 - x1));

        // 枚举原始木棒可能的长度 targetL
        // 范围：从最长的那根开始，直到所有木棒的总和
        for (targetL = maxL; targetL <= sum; targetL++) {

            // 【条件约束】：原始长度必须能被总长度整除，否则乔治不可能拼成同样长的木棒
            if (sum % targetL != 0) {
                continue;
            }

            numbers = sum / targetL; // 计算在当前 targetL 下应该拼出多少根

            // 尝试拼凑，初始：已完成0根，当前长度0，从第0个小木棒开始找
            if (dfs(0, 0, 0, used)) {
                out.println(targetL); // 找到第一个可行的最小长度，即为答案
                break;
            }
        }
        out.flush();
        out.close();
        br.close();
    }

    /**
     * DFS 拼凑过程
     *
     * @param completed 已完整拼好的原始木棒根数
     * @param currentL  当前正在拼的那根原始木棒已经达到的长度
     * @param idx       为了避免重复组合，从数组的哪一个下标开始挑选下一根小木棒
     * @param used      使用情况记录
     */
    private static boolean dfs(int completed, int currentL, int idx, boolean[] used) {
        // 【递归出口】：如果乔治拼好了所有原始木棒，大功告成
        if (completed == numbers) {
            return true;
        }

        // 如果当前这根拼满了，开启下一根木棒的拼凑
        if (currentL == targetL) {
            return dfs(completed + 1, 0, 0, used);
        }

        for (int i = idx; i < n; i++) {
            // 如果这根用过了，或者放进去就超过了目标长度，跳过
            if (used[i] || currentL + a[i] > targetL) {
                continue;
            }

            // 【做选择】：尝试放这根木棒
            used[i] = true;
            if (dfs(completed, currentL + a[i], i + 1, used)) {
                return true;
            }

            // 【撤销选择】：刚才的尝试失败了，拿出来
            used[i] = false;

            // --- 核心剪枝策略 (极其关键) ---

            // 【剪枝优化 2】：首棒失败判定
            // 如果此时 currentL 为 0，说明我们正在尝试拼一根新木棒的第一部分。
            // 如果第一部分用这根最长的木棒都拼不出来，那后面更拼不出来了。

            // 【剪枝优化 3】：末棒失败判定
            // 如果加上这根木棒刚好填满了 targetL，但在后续递归中失败了，
            // 说明用这根刚好填满的方案不行，那么换用几根更碎的小木棒来填这个坑也肯定不行。
            if (currentL == 0 || currentL + a[i] == targetL) {
                return false;
            }

            // 【剪枝优化 4】：去重剪枝
            // 如果当前长度的木棒不行，那后面相同长度的木棒也肯定不行，直接跳过。
            while (i + 1 < n && a[i + 1].equals(a[i])) {
                i++;
            }
        }
        return false;
    }

BISHI90 【模板】记忆化搜索

Wed, 04 Mar 2026 20:51:44 +0000

思路

求解代码

 private static final int MOD = 1000000007;
    private static long[][][] memory = new long[101][101][101];

    public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));


        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            String[] s = br.readLine().trim().split("\\s+");
            int a = Integer.parseInt(s[0]);
            int b = Integer.parseInt(s[1]);
            int c = Integer.parseInt(s[2]);
            out.println(solve(a, b, c));
        }


        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }

    /**
     * 这是一个递归求解函数，使用记忆化技术来优化性能
     *
     * @param a 第一个参数
     * @param b 第二个参数
     * @param c 第三个参数
     * @return 返回计算结果，类型为long
     */
    private static long solve(int a, int b, int c) {
        // 如果任一参数小于等于0，返回1
        if (a <= 0 || b <= 0 || c <= 0) {
            return 1;
        }

        // 如果结果已经计算过并存储在memory中，直接返回存储的结果
        if (memory[a][b][c] != 0) {
            return memory[a][b][c];
        }

        long res; // 用于存储计算结果

        // 当a<b且b<c时，使用特定的递归公式计算
        if (a < b && b < c) {
            res = (solve(a, b, c - 1) + solve(a, b - 1, c - 1)) % MOD;
            res = (res - solve(a, b - 1, c) + MOD) % MOD;
        } else {
            res = (solve(a - 1, b, c) + solve(a - 1, b - 1, c)) % MOD;
            res = (res + solve(a - 1, b, c - 1)) % MOD;
            res = (res - solve(a - 1, b - 1, c - 1) + MOD) % MOD;
        }
        return memory[a][b][c] = res;
    }

零成本上线个人项目 ——ngrok 仅穿透前端实现公网访问

Wed, 04 Mar 2026 17:39:43 +0000

开发个人项目时，想让他人访问往往需要购买服务器、配置域名解析，成本高且流程繁琐。

本文介绍一种零成本方案 —— 仅穿透前端即可实现内网个人项目的公网访问。

ngrok 账号注册与工具准备

首先在https://ngrok.com/ 官网注册一个账号，就能获得一个免费的dev结尾的域名。

注册好之后，下载对应的zip压缩包

在官网个人后台 / 仪表盘（Dashboard）可直接复制个人专属的 Authtoken。

分框架适配配置

如果前端是用 Vite + React 的项目，需要在 vite.config.js 文件加上allowedHosts这一行代码：

// vite.config.js
export default defineConfig({
  server: {
    allowedHosts: ['xxx.dev']  // ngrok 域名
  }
})

如果前端是基于 Umi Max + Ant Design Pro 的项目，前端默认是跑在 localhost:8000（umi dev），则需要修改2个文件。

1.config/config.ts

在文件里加上如下 proxy 部分：

// config/config.ts
export default defineConfig({
  // ... 其他配置 ...

  proxy: {
    '/api/': {
      target: 'http://localhost:[项目后端的端口号]',
      changeOrigin: true,
      // 根据后端实际路由决定是否 rewrite
      // 如果后端接口路径就是 /api/xxx 开头 → 不要 rewrite
      // 如果后端是 /user/xxx（无 /api 前缀） → 加下面这行
      // pathRewrite: { '^/api': '' },
    },
  },

  // ... 其他配置 ...
});

这段只在 umi dev / npm run dev 时生效。

2.src/app.tsx

找到 request 配置，把 baseURL 相关全部注释或删除：

// src/app.tsx

export const request: RequestConfig = {
  // ！！！ 下面这整段注释掉或删除 ！！！
  // baseURL: "http://localhost:[项目后端的端口号]",

  // 保持这两个（ngrok 警告页绕过 + cookie 跨域）
  withCredentials: true,
  headers: {
    'ngrok-skip-browser-warning': 'true',
  },

  ...errorConfig,
};

项目启动与公网访问

接下来，依次启动后端和前端，将之前下载好的压缩包解压后直接双击 exe 即可打开命令行，执行以下命令：

1
2
3

ngrok config add-authtoken [YourAuthtoken]

ngrok http [项目前端的端口号]

复制 ngrok 生成的 https 地址，其他人就能够访问你的项目了。

【二分】BISHI89 山峰数组计数

Tue, 03 Mar 2026 21:17:15 +0000

思路

求解代码

public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取整数n，表示数组的长度
        int n = Integer.parseInt(br.readLine().trim());
        // 创建长度为n的数组P，用于存储输入的数值
        long[] P = new long[n];
        // 创建长度为n+1的前缀和数组preSum，preSum[0]=0
        long[] preSum = new long[n+1];

        // 读取一行输入，按空格分割成字符串数组
        String[] s= br.readLine().trim().split("\\s+");
        // 计算前缀和
        for(int i=0;i<n;i++){
            // 将字符串转换为长整型并存入数组P
            P[i]= Long.parseLong(s[i]);
            // 计算前缀和，preSum[i+1]表示前i个元素的和
            preSum[i+1]=preSum[i]+P[i];
        }

        // 初始化总和变量total
        long total = 0;

        // 遍历数组，从第2个元素开始到倒数第2个元素
        for (int j=2;j<n;j++){
            // 计算limit1，即(preSum[j]-1)/2
            long limit1 = (preSum[j]-1)/2;
            // 计算limit2，即2*preSum[j]-preSum[n]-1
            long limit2 = 2*preSum[j]-preSum[n]-1;
            // 取limit1和limit2中的较小值作为阈值
            long threshold = Math.min(limit1,limit2);

            // 如果阈值大于等于第一个元素的前缀和
            if (threshold >= preSum[1]){
                // 调用upper函数计算符合条件的元素个数
                int count = upper(preSum,1,j-1,threshold);
                // 将count累加到total中
                total += count;
            }
        }



        // 输出最终结果
        out.println(total);

        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }

/**
 * 在有序数组中查找最后一个小于等于目标值的元素的位置，并返回满足条件的元素个数
 * @param preSum 有序数组，表示前缀和数组
 * @param left 查找范围的左边界
 * @param right 查找范围的右边界
 * @param target 目标值
 * @return 返回在[left, right]范围内小于等于target的元素个数
 */
    private static int upper(long[] preSum,int left,int right,long target){
        int low = left,high = right;    // 初始化查找范围的左右边界
        int ans = 0;                    // 初始化答案变量

        // 执行二分查找
        while(low<=high){
            int mid = low +((high-low)>>1);   // 计算中间值，使用位运算优化替代除法

                                        // 这种写法可以避免(low+high)可能导致的整数溢出问题
            // 检查中间值是否满足条件
            if(preSum[mid]<=target){    // 如果中间值小于等于目标值
                ans = mid;              // 更新答案为当前位置
                low = mid+1;            // 在右半部分继续查找
            }else{                      // 如果中间值大于目标值
                high = mid-1;           // 在左半部分继续查找
            }
        }
    // 返回结果：如果找到满足条件的元素，返回其个数；否则返回0
        return ans>0?(ans-left+1):0;
    }

【二分】BISHI88 小苯的魔法染色

Tue, 03 Mar 2026 20:41:07 +0000

思路

求解代码

public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割为字符串数组
        String[] strA = br.readLine().trim().split("\\s+");

        int n = Integer.parseInt(strA[0]);    // 获取字符串长度
        int m = Integer.parseInt(strA[1]);    // 获取操作次数

        char[] c = new char[n];               // 创建字符数组，虽然在此代码中未使用

        String s= br.readLine().trim();      // 待处理的字符串

        int low = 0,high = n;                // 二分查找的边界
        int ans = n;                          // 初始化答案为字符串长度

        // 执行二分查找
        while(low<=high){
            int mid = low +((high-low)>>1);   // 计算中间值，使用位运算优化替代除法

            // 检查中间值是否满足条件
            if(check(mid,n,m,s)){
                ans = mid;                     // 如果满足条件，更新答案
                high = mid-1;                // 尝试寻找更小的解
            }else{
                low = mid+1;                 // 如果不满足，尝试更大的值
            }
        }

        // 输出最终结果
        out.println(ans);

        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }
    
    private static boolean check(int k,int n,int m,String s){
        // 如果k为0，检查字符串中是否不包含'W'
        if(k==0){
            return !s.contains("W");
        }

        int count = 0; // 记录操作次数
        // 遍历字符串
        for (int i=0;i<n;i++){
            // 如果当前字符是'W'，增加操作计数
            if(s.charAt(i)=='W'){
                count++;
                // 如果操作次数超过m，返回false
                if(count>m){
                    return false;
                }
                // 跳过接下来的k-1个字符
                i+=(k-1);
            }
        }

        // 检查总操作次数是否不超过m
        return count<=m;
    }

【二分】BISHI87 [CQOI2010]扑克牌

Mon, 02 Mar 2026 21:44:34 +0000

思路

求解代码

public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割为字符串数组
        String[] strA = br.readLine().trim().split("\\s+");

        int n = Integer.parseInt(strA[0]);
        long m = Long.parseLong(strA[1]);

        int[] c = new int[n];                   // 创建大小为n的整型数组

        // 读取第二行输入，分割为字符串数组
        String[] strB = br.readLine().trim().split("\\s+");

        // 将字符串数组转换为整型数组
        for(int i=0;i<n;i++){
            c[i]=Integer.parseInt(strB[i]);
        }



        // 初始化二分查找的边界和结果变量
        long low = 0,high = 10000000000L;      // 设置查找范围为0到100亿
        long ans = 0;

        // 执行二分查找
        while(low<=high){
            long mid = low +((high-low)>>1);   // 计算中间值，使用位运算优化

            // 检查中间值是否满足条件
            if(check(mid,n,m,c)){
                ans = mid;                     // 如果满足条件，更新答案
                low = mid+1;                   // 尝试更大的值
            }else{
                high = mid-1;                  // 如果不满足，尝试更小的值
            }
        }

        // 输出最终结果
        out.println(ans);

        // 刷新输出流
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    private static boolean check(long x,int n,long m,int[] c){
        long need = 0; // 需要添加的资源总量
        for(int count:c){ // 遍历每种资源的当前数量
            if(count<x){ // 如果当前资源数量小于目标数量
                need +=(x-count); // 计算需要添加的资源数量
            }
        }

        return need <= m&& need <=x; // 判断需要添加的资源总量是否不超过m和x
    }

【二分】BISHI86 圆覆盖

Mon, 02 Mar 2026 20:59:32 +0000

思路

求解代码

 /**
     * 表示一个点的静态内部类
     * 包含两个属性：d2和v
     */
    static class Point {
        // 平方距离属性，通常用于表示点与点之间的距离平方
        long d2;
        // 权值属性
        long v;


        Point(long d2, long v) {
            // 使用this关键字将参数值赋给类的成员变量
            this.d2 = d2;
            this.v = v;
        }
    }

    public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割为字符串数组
        String[] strA = br.readLine().trim().split("\\s+");
        // 获取点的数量n
        int n = Integer.parseInt(strA[0]);
        // 获取所需的最小权值S
        long S = Long.parseLong(strA[1]);

        // 创建二维数组存储每个点的坐标和权值
        long[][] a = new long[n][3];

        // 创建Point数组，用于存储每个点到原点的距离平方和权值
        Point[] points = new Point[n];
        // 初始化总权值
        long total = 0;
        // 读取每个点的数据并计算相关信息
        for (int i = 0; i < n; i++) {
            // 读取一行输入并分割
            String[] str = br.readLine().trim().split("\\s+");
            // 存储x坐标
            a[i][0] = Long.parseLong(str[0]);
            // 存储y坐标
            a[i][1] = Long.parseLong(str[1]);
            // 存储权值
            a[i][2] = Long.parseLong(str[2]);

            // 创建Point对象，计算点到原点的距离平方
            points[i] = new Point(a[i][0] * a[i][0] + a[i][1] * a[i][1], a[i][2]);

            // 累加总权值
            total += a[i][2];

        }

        // 如果总权值小于所需权值S，输出-1并返回
        if (total < S) {
            out.println("-1");
            out.flush();
            return;
        }

        // 对points数组进行排序，使用Lambda表达式作为比较器，按照d2属性值升序排序
        Arrays.sort(points, (x1, x2) -> Long.compare(x1.d2, x2.d2));

        // 创建前缀和数组preSum，长度为n
        long[] preSum = new long[n];
        // 初始化前缀和数组的第一个元素为points[0]的v值
        preSum[0] = points[0].v;
        // 计算前缀和数组，preSum[i]存储从points[0]到points[i]的v值之和
        for (int i = 1; i < n; i++) {
            preSum[i] = preSum[i - 1] + points[i].v;
        }

        // 初始化二分查找的边界，low为0，high为n-1
        int low = 0, high = n - 1;

        // 初始化index为n-1，用于存储满足条件的最小索引
        int index = n - 1;

        // 使用二分查找算法找到满足preSum[mid] >= S的最小mid值
        while (low <= high) {
            // 计算中间位置，使用位运算防止溢出
            int mid = low + ((high - low) >> 1);
            // 如果当前前缀和大于等于S，则更新index并向左查找更小的值
            if (preSum[mid] >= S) {
                index = mid;
                high = mid - 1;
            } else {
                // 否则向右查找
                low = mid + 1;
            }
        }

        // 输出满足条件的点的d2值的平方根
        out.println(Math.sqrt(points[index].d2));
        // 刷新输出流
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

【二分】BISHI85 【模板】整数域二分

Sun, 01 Mar 2026 21:36:42 +0000

思路

求解代码


    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");

        // 解析数组长度n和查询次数q
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);
        // 创建数组a并读取输入数据
        int[] a = new int[n];
        String[] strB = br.readLine().trim().split("\\s+");
        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(strB[i]);
        }

        // 对数组进行排序，为后续查询做准备
        Arrays.sort(a);
        // 处理q次查询
        while (q-- > 0) {
            // 读取每次查询的左右边界
            String[] strC = br.readLine().trim().split("\\s+");

            int l = Integer.parseInt(strC[0]);
            int r = Integer.parseInt(strC[1]);

            // 使用二分查找计算下界和上界
            int left = lowerBound(a, l);
            int right = upperBound(a, r);

            // 输出结果：范围内的元素个数
            out.println(right - left);

        }

        // 关闭IO资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 二分查找下界函数
     *
     * @param a      已排序的数组
     * @param target 目标值
     * @return 第一个大于等于target的元素的索引
     */
    private static int lowerBound(int[] a, int target) {
        // 初始化查找范围的 low 和 high 指针
        // low 从数组的起始位置 0 开始
        // high 从数组长度开始（不包括该位置）
        int low = 0, high = a.length;

        // 当 low 小于 high 时，继续查找
        // 这是循环查找的条件，确保查找范围有效
        while (low < high) {
            // 计算中间位置 mid
            // 使用位运算 (high-low)>>1 代替除法 2，提高效率
            // 防止整数溢出，同时确保 mid 总是在 low 和 high 之间
            int mid = low + ((high - low) >> 1);

            // 如果中间位置的元素大于等于目标值
            // 说明目标值可能在左半部分，或者 mid 就是我们要找的位置
            // 因此将 high 设置为 mid，继续在左半部分查找
            if (a[mid] >= target) {
                high = mid;
            } else {
                // 如果中间位置的元素小于目标值
                // 说明目标值一定在右半部分
                // 因此将 low 设置为 mid+1，继续在右半部分查找
                low = mid + 1;
            }

        }
        // 当循环结束时，low 指向第一个大于等于 target 的元素的位置
        // 如果所有元素都小于 target，则返回数组长度
        return low;
    }

    /**
     * 二分查找上界函数
     *
     * @param a      已排序的数组
     * @param target 目标值
     * @return 第一个大于target的元素的索引
     */
    private static int upperBound(int[] a, int target) {
        // 初始化查找范围的左右边界，左边界为0，右边界为数组长度
        int low = 0, high = a.length;

        // 当左边界小于右边界时，继续查找
        while (low < high) {
            // 计算中间位置，使用位运算防止溢出
            int mid = low + ((high - low) >> 1);

            // 如果中间位置的值大于目标值，则上界在左半部分
            if (a[mid] > target) {
                high = mid;
            } else {
                // 否则上界在右半部分，且不包括中间位置
                low = mid + 1;
            }

        }
        // 返回第一个大于target的元素的索引
        return low;
    }

【BFS】BISHI84 时津风的资源收集

Sun, 01 Mar 2026 20:38:54 +0000

思路

求解代码

// 定义一个静态数组dist，用于存储从数字10到其他数字的最小步数
    private static int[] dist = new int[301];

    public static void main(String[] args)throws IOException{
        // 调用bfs方法计算最小步数
        bfs();
        // 初始化输入输出流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- >0){
            // 读取一行输入并分割成字符串数组
            String[] str = br.readLine().trim().split("\\s+");
            // 将字符串数组转换为四个整数
            int a = Integer.parseInt(str[0]);
            int b = Integer.parseInt(str[1]);
            int c = Integer.parseInt(str[2]);
            int d = Integer.parseInt(str[3]);

            // 计算四个数字的最小步数之和
            int ans = dist[a]+dist[b]+dist[c]+dist[d];
            // 输出结果
            out.println(ans);
        }
        // 刷新并关闭输出流
        out.flush();
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 使用BFS算法计算从数字10到其他数字的最小步数
     * 可以进行的操作包括：+1, -1, +10, -10, +100, -100
     * 特殊情况：可以直接跳到数字10或300
     */
    private static void bfs(){
        // 初始化dist数组，-1表示未访问
        Arrays.fill(dist,-1);
        // 创建队列用于BFS遍历
        Queue<Integer> queue = new LinkedList<>();

        // 设置起点数字10的步数为0
        dist[10]=0;
        // 将起点加入队列
        queue.add(10);
        // 定义可能的操作数组
        int[] ops = {1,-1,10,-10,100,-100};

        // 当队列不为空时继续遍历
        while (!queue.isEmpty()){
            // 取出队首元素
            int u = queue.poll();

            // 创建邻居列表
            List<Integer> neighbors = new ArrayList<>();

            // 应用所有可能的操作生成邻居
            for(int op:ops){
                neighbors.add(u+op);
            }

            // 添加特殊邻居：10和300
            neighbors.add(10);
            neighbors.add(300);

            // 遍历所有邻居
            for(int v:neighbors){
                // 如果邻居在有效范围内且未被访问过
                if(v>=10&&v<=300&&dist[v]==-1){
                    // 更新步数
                    dist[v]=dist[u]+1;
                    // 将邻居加入队列
                    queue.add(v);
                }
            }
        }
    }

【回溯】BISHI83 迷宫问题

Sat, 28 Feb 2026 22:45:36 +0000

思路

求解代码

private static List<int[]> path = new ArrayList<>();

    /**
     * 主方法，处理输入输出并调用回溯算法
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {
        // 创建输入输出缓冲流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割并转换为高度h和宽度w
        String[] strA = br.readLine().trim().split("\\s+");

        // 解析网格的高度和宽度
        int h = Integer.parseInt(strA[0]);
        int w = Integer.parseInt(strA[1]);

        // 创建网格数组和访问标记数组
        int[][] grid = new int[h][w];
        boolean[][] visited = new boolean[h][w];

        // 读取网格数据
        for (int i = 0; i < h; i++) {
            // 读取一行输入并分割
            String[] str = br.readLine().trim().split("\\s+");
            // 填充网格数据
            for (int j = 0; j < w; j++) {
                grid[i][j] = Integer.parseInt(str[j]);
            }
        }

        // 从起点(0,0)开始回溯
        backtrack(grid, h, w, 0, 0, visited);

        // 输出路径
        for (int[] pos : path) {
            out.println("(" + pos[0] + "," + pos[1] + ")");
        }

        // 刷新并关闭输出流和输入流
        out.flush();
        out.close();
        br.close();

    }

    /**
     * 使用回溯算法在网格中寻找路径
     *
     * @return 如果找到从起点到终点的路径则返回true，否则返回false
     */
    private static boolean backtrack(int[][] grid, int h, int w, int i, int j, boolean[][] visted) {
        // 检查当前位置是否有效：是否在网格范围内、是否是障碍物、是否已经访问过
        if (i < 0 || i >= h || j < 0 || j >= w || grid[i][j] == 1 || visted[i][j]) {
            return false;
        }

        // 标记当前位置为已访问，并将当前位置添加到路径中
        visted[i][j] = true;
        path.add(new int[]{i, j});

        // 如果当前位置是终点，则返回true
        if (i == h - 1 && j == w - 1) {
            return true;
        }

        // 定义四个方向：上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // 尝试向四个方向移动
        for (int k = 0; k < 4; k++) {
            // 递归调用backtrack方法，如果找到路径则返回true
            if (backtrack(grid, h, w, i + dx[k], j + dy[k], visted)) {
                return true;
            }
        }

        // 如果四个方向都无法继续前进，则回溯：从路径中移除当前位置
        path.remove(path.size() - 1);
        return false;
    }

【BFS】BISHI82 没挡住洪水

Sat, 28 Feb 2026 21:17:35 +0000

思路

求解代码


    /**
     * 主方法：处理吴铭市地图数据并统计被完全淹没的区域数量
     *
     * 业务逻辑：
     * 1. 读取 N*N 的城市地图。
     * 2. 通过遍历寻找每一个独立的“空地区域”（由 '#' 组成的四连通块）。
     * 3. 对每个区域进行洪水上涨模拟判定。
     *
     * @param args 命令行参数
     * @throws IOException IO异常处理
     */
    public static void main(String[] args) throws IOException {
        // 使用高效流读取地图数据与输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取地图尺寸 N
        int N = Integer.parseInt(br.readLine().trim());
        // grid: 地图矩阵，'.' 为已淹没，'#' 为空地
        char[][] grid = new char[N][N];
        // visit: 标记当前空地是否已被抗灾委员会统计过
        boolean[][] visit = new boolean[N][N];

        // 加载吴铭市当前受灾地图
        for (int i = 0; i < N; i++) {
            grid[i] = br.readLine().trim().toCharArray();
        }

        // ans: 记录洪水上涨一天后，完全消失的空地区域总数
        int ans = 0;

        // 逐格扫描地图
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // 发现一块新的且未统计过的空地区域
                if (grid[i][j] == '#' && !visit[i][j]) {
                    /**
                     * 执行 BFS 模拟：
                     * 若该区域内所有格子在明天都会被淹没（即 bfs 返回 false），
                     * 则该区域属于“完全淹没区域”，计数加一。
                     */
                    if (!bfs(grid, N, i, j, visit)) {
                        ans++;
                    }
                }
            }
        }

        // 输出统计结果并释放资源
        out.println(ans);
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用广度优先搜索 (BFS) 判定一个空地区域在洪水上涨后是否能“存活”
     *
     * 判定核心：
     * 一个区域能存活，当且仅当该区域内【至少有一个】格子是安全的。
     * 安全格子的定义：其上下左右四个相邻方向全部都是空地 '#'，洪水无法直接上涨淹没它。
     *
     * @param grid  城市地图矩阵
     * @param N     地图尺寸
     * @param i     区域起始点行坐标
     * @param j     区域起始点列坐标
     * @param visit 访问标记数组
     * @return 如果该区域上涨后仍有残留（不完全消失）返回 true，否则返回 false
     */
    private static boolean bfs(char[][] grid, int N, int i, int j, boolean[][] visit) {
        Queue<int[]> queue = new LinkedList<>();
        // 将当前区域的起点加入队列并标记
        queue.add(new int[]{i, j});
        visit[i][j] = true;

        // areaSurvived: 标识整个区域是否能存活（只要有一个格子不被淹，即为 true）
        boolean areaSurvived = false;

        // 四联通方向向量
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0];
            int y = cur[1];

            // flag: 检查当前格子 (x, y) 是否为“避风港”
            // 默认假设它是安全的（四周无洪水 '.'）
            boolean flag = true;

            // 扫描当前格子的四周
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                // 如果邻居越界或者是洪水 '.'，则当前格子明早会被淹没
                if (nextX < 0 || nextX >= N || nextY < 0 || nextY >= N || grid[nextX][nextY] == '.') {
                    flag = false;
                    break;
                }
            }

            // 如果发现当前格子四周都是空地，它将保证该区域不被完全淹没
            if (flag) {
                areaSurvived = true;
            }

            // 继续探索该区域的其他空地格子
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                // 确保在地图范围内，且是同一区域的未访问空地
                if (nextX >= 0 && nextX < N && nextY >= 0 && nextY < N && grid[nextX][nextY] == '#' && !visit[nextX][nextY]) {
                    visit[nextX][nextY] = true;
                    queue.add(new int[]{nextX, nextY});
                }
            }
        }

        // 返回该区域是否完全消失
        return areaSurvived;
    }

【BFS】BISHI81 剪纸游戏

Fri, 27 Feb 2026 21:15:34 +0000

思路

求解代码

/**
     * 主方法，用于读取输入数据并处理网格问题
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 使用PrintWriter输出结果
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入并分割成字符串数组
        String[] str = br.readLine().trim().split("\\s+");
        // 解析网格的行数n
        int n = Integer.parseInt(str[0]);
        // 解析网格的列数m
        int m = Integer.parseInt(str[1]);

        // 创建n行m列的字符网格
        char[][] grid = new char[n][m];

        // 逐行读取网格数据
        for (int i = 0; i < n; i++) {
            // 将每行字符串转换为字符数组存入网格
            grid[i] = br.readLine().toCharArray();
        }

        // 创建n行m列的访问标记数组，初始值都为false
        boolean[][] visit = new boolean[n][m];
        // 初始化答案计数器
        int ans = 0;

        // 遍历网格的每个单元格
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前单元格是'.'且未被访问过
                if (grid[i][j] == '.' && !visit[i][j]) {
                    // 使用BFS方法处理，如果返回true则增加答案计数
                    if (bfs(grid, n, m, i, j, visit)) {
                        ans++;
                    }

                }
            }
        }
        // 输出最终结果
        out.println(ans);
        // 刷新输出流
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();

    }


    /**
     * 使用广度优先搜索(BFS)算法遍历连通区域，并判断该连通区域是否为矩形
     *
     * @param grid  二维字符网格，其中'.'表示可走区域
     * @param n     网格的行数
     * @param m     网格的列数
     * @param i     起始点的行坐标
     * @param j     起始点的列坐标
     * @param visit 记录访问状态的二维数组
     * @return 如果连通区域是完整的矩形则返回true，否则返回false
     */
    private static boolean bfs(char[][] grid, int n, int m, int i, int j, boolean[][] visit) {
        // 使用队列进行BFS遍历
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i, j});
        visit[i][j] = true;  // 标记起始点为已访问

        // 记录连通区域的最小和最大x、y坐标
        int minX = i, maxX = i;
        int minY = j, maxY = j;

        // 记录连通区域中点的数量
        int count = 0;

        // 定义四个方向的偏移量：上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // BFS遍历连通区域
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();  // 取出队列中的当前点
            int x = cur[0];
            int y = cur[1];

            count++;  // 增加连通区域点计数

            // 更新连通区域的边界
            minX = Math.min(minX, x);
            maxX = Math.max(maxX, x);
            minY = Math.min(minY, y);
            maxY = Math.max(maxY, y);

            // 遍历四个方向
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && grid[nextX][nextY] == '.' && !visit[nextX][nextY]) {
                    visit[nextX][nextY] = true;
                    queue.add(new int[]{nextX, nextY});
                }
            }

        }

        // 判断是否填满整个区域
        // 当count等于整个区域的格子数量时，返回true，表示已填满
        // 整个区域的格子数量计算公式为：(maxX-minX+1) * (maxY-minY+1)
        return count == (maxX - minX + 1) * (maxY - minY + 1);
    }

【BFS-方向数组】BISHI80 走迷宫-方向数组

Fri, 27 Feb 2026 20:18:34 +0000

思路

求解代码

 /**
     * 主方法，处理输入输出并调用BFS算法
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，使用PrintWriter输出
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割成字符串数组并解析为整数n和m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 行数
        int m = Integer.parseInt(strA[1]);  // 列数

        // 读取第二行输入，分割成字符串数组并解析为起点和终点的坐标
        String[] strB = br.readLine().trim().split("\\s+");
        int xs = Integer.parseInt(strB[0]) - 1;  // 起点x坐标（转换为0-based索引）
        int ys = Integer.parseInt(strB[1]) - 1;  // 起点y坐标（转换为0-based索引）
        int xt = Integer.parseInt(strB[2]) - 1;  // 终点x坐标（转换为0-based索引）
        int yt = Integer.parseInt(strB[3]) - 1;  // 终点y坐标（转换为0-based索引）

        // 读取n行输入，构建二维字符数组grid表示地图
        char[][] grid = new char[n][m];
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim().toCharArray();
        }


        // 调用BFS方法计算最短路径长度，并将结果输出
        out.println(bfs(grid, n, m, xs, ys, xt, yt));
        // 刷新输出流，确保所有内容都被写出
        out.flush();
        // 关闭输出流和输入流
        out.close();
        br.close();

    }

    /**
     * 使用广度优先搜索(BFS)算法计算从起点到终点的最短路径
     *
     * @param grid 二维字符数组，表示网格地图，'.'表示可走的路径
     * @param n    网格的行数
     * @param m    网格的列数
     * @param xs   起点的x坐标
     * @param ys   起点的y坐标
     * @param xt   终点的x坐标
     * @param yt   终点的y坐标
     * @return 从起点到终点的最短距离，如果无法到达则返回-1
     */
    private static int bfs(char[][] grid, int n, int m, int xs, int ys, int xt, int yt) {
        // 如果起点和终点相同，直接返回0
        if (xs == xt && ys == yt) {
            return 0;
        }

        // 初始化距离数组，-1表示未访问过
        int[][] distance = new int[n][m];
        for (int i = 0; i < n; i++) {
            Arrays.fill(distance[i], -1);
        }

        // 使用队列实现BFS，存储待访问的节点坐标
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{xs, ys});
        distance[xs][ys] = 0;  // 起点到自身的距离为0

        // 定义四个方向的偏移量，分别表示上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // BFS遍历
        while (!queue.isEmpty()) {
            // 取出队列中的当前节点
            int[] cur = queue.poll();

            int x = cur[0];
            int y = cur[1];

            // 遍历四个方向
            for (int i = 0; i < 4; i++) {
                // 计算下一个节点的坐标
                int nextX = x + dx[i];
                int nextY = y + dy[i];

                // 检查下一个节点是否在网格范围内，且是可走的路径，且未被访问过
                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && grid[nextX][nextY] == '.' && distance[nextX][nextY] == -1) {
                    // 更新距离
                    distance[nextX][nextY] = distance[x][y] + 1;

                    // 如果到达终点，返回距离
                    if (nextX == xt && nextY == yt) {
                        return distance[nextX][nextY];
                    }

                    // 将下一个节点加入队列
                    queue.add(new int[]{nextX, nextY});
                }
            }
        }
        // 如果无法到达终点，返回-1
        return -1;
    }

BISHI79 取数游戏

Thu, 26 Feb 2026 21:45:07 +0000

思路

求解代码

private static int N, M;  // 网格的行数和列数
    private static int[][] grid;  // 存储网格数据的二维数组
    private static boolean[][] used;  // 标记网格位置是否被使用过的二维数组
    private static long ans;  // 存储最终答案的最大值

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter向标准输出写入数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));


        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            N = Integer.parseInt(str[0]);
            M = Integer.parseInt(str[1]);

            grid = new int[N][M];  // 初始化网格数组
            used = new boolean[N][M];  // 初始化使用标记数组
            ans = 0;  // 重置答案为0

            // 读取网格数据
            for (int j = 0; j < N; j++) {
                String[] gridStr = br.readLine().trim().split("\\s+");
                for (int k = 0; k < M; k++) {
                    grid[j][k] = Integer.parseInt(gridStr[k]);  // 将字符串转换为整数存入网格
                }
            }
            backtrack(0, 0);  // 从第一个位置开始回溯
            out.println(Math.max(ans, 0));  // 输出最大答案，至少为0
        }

        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();  // 关闭输入流


    }


    /**
     * 回溯算法方法，用于在网格中寻找最大可能值
     *
     * @param index  当前处理的位置索引，从0到N*M-1
     * @param curAns 当前累计的答案值
     */
    private static void backtrack(int index, long curAns) {
        // 基本情况：如果已经处理完所有网格位置
        if (index == N * M) {
            // 更新最大答案值
            ans = Math.max(ans, curAns);
            return;
        }

        // 计算当前索引对应的行和列
        int row = index / M;  // 计算当前行号
        int col = index % M;  // 计算当前列号

        // 情况1：不选择当前网格位置，直接处理下一个位置
        backtrack(index + 1, curAns);

        // 情况2：如果当前位置可以安全选择
        if (isSafe(row, col)) {
            // 标记当前位置为已使用
            used[row][col] = true;
            // 选择当前位置，累加其值并处理下一个位置
            backtrack(index + 1, curAns + grid[row][col]);
            // 回溯：撤销当前位置的使用标记
            used[row][col] = false;
        }
    }

    /**
     * 检查指定位置是否安全，即其周围8个方向（包括自身）是否都没有被使用过
     *
     * @param row 当前行索引
     * @param col 当前列索引
     * @return 如果周围8个方向都没有被使用过，返回true；否则返回false
     */
    private static boolean isSafe(int row, int col) {
        // 遍历当前位置的周围8个方向（包括自身）
        for (int drow = -1; drow <= 1; drow++) {
            for (int dcol = -1; dcol <= 1; dcol++) {
                // 计算下一个位置的行索引
                int nextRow = row + drow;
                // 计算下一个位置的列索引
                int nextCol = col + dcol;

                // 检查下一个位置是否在有效范围内
                if (nextRow >= 0 && nextRow < N && nextCol >= 0 && nextCol < M) {
                    // 如果下一个位置已经被使用过，则返回false
                    if (used[nextRow][nextCol]) {
                        return false;
                    }
                }

            }
        }
        // 如果周围8个方向都没有被使用过，则返回true
        return true;
    }

BISHI78 全排列

Thu, 26 Feb 2026 20:32:41 +0000

思路

【回溯】没有重复项数字的全排列这个是核心代码模式的题解。现在这题是ACM模式的题解。

求解代码

/**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter向标准输出写入数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取整数n，并去除可能的空白字符
        int n = Integer.parseInt(br.readLine().trim());

        // 初始化一个长度为n的数组，用于存储排列结果
        int[] track = new int[n];
        // 初始化一个长度为n+1的布尔数组，用于标记数字是否已被使用
        boolean[] used = new boolean[n + 1];

        // 调用回溯方法生成全排列
        backtrack(n, 0, track, used, out);
        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();


    }

    /**
     * 回溯法生成全排列
     *
     * @param n     排列的数字范围，1到n
     * @param depth 当前递归的深度，即已经确定的前几个数字的数量
     * @param track 当前排列的路径，存储已经确定的数字序列
     * @param used  标记数组，记录数字是否已经在当前排列中使用过
     * @param out   用于输出结果的打印流
     */
    private static void backtrack(int n, int depth, int[] track, boolean[] used, PrintWriter out) {
        // 如果当前深度等于n，说明已经生成了一个完整的排列
        if (depth == n) {
            // 输出当前排列
            for (int i = 0; i < n; i++) {
                // 如果是最后一个数字，直接输出，否则输出数字加空格
                out.print(track[i] + (i == n - 1 ? "" : " "));
            }
            // 换行，准备输出下一个排列
            out.println();
            // 返回上一层递归
            return;
        }

        // 遍历所有可能的数字
        for (int i = 1; i <= n; i++) {
            // 如果数字i还没有被使用过
            if (!used[i]) {
                // 标记数字i为已使用
                used[i] = true;
                // 将数字i放入当前深度的位置
                track[depth] = i;

                // 递归处理下一个位置
                backtrack(n, depth + 1, track, used, out);

                // 回溯，撤销选择，将数字i标记为未使用，以便尝试其他可能性
                used[i] = false;
            }
        }
    }

【DFS】BISHI77数水坑

Wed, 25 Feb 2026 22:45:37 +0000

思路

求解代码

 /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        int ans = 0;  // 用于记录找到的'W'的数量

        // 遍历网格中的每个元素
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前元素是'W'，则增加计数器并执行深度优先搜索
                if (gridStr[i][j] == 'W') {
                    ans++;  // 增加计数器
                    dfs(gridStr, i, j);  // 执行深度优先搜索，标记相邻的'W'
                }

            }
        }

        // 输出结果
        out.println(ans);

        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 深度优先搜索(DFS)方法，用于遍历网格中的连通区域
     *
     * @param grid 二维字符网格
     * @param i    当前处理的行坐标
     * @param j    当前处理的列坐标
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 如果当前格子是'.'，表示已经是访问过的格子，直接返回
        if (grid[i][j] == '.') {
            return;
        }

        // 将当前格子标记为已访问（用'.'表示）
        grid[i][j] = '.';

        // 遍历当前格子的8个相邻方向（包括对角线方向）
        for (int di = -1; di <= 1; di++) {
            for (int dj = -1; dj <= 1; dj++) {
                // 跳过当前格子本身
                if (di == 0 && dj == 0) {
                    continue;
                }
                // 递归处理相邻格子
                dfs(grid, i + di, j + dj);
            }
        }

    }

【DFS】BISHI76 迷宫寻路

Wed, 25 Feb 2026 21:45:53 +0000

思路

求解代码

private static String ans = "No";

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        // 从起点(0,0)开始深度优先搜索
        dfs(gridStr, 0, 0);
        // 输出结果
        out.println(ans);

        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 深度优先搜索（DFS）方法，用于在二维网格中寻找从起点到终点的路径
     *
     * @param grid 二维字符网格，包含可走的路径和障碍物
     * @param i    当前搜索的行索引
     * @param j    当前搜索的列索引
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 检查当前单元格是否是障碍物（已访问过的标记为'#'）
        if (grid[i][j] == '#') {
            return;
        }

        // 检查是否到达终点（右下角）
        if (i == grid.length - 1 && j == grid[0].length - 1) {
            ans = "Yes";  // 找到路径，设置答案为"Yes"
            return;
        }

        // 标记当前单元格为已访问（使用'#'作为标记）
        grid[i][j] = '#';
        // 向上搜索
        dfs(grid, i - 1, j);
        // 向下搜索
        dfs(grid, i + 1, j);
        // 向左搜索
        dfs(grid, i, j - 1);
        // 向右搜索
        dfs(grid, i, j + 1);
    }

开源必备：Git 仓库敏感日志文件清理与脱敏教程

Wed, 25 Feb 2026 19:45:42 +0000

在做个人项目的时候，有时为了开源需要对数据进行脱敏，尤其是一些log文件。

先确认代码里还有没有其他“XXX”？

执行这条精准排除命令：

`1`	`git grep -w "XXX" $(git rev-list --all) -- ":!*.log"`

如果没有输出，证明没有包含相关字符串的文件，如果有输出则需要进行如下操作，彻底删除文件的历史。

⚠️警告，以下操作会改写所有 Commit 的 Hash 值，必须强制推送！

1.在项目根目录执行清洗命令

1
2
3

git filter-branch --force --index-filter \
'git rm --cached --ignore-unmatch "*/hs_err_pid*.log"' \
--prune-empty --tag-name-filter cat -- --all

执行过程中终端会疯狂滚动 “Rewriting …”，耐心等待即可。

2. 清理 Git 内部备份

1
2
3

rm -rf .git/refs/original/
git reflog expire --expire=now --all
git gc --prune=now

3. 防止再次犯错，在 `.gitignore` 中永久屏蔽

1
2
3

# JVM 崩溃日志
hs_err_pid*.log
*.log

4.删除本地log文件，强制推送覆盖远程仓库

# 删除当前文件
git rm --force hs_err_pid*.log
git add .gitignore
git commit -m "chore: 删除误上传的JVM崩溃日志 + 屏蔽所有.log文件提交"
git push origin --force --all

5.验证是否彻底干净

`1`	`git grep -w "XXX" $(git rev-list --all)`

如果没有任何输出，则大功告成。

BISHI75 阶幂

Tue, 24 Feb 2026 21:40:06 +0000

如果 $a^b \ge m$，返回 $(a^b \bmod m) + m$；否则直接返回 $a^b$。

思路

代码实现

 private static long MOD = 1000000007;  // 定义模数常量，用于取模运算
    private static List<Long> mList = new ArrayList<>();  // 存储欧拉函数值的列表

    /**
     * 主方法，处理输入输出并计算结果
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入的长整型数值n
        long n = Long.parseLong(br.readLine().trim());

        // 初始化tmp为MOD值，并添加到mList列表中
        long tmp = MOD;
        mList.add(tmp);

        // 计算欧拉函数值直到tmp为1，并将结果添加到mList中
        while (tmp > 1) {
            tmp = getPhi(tmp);
            mList.add(tmp);
        }

        // 调用solve方法计算结果并输出，取模MOD
        out.println(solve(n, 0) % MOD);


        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 递归求解模幂运算的结果
     *
     * @param curN 当前处理的数字
     * @param idx  当前处理的mList中的索引位置
     * @return 返回模幂运算的结果
     */
    private static long solve(long curN, int idx) {
        // 获取当前索引对应的模数
        long m = mList.get(idx);
        // 如果模数为1，任何数对1取模结果都是1
        if (m == 1) {
            return 1;
        }

        // 如果当前数字为1，1的任何次幂都是1
        if (curN == 1) {
            return 1;
        }

        // 递归计算指数部分，curN-1和idx+1表示递归处理下一个数字和下一个模数
        long exp = solve(curN - 1, idx + 1);

        // 计算curN的exp次幂对m取模的结果
        return safePow(curN, exp, m);
    }

    /**
     * 安全的幂运算函数，计算 a^b mod m，并处理可能的溢出情况
     *
     * @param a 底数
     * @param b 指数
     * @param m 模数
     * @return 计算结果，如果发生溢出则返回结果加上模数后的值
     */
    private static long safePow(long a, long b, long m) {
        long res = 1;        // 初始化结果为1
        boolean overflow = false;  // 溢出标志，初始为false

        // 如果底数大于等于模数，进行取模操作，并标记可能溢出
        if (a >= m) {
            overflow = true;
            a %= m;
        }

        // 使用快速幂算法计算幂运算
        while (b > 0) {
            // 如果当前指数的二进制最低位为1（即指数为奇数）
            if ((b & 1) == 1) {
                res = res * a;   // 将当前底数乘入结果
                // 如果结果大于等于模数，进行取模操作，并标记可能溢出
                if (res >= m) {
                    overflow = true;
                    res %= m;
                }
            }

            b >>= 1;   // 指数右移一位，相当于除以2
            // 如果指数还有剩余位
            if (b > 0) {
                a = a * a;   // 底数平方
                // 如果平方后的底数大于等于模数，进行取模操作，并标记可能溢出
                if (a >= m) {
                    overflow = true;
                    a %= m;
                }
            }
        }
        // 根据溢出标志返回结果，如果溢出则加上模数
        return overflow ? (res + m) : res;
    }

    /**
     * 计算欧拉函数Phi(n)的值
     * 欧拉函数Phi(n)表示小于n的正整数中与n互质的数的个数
     *
     * @param n 需要计算欧拉函数的正整数
     * @return 返回n的欧拉函数值
     */
    private static long getPhi(long n) {
        long res = n;  // 初始化结果为n

        // 遍历2到sqrt(n)的所有整数
        for (long i = 2; i * i <= n; i++) {
            // 如果i是n的因数
            if (n % i == 0) {
                // 应用欧拉函数的公式：res = res * (1 - 1/p)
                res = res / i * (i - 1);
                // 去除n中所有的i因子
                while (n % i == 0) {
                    n /= i;
                }
            }
        }

        // 如果n大于1，说明n本身是一个质数
        if (n > 1) {
            res = res / n * (n - 1);
        }
        return res;
    }

BISHI74 【模板】非质模数下的乘法逆元

Tue, 24 Feb 2026 20:34:31 +0000

乘法逆元 $a^{-1} \equiv x \pmod m$ 等价于求解线性同余方程：

$ax \equiv 1 \pmod m \implies ax + my = 1$

根据裴蜀定理，该方程有解的充要条件是 $\gcd(a, m) = 1$。
扩展欧几里得算法可以在计算 $\gcd(a, m)$ 的同时，求出一组整数 $(x, y)$ 满足 $ax + my = \gcd(a, m)$。

思路

实现代码

    private static long x;
    private static long y;

    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {

            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long m = Long.parseLong(str[1]);

            exgcd(a, m);
            long ans = (x % m + m) % m;
            out.println(ans);
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }


    /**
     * 扩展欧几里得算法，用于求解形如 ax + by = gcd(a,b) 的方程
     * 同时返回最大公约数和x、y的值
     *
     * @param a 第一个参数
     * @param b 第二个参数
     * @return a和b的最大公约数
     */
    private static long exgcd(long a, long b) {

        // 当b为0时，递归结束，此时a就是最大公约数
        if (b == 0) {
            x = 1;    // x初始化为1
            y = 0;    // y初始化为0
            return a;
        }

        // 递归调用，计算b和a mod b的最大公约数
        long d = exgcd(b, a % b);
        // 通过递归结果更新x和y的值
        long tmp = x;
        x = y;
        y = tmp - (a / b) * y;

        // 返回最大公约数
        return d;
    }

BISHI73 【模板】欧拉函数计算Ⅰ ‖ 朴素求值：试除法

Mon, 23 Feb 2026 21:59:20 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            long x = Long.parseLong(br.readLine().trim());
            out.println(euler(x));  // 输出当前测试用例的结果
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }


    /**
     * 使用欧拉函数计算小于等于x的正整数中与x互质的数的个数
     * 欧拉函数公式：φ(n) = n * (1 - 1/p1) * (1 - 1/p2) * ... * (1 - 1/pk)
     * 其中p1, p2, ..., pk是n的质因数
     *
     * @param x 需要计算欧拉函数的正整数
     * @return 小于等于x的正整数中与x互质的数的个数
     */
    private static long euler(long x) {
        // 如果x为1，直接返回1，因为1与1互质
        if (x == 1) {
            return 1;
        }
        // 初始化结果为x
        long res = x;
        // 遍历从2到√x的所有数，寻找x的质因数
        for (long i = 2; i * i <= x; i++) {
            // 如果i是x的因数
            if (x % i == 0) {
                // 应用欧拉函数公式，乘以(1-1/i)
                res = res / i * (i - 1);

                // 去除x中所有的i因子
                while (x % i == 0) {
                    x /= i;
                }
            }
        }
        // 如果x大于1，说明x本身是一个质数，应用欧拉函数公式
        if (x > 1) {
            res = res / x * (x - 1);
        }

        return res;
    }

BISHI72 中位数之和

Mon, 23 Feb 2026 21:10:27 +0000

由于数组 $a$ 仅包含 $0$ 和 $1$，对于长度为奇数 $k$ 的子序列，其中位数是 $1$ 的充要条件是：子序列中 $1$ 的个数不少于 $\frac{k+1}{2}$。

因此，求“中位数之和”等价于求“中位数为 $1$的子序列个数”。

思路

代码实现

   // 定义模数常量，用于所有取模运算
    private static final int MOD = 1000000007;
    // 定义最大计算范围常量
    private static final int MAX_N = 1000001;
    // 存储阶乘值的数组
    private static long[] fact = new long[MAX_N];
    // 存储阶乘逆元的数组
    private static long[] invFact = new long[MAX_N];


    /**
     * 主方法，处理输入输出并计算组合数学问题
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 预计算阶乘和逆元，为后续计算做准备
        precompute();

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            // 读取每行输入并分割，获取n和k的值
            String[] str = br.readLine().split("\\s+");
            int n = Integer.parseInt(str[0]);  // 总数
            int k = Integer.parseInt(str[1]);  // 选择数

            // 统计输入中"1"的数量
            int c1 = 0;
            String[] strA = br.readLine().split("\\s+");
            for (int j = 0; j < n; j++) {
                if (strA[j].equals("1")) {
                    c1++;  // 统计"1"的个数
                }
            }
            int c0 = n - c1;  // 计算"0"的个数

            // 计算至少需要选择的"1"的数量
            int m = (k + 1) / 2;
            long ans = 0;
            // 遍历所有可能的"1"的选择数量
            for (int j = m; j <= Math.min(k, c1); j++) {
                // 检查剩余的选择数是否不超过"0"的数量
                if (k - j <= c0) {
                    // 计算组合数并累加结果
                    long res = (nCr(c1, j) * nCr(c0, k - j)) % MOD;
                    ans = (ans + res) % MOD;
                }
            }
            out.println(ans);  // 输出当前测试用例的结果
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用快速幂算法计算base的exp次方对MOD取模的结果
     * 快速幂算法是一种高效计算幂运算的算法，时间复杂度为O(log n)
     *
     * @param base 底数
     * @param exp  指数
     * @return base的exp次方对MOD取模的结果
     */
    private static long mypower(long base, long exp) {

        // 初始化结果为1对MOD取模，防止MOD为1时结果错误
        long ans = 1 % MOD;
        // 当指数exp大于0时继续循环
        while (exp > 0) {

            // 如果当前指数是奇数，将base乘入结果
            if (exp % 2 == 1) {
                ans = (ans * base) % MOD;
            }

            // base平方，指数减半
            base = (base * base) % MOD;
            exp /= 2;
        }

        // 返回最终结果
        return ans;
    }

    /**
     * 预计算阶乘和阶乘的逆元数组
     * 使用动态规划方法计算阶乘数组fact[]
     * 使用费马小定理计算逆元数组invFact[]
     */
    private static void precompute() {
        // 初始化0的阶乘和0的阶乘逆元为1
        fact[0] = 1;
        invFact[0] = 1;
        // 动态规划计算阶乘数组
        for (int i = 1; i < MAX_N; i++) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        // 使用费马小定理计算最大阶乘的逆元
        invFact[MAX_N - 1] = mypower(fact[MAX_N - 1], MOD - 2);

        // 逆向递推计算其他阶乘的逆元
        for (int i = MAX_N - 2; i >= 1; i--) {
            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
        }
    }

    /**
     * 计算组合数 nCr，即从n个物品中选取r个物品的组合数
     * 使用预计算阶乘和阶乘逆元的方法来高效计算组合数
     *
     * @param n 总物品数
     * @param r 选取物品数
     * @return 组合数结果，对MOD取模
     */
    private static long nCr(int n, int r) {
        // 如果r小于0或大于n，组合数为0
        if (r < 0 || r > n) {
            return 0;
        }

        // 使用公式 nCr = n! / (r! * (n-r)!) 计算
        // 通过预计算的阶乘数组fact和阶乘逆元数组invFact来计算
        // 并对MOD取模，防止数值溢出
        return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
    }

BISHI71 人员分组问题

Sun, 22 Feb 2026 23:25:15 +0000

思路

这题就是个组合问题，本质上是求C(n,5)+C(n,6)+C(n,7)的问题。

求解代码

// 定义模数常量，用于所有取模运算
    private static final int MOD = 1000000007;
    // 定义最大计算范围常量
    private static final int MAX_N = 1000001;
    // 存储阶乘值的数组
    private static long[] fact = new long[MAX_N];
    // 存储阶乘逆元的数组
    private static long[] invFact = new long[MAX_N];


    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 预计算阶乘和逆元
        precompute();

        int n = Integer.parseInt(br.readLine().trim());
        long ans = (nCr(n, 5) + nCr(n, 6) + nCr(n, 7))%MOD;
        out.println(ans);

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用快速幂算法计算base的exp次方对MOD取模的结果
     * 快速幂算法是一种高效计算幂运算的算法，时间复杂度为O(log n)
     *
     * @param base 底数
     * @param exp  指数
     * @return base的exp次方对MOD取模的结果
     */
    private static long mypower(long base, long exp) {

        // 初始化结果为1对MOD取模，防止MOD为1时结果错误
        long ans = 1 % MOD;
        // 当指数exp大于0时继续循环
        while (exp > 0) {

            // 如果当前指数是奇数，将base乘入结果
            if (exp % 2 == 1) {
                ans = (ans * base) % MOD;
            }

            // base平方，指数减半
            base = (base * base) % MOD;
            exp /= 2;
        }

        // 返回最终结果
        return ans;
    }

    /**
     * 预计算阶乘和阶乘的逆元数组
     * 使用动态规划方法计算阶乘数组fact[]
     * 使用费马小定理计算逆元数组invFact[]
     */
    private static void precompute() {
        // 初始化0的阶乘和0的阶乘逆元为1
        fact[0] = 1;
        invFact[0] = 1;
        // 动态规划计算阶乘数组
        for (int i = 1; i < MAX_N; i++) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        // 使用费马小定理计算最大阶乘的逆元
        invFact[MAX_N - 1] = mypower(fact[MAX_N - 1], MOD - 2);

        // 逆向递推计算其他阶乘的逆元
        for (int i = MAX_N - 2; i >= 1; i--) {
            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
        }
    }

    /**
     * 计算组合数 nCr，即从n个物品中选取r个物品的组合数
     * 使用预计算阶乘和阶乘逆元的方法来高效计算组合数
     *
     * @param n 总物品数
     * @param r 选取物品数
     * @return 组合数结果，对MOD取模
     */
    private static long nCr(int n, int r) {
        // 如果r小于0或大于n，组合数为0
        if (r < 0 || r > n) {
            return 0;
        }

        // 使用公式 nCr = n! / (r! * (n-r)!) 计算
        // 通过预计算的阶乘数组fact和阶乘逆元数组invFact来计算
        // 并对MOD取模，防止数值溢出
        return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
    }

BISHI70 【模板】组合数

Sun, 22 Feb 2026 21:40:22 +0000

思路

求解代码

// 定义模数常量，用于所有取模运算
    private static final int MOD = 1000000007;
    // 定义最大计算范围常量
    private static final int MAX_N = 500001;
    // 存储阶乘值的数组
    private static long[] fact = new long[MAX_N];
    // 存储阶乘逆元的数组
    private static long[] invFact = new long[MAX_N];

    /**
     * 主方法
     * 处理输入输出，调用预计算和组合数计算方法
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 预计算阶乘和逆元
        precompute();
        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            // 读取每行输入并分割
            String[] str = br.readLine().split("\\s+");
            int n = Integer.parseInt(str[0]);
            int m = Integer.parseInt(str[1]);

            // 输出组合数计算结果
            out.println(nCr(m, n));
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用快速幂算法计算base的exp次方对MOD取模的结果
     * 快速幂算法是一种高效计算幂运算的算法，时间复杂度为O(log n)
     *
     * @param base 底数
     * @param exp  指数
     * @return base的exp次方对MOD取模的结果
     */
    private static long mypower(long base, long exp) {

        // 初始化结果为1对MOD取模，防止MOD为1时结果错误
        long ans = 1 % MOD;
        // 当指数exp大于0时继续循环
        while (exp > 0) {

            // 如果当前指数是奇数，将base乘入结果
            if (exp % 2 == 1) {
                ans = (ans * base) % MOD;
            }

            // base平方，指数减半
            base = (base * base) % MOD;
            exp /= 2;
        }

        // 返回最终结果
        return ans;
    }

    /**
     * 预计算阶乘和阶乘的逆元数组
     * 使用动态规划方法计算阶乘数组fact[]
     * 使用费马小定理计算逆元数组invFact[]
     */
    private static void precompute() {
        // 初始化0的阶乘和0的阶乘逆元为1
        fact[0] = 1;
        invFact[0] = 1;
        // 动态规划计算阶乘数组
        for (int i = 1; i < MAX_N; i++) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        // 使用费马小定理计算最大阶乘的逆元
        invFact[MAX_N - 1] = mypower(fact[MAX_N - 1], MOD - 2);

        // 逆向递推计算其他阶乘的逆元
        for (int i = MAX_N - 2; i >= 1; i--) {
            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
        }
    }

    /**
     * 计算组合数 nCr，即从n个物品中选取r个物品的组合数
     * 使用预计算阶乘和阶乘逆元的方法来高效计算组合数
     *
     * @param n 总物品数
     * @param r 选取物品数
     * @return 组合数结果，对MOD取模
     */
    private static long nCr(int n, int r) {
        // 如果r小于0或大于n，组合数为0
        if (r < 0 || r > n) {
            return 0;
        }

        // 使用公式 nCr = n! / (r! * (n-r)!) 计算
        // 通过预计算的阶乘数组fact和阶乘逆元数组invFact来计算
        // 并对MOD取模，防止数值溢出
        return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
    }

BISHI69 [HNOI2008]越狱

Sun, 22 Feb 2026 00:00:54 +0000

这个问题可以通过计算“总方案数”减去“不越狱方案数”来得出结果。

总分配方案数：每个房间有 $M$ 种宗教选择，共有 $N$ 个房间。总数 = $M \times M \times \dots \times M = M^N$。

不越狱方案数: 第 1 个房间有 $M$ 种选择；第 2 个房间为了不与第 1 个重复，有 $M-1$ 种选择；第 3 个房间为了不与第 2 个重复，有 $M-1$ 种选择；以此类推，剩下的 $N-1$ 个房间每个都有 $M-1$ 种选择。不越狱总数 = $M \times (M-1)^{N-1}$。

可能发生越狱的方案数：越狱方案 = 总方案数 - 不越狱方案数 结果 = $M^N - M \times (M-1)^{N-1}$

流程图

代码实现

 private static final long MOD = 100003L;

    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String[] str = br.readLine().split("\\s+");
        long M = Long.parseLong(str[0]);
        long N = Long.parseLong(str[1]);
        long total = mypower(M, N, MOD);
        long safe = M * mypower(M - 1, N - 1, MOD)%MOD;
        long ans = (total-safe+MOD)%MOD;

        out.println(ans);

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI68 刷题统计

Sat, 21 Feb 2026 23:32:54 +0000

这是一个经典的容斥原理应用题。

设三个集合分别为 $A$（新手）、$B$（算法入门）、$C$（算法进阶）。

已知 $n = |A \cup B \cup C|$ （至少刷过一个的总人数） $a = |A|, b = |B|, c = |C|$ （各题单人数） $d$: 恰好刷过两个题单的人数。设 $x$: 同时刷过三个题单的人数（我们要找的解）。

根据容斥原理：
$$|A \cup B \cup C| = |A| + |B| + |C| - (|A \cap B| + |A \cap C| + |B \cap C|) + |A \cap B \cap C|$$
其中，任意两个集合的交集（如 $|A \cap B|$）包含了“恰好刷过两个”的人和“刷过全部三个”的人。因此：$|A \cap B| + |A \cap C| + |B \cap C| = d + 3x$（因为 $x$ 这部分人在三个两两交集中各被算了一次）。

代入公式：
$$n = a + b + c - (d + 3x) + x$$

$$n = a + b + c - d - 2x$$
得出 $x$：
$$2x = a + b + c - n - d$$

$$x = \frac{a + b + c - n - d}{2}$$

流程图

代码实现

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            long n = Long.parseLong(str[0]);
            long a = Long.parseLong(str[1]);
            long b = Long.parseLong(str[2]);
            long c = Long.parseLong(str[3]);
            long d = Long.parseLong(str[4]);
            long ans = (a+b+c-n-d)/2;

            out.println(ans);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI67 穿搭大挑战

Sat, 21 Feb 2026 23:03:31 +0000

思路

###求解代码

 public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);
            long c = Long.parseLong(str[2]);
            long ans = a*b+a*c+b*c;

            out.println(ans);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI66 子数列求积

Sat, 21 Feb 2026 22:12:44 +0000

思路

求解代码

private static final int MOD = 1000000007;

    /**
     * 主函数，处理输入输出并计算区间乘积
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割字符串并解析为整数n和q
        String[] str = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(str[0]);  // 数组长度
        int q = Integer.parseInt(str[1]);  // 查询次数


        // 创建前缀积数组，大小为n+1
        long[] preProduct = new long[n + 1];
        preProduct[0] = 1;  // 初始化前缀积的第一个元素为1
        // 读取数组元素并计算前缀积
        String[] numStr = br.readLine().trim().split("\\s+");
        for (int i = 1; i <= n; i++) {
            long val = Long.parseLong(numStr[i - 1]);  // 解析当前元素
            // 计算前缀积，并对MOD取模
            preProduct[i] = (preProduct[i - 1] * val) % MOD;
        }

        // 创建结果列表
        List<Long> res = new ArrayList<>();
        // 处理每个查询
        for (int i = 0; i < q; i++) {
            // 读取查询区间
            String[] strQ = br.readLine().split("\\s+");
            int l = Integer.parseInt(strQ[0]);  // 区间左端点
            int r = Integer.parseInt(strQ[1]);  // 区间右端点

            // 计算preProduct[l-1]的模逆元
            long invPreProduct = mypower(preProduct[l - 1], MOD - 2, MOD);
            // 计算区间[l,r]的乘积
            long ans = (preProduct[r] * invPreProduct) % MOD;
            res.add(ans);  // 将结果添加到列表中
        }

        // 使用StringBuilder构建输出字符串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.size(); i++) {
            // 每个结果用空格分隔，最后一个结果后不加空格
            sb.append(res.get(i)).append(res.size() == n - 1 ? "" : " ");
        }


        // 输出结果并关闭流
        out.println(sb.toString());
        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI65 【模板】分数取模

Sat, 21 Feb 2026 00:37:41 +0000

思路

求解代码

private static final int MOD = 1000000007;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < t; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);

            long bInv= mypower(b, MOD-2, MOD);
            long ans = (a%MOD+MOD)%MOD;
            ans = (ans*bInv)%MOD;

            out.println(ans);
        }

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI64 【模板】快速幂Ⅰ ‖ 模小整数

Fri, 20 Feb 2026 22:22:19 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);
            long m = Long.parseLong(str[2]);

            out.println(mypower(a, b, m));
        }

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

Windows 环境下 OpenClaw 的安装与千问大模型配置

Fri, 20 Feb 2026 16:53:53 +0000

为了不占用 C 盘空间，重装系统也不丢失配置，本文详细记录了如何将 OpenClaw 安装在非系统盘，比如D 盘，并对接阿里云通义千问大模型的全过程。

主要是利用 NVM 和 npm 进行安装，方便后续一键升级，配置具有免费额度的Qwen API，这个只需要在阿里云百炼注册一个账号就能获得免费额度。

准备工作

1.在安装之前，在D盘创建以下目录：

1
2

D:\SOFT_WARE\OpenClaw\data：用于存放配置文件、日志和数据库。
D:\SOFT_WARE\OpenClaw\workspace：用于存放 AI 生成的代码和项目。

2.配置环境变量
新建系统环境变量：OPENCLAW_HOME = D:\SOFT_WARE\OpenClaw\data
这个操作的目的是将原本在 C:\Users\用户名.openclaw 的配置转移到 D 盘。

3.安装 NVM和npm

下载地址：https://github.com/coreybutler/nvm-windows/releases

安装后配置 NVM 路径：

`1`	`nvm root D:\SOFT_WARE\NVM`

安装满足要求的 Node 版本：

nvm install 22.12.0  
nvm use 22.12.0      # 切换到该版本
node -v  # 验证 Node 版本（显示 v22.12.0 则表示成功）
npm -v   # 验证 npm 可用

安装步骤

以管理员权限打开 PowerShell，执行：

`1`	`npm install -g openclaw`

验证安装的版本：

`1`	`openclaw -v`

配置 Qwen 大模型

以管理员权限打开 PowerShell，执行：

`1`	`[Environment]::SetEnvironmentVariable("DASHSCOPE_API_KEY", "你的sk-xxx密钥", "User")`

修改 D:\SOFT_WARE\OpenClaw\data.openclaw\openclaw.json 文件。

{
  "meta": {
    "lastTouchedVersion": "2026.2.19-2",
    "lastTouchedAt": "2026-02-20T04:31:04.294Z"
  },
  "wizard": {
    "lastRunAt": "2026-02-20T03:22:24.306Z",
    "lastRunVersion": "2026.2.19-2",
    "lastRunCommand": "configure",
    "lastRunMode": "local"
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "bailian/qwen3.5-plus-2026-02-15"
      },
      "models": {
        "bailian/qwen3.5-plus-2026-02-15": {
          "alias": "通义千问3.5 Plus"
        },
        "bailian/qwen3.5-plus": {
          "alias": "通义千问 Plus"
        }
      },
      "workspace": "D:\\SOFT_WARE\\OpenClaw\\workspace",
      "compaction": {
        "mode": "safeguard"
      },
      "maxConcurrent": 4,
      "subagents": {
        "maxConcurrent": 8
      }
    }
  },
  "models": {
    "mode": "merge",
    "providers": {
      "bailian": {
        "baseUrl": "https://dashscope.aliyuncs.com/compatible-mode/v1",
        "apiKey": "${DASHSCOPE_API_KEY}",
        "api": "openai-completions",
        "models": [
          {
            "id": "qwen3.5-plus-2026-02-15",
            "name": "通义千问3.5 Plus",
            "reasoning": false,
            "input": ["text"],
            "cost": {
              "input": 0.0025,
              "output": 0.01
            },
            "contextWindow": 262144,
            "maxTokens": 65536
          },
          {
            "id": "qwen3.5-plus",
            "name": "通义千问3.5 Plus",
            "reasoning": false,
            "input": ["text"],
            "cost": {
              "input": 0.008,
              "output": 0.008
            },
            "contextWindow": 1029000,
            "maxTokens": 32000
          }
        ]
      }
    }
  },
  "tools": {
    "web": {
      "search": { "enabled": true },
      "fetch": { "enabled": true }
    }
  },
  "gateway": {
    "port": 12345,
    "mode": "local",
    "bind": "loopback",
    "auth": {
      "mode": "token",
      "token": "你的自定义Token"
    }
  },
  "commands": {
    "native": "auto",
    "nativeSkills": "auto",
    "restart": true
  }
}

启动网关服务

OpenClaw 依靠网关（Gateway）提供网页交互界面。以管理员权限打开 PowerShell，执行：

1
2

openclaw gateway install --force  # 加 --force 避免残留配置冲突
openclaw gateway start

网页端使用与登录

在命令行输入

`1`	`openclaw config get gateway.auth.token`

获取登录 Token或者直接从 JSON 中复制。

打开浏览器访问 http://127.0.0.1:你的端口号

小贴士

1.Windows 路径在 JSON 中必须使用双反斜杠 \。
2.浏览器的无痕模式会丢失本地缓存，可能会导致每次刷新页面都要重新输入 Token。
http://127.0.0.1:你的端口号/?token=你的TOKEN

修改 openclaw.json 后需重启网关（openclaw gateway restart）才能生效；
升级 OpenClaw：npm update -g openclaw;

5.卸载网关：openclaw gateway uninstall --force。

6."port": 你的端口号 ➡️ 填写纯数字（如 12345）；

7."token": "你的自定义Token" ➡️ 填写任意字符串（如 openclaw_123456）

AI 浪潮下，工具的配置是第一步。希望这篇笔记能帮大家在 Windows 平台上少走弯路！

BISHI63 计算阶乘

Thu, 19 Feb 2026 22:24:36 +0000

思路

求解代码

private static final int MOD = 1000000007;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            int n = Integer.parseInt(br.readLine().trim());

            long ans = 1;

            for(int i=1;i<=n;i++){
                ans = (ans*i)%MOD;
            }
            out.println(ans%MOD);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI61 小q的数列

Thu, 19 Feb 2026 21:23:17 +0000

思路

这道题本质上是要计算一个数字在二进制下“1”的个数，然后构造出另一个具有相同数量“1”但取值最小的数字。

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            String str = br.readLine();
            long n = Long.parseLong(str.trim());

            int c = Long.bitCount(n);
            long k = (1L << c) - 1;
            out.println(c + " " + k);
        }

        out.flush();
        out.close();
        br.close();
    }

零成本从0到1搭建个人博客

Thu, 19 Feb 2026 12:20:35 +0000

测试环境：Windows 11 专业版 + Git 2.45.1

下载Hugo

点击进入以下网页：https://github.com/gohugoio/hugo/tags

可按需选择版本，如v0.154.5。

也可以通过百度网盘链接下载：

【hugo_extended_0.154.5_windows-amd64.zip】

链接: https://pan.baidu.com/s/1XD1Zi877nFvVZaXw0Q9-wA 提取码: 477k

创建个人博客

解压这个压缩包，进入到解压后的文件夹，右键进入命令行界面，输入以下命令【hugo new site CodeEdge】，其中【CodeEdge】名字可任意取。

将【hugo.exe】文件复制到【CodeEdge】文件夹中，再cd到CodeEdge目录，执行以下命令启动服务【hugo server -D】

配置个人博客的主题

点击进入以下网页https://github.com/CaiJimmy/hugo-theme-stack/tags，这里选择的是【Stack】主题，可按需选择版本，如v3.33.0。

也可以通过百度网盘链接下载：

【hugo-theme-stack-3.33.0.zip】

链接: https://pan.baidu.com/s/1rNPzDXJbeFSrqURK4X1JJg 提取码: pwgv

将这个压缩包解压到CodeEdge的themes文件夹下：

将【exampleSite】文件夹下的【content】文件夹和【hugo.yaml】文件复制到【CodeEdge】文件夹下：

接下来，将【CodeEdge】文件夹下的【hugo.toml】文件以及【content/post】路径下的【rich-content】文件夹一并删除：

编辑【hugo.yaml】文件，将theme修改为themes文件夹下的主题文件夹同名：

在命令行中再次执行【hugo server -D】

访问【http://localhost:1313】就能加载添加的主题：

新建Github博客网站仓库

在Github上新建一个博客网站仓库，如【CodeEdge.github.io】

。

为了连接的稳定性，github上最好选择ssh：

在github的博客网站仓库依次执行以下步骤：

编辑【hugo.yaml】文件，将baseurl修改为如下网站名称，与上面的步骤⑤保持一致：

之后即可通过访问这个baseurl来查看部署的博客了。

在命令行cd到public文件夹：

依次执行以下命令：

echo "# CodeEdge.github.io" >> README.md
git init
git add .
git commit -m "first commit"
git branch -M main
git remote add origin git@github.com:github用户名/CodeEdge.github.io.git
git push -u origin main

新建Github博客源代码仓库

在Github上新建一个博客源代码仓库，如【CodeEdge.github.io】

。

在命令行cd到CodeEdge文件夹：

依次执行以下命令：

echo "# CodeEdgeSource" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin git@github.com:github用户名/源代码仓库.git
git push -u origin main

实现Github Action自动部署

在github上依次进行以下操作，创建token，需要勾选【repo】和【workflow】：

将这个token保存到源代码仓库【CodeEdgeSource】中：

在【CodeEdge】文件夹下新建以下文件：

hugo_deploy文件的主要内容如下：

name: Build and Deploy Hugo Site

on:
  push:
    branches:
      - main
    paths:
      - "content/**/*.md"
      - "static/**"
      - "layouts/**"
      - "assets/**"
  workflow_dispatch: # 支持手动触发

concurrency:
  group: deploy-pages
  cancel-in-progress: true

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - name: Checkout source repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
          token: ${{ secrets.DEPLOYCODEEDGE_TOKEN }} # 用于图片上传需要推送权限

      - name: Git Configuration
        run: |
          git config --global core.quotePath false
          git config --global core.autocrlf false
          git config --global core.safecrlf true
          git config --global core.ignorecase false

      # ============ 构建 Hugo 站点 ============
      - name: Setup Hugo
        uses: peaceiris/actions-hugo@v3
        with:
          hugo-version: "latest"
          extended: true

      - name: Build site
        run: hugo -D # 包含 draft 文章

      # ============ 部署到 GitHub Pages ============
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v4
        with:
          personal_token: ${{ secrets.DEPLOYCODEEDGE_TOKEN }}
          external_repository: github用户名/博客网站仓库
          publish_branch: main
          publish_dir: ./public
          force_orphan: true
          commit_message: "auto deploy: ${{ github.event.head_commit.message }}"
          user_name: "github-actions[bot]"
          user_email: "github-actions[bot]@users.noreply.github.com"

在【CodeEdge】文件夹下新建【.gitignore】文件，避免提交以下非必要的文件：

public
resources
.hugo_build.lock
hugo.exe

*.lock
.DS_Store
Thumbs.db
*.tmp
*.log
.idea/
.vscode/

博客部署步骤

#新建博客
hugo new content post/XXX.md

#本地查看
hugo server -D

#部署
git add .

git commit -m "xxx"

git push origin main

当新增的博客推送到源代码仓库后，GitHub Actions 会自动执行以下步骤：

检测到推送
触发 .github/workflows/hugo_deploy.yaml 工作流
运行 hugo -D 构建网站
将生成的静态文件部署到博客网站仓库
等待一定的时间后，博客网站会自动更新

参考资料

1.配置ssh解决https不稳定的问题-CSDN博客

2.下载 GitHub 仓库「单个文件夹」的方法_github只下载某个文件夹-CSDN博客

3.推送错了仓库的解决办法-CSDN博客

4.本地改乱了代码，如何恢复成和 GitHub 仓库一致的干净版本？-CSDN博客

5.VS Code图形化界面操作Git-CSDN博客

6.消除VS Code在检查style标签里面的 CSS 代码时产生的语法警告-CSDN博客

小贴士

1.Hugo 需要 Front Matter 才能识别文章。也就是在文件最开头需要有以下这些代码：

+++
title = '配置ssh解决https不稳定的问题'
date = '2026-01-13T14:20:00+08:00'
draft = false
+++

2.github账号现在有一个输入验证码的步骤，可在浏览器上安装【2FA Authenticator】插件获取。

3.一些搭建博客可能用到的网站

免费图标网站	https://icon-icons.com/
emoji词典	https://www.emojiall.com/
在线PS工具	https://ps.pic.net/
ANI 鼠标样式转 PNG 文件在线工具	https://ezgif.com/ani-to-apng
PNG转ICO在线工具	https://www.png2ico.com/
免费的商用字体	https://www.100font.com/

Coder_Studio

关于

Coder_Studio - 个人技术博客

🚀 主要特性

🛠️ 技术栈

📝 开发与部署流程

博客首页

博客分类

博客标签

搜索

友情链接

Spring Boot + Vue 前后端联调踩坑记录

哈希、对称_非对称加密、数字签名，一次性讲清

别再搞混了！Redis、Jedis、Lettuce、Spring Data Redis、Redisson、Spring Session Redis 一次讲透

Java线程与操作系统线程的生命周期

一篇搞懂：Java包名、Maven artifactId、Spring application.name到底有啥区别？

Java包名 com.codeedgexu.codeedgebackend

作用

小贴士

Maven artifactId codeedge-backend

作用

小贴士

application.yml文件中的codeedge-backend

作用

小贴士

一篇搞懂：LangChain4j结构化输出、TokenStream、SSE、Flux、Reactor到底是什么？

LangChain4j结构化输出

TokenStream + SSE

Flux & Reactor

一张图搞懂

【面试真题拆解】十万用户并发下，Caffeine+Redis+MySQL多级缓存怎么设计？

设计方案

定好每一层的职责

缓存预热

缓存雪崩、击穿、穿透

缓存雪崩：十万个Key同时过期

缓存击穿：超级热门Key突然过期

缓存穿透：查根本不存在的Key

十万并发下的 Redis 压力分摊方案

多实例下的本地缓存一致性

完整的请求+数据更新全流程

【面试真题拆解】你知道登录用到的Token是什么吗？

为什么登录必须用 Token？

Token 的工作流程

Token 的作用

Token 和 Session 的区别

一篇搞懂前后端所有的“器”

前后端对比

【面试真题拆解】为什么用SSE做流式输出？和WebSocket有啥区别？

为什么用SSE做流式输出？

SSE流式输出的原理

为什么不用WebSocket？

【面试真题拆解】平时会收发短信吧？你知道短信里那种 `CodeEdge` 的短链接，点击之后是怎么跳转到长链接的？它是怎么生成的？

点击短链接后发生了什么？

那个短链接是怎么生成的？

自增ID + Base62编码

小贴士

哈希算法+截取

随机字符串生成

为什么要用短链接？

1. 短信的字数限制

2. 防拦截、防屏蔽

3. 数据统计和追踪

Spring Boot + 通义千问 AI 数据分析助手：一句话生成 SQL + 图表 + 智能结论

需求分析

项目效果演示

技术栈

核心功能

3 步快速上手

【面试真题拆解】Java里面的线程池都有哪些参数？

线程池的7个核心参数

1. corePoolSize：核心线程数

2. maximumPoolSize：最大线程数

3. keepAliveTime：空闲线程存活时间

4. unit：时间单位

5. workQueue：工作队列

6. threadFactory：线程工厂

7. handler：拒绝策略

线程池的执行流程

4种默认拒绝策略

Java包名 `com.codeedgexu.codeedgebackend`

Maven artifactId `codeedge-backend`

`application.yml`文件中的`codeedge-backend`