欢迎访问 java笔试刷题 —— 每日一题,日拱一卒

java笔试刷题|大厂通关必备题库

覆盖JVM、集合、并发、Spring、网络协议、设计模式等12大核心模块|真实面试题解析|高频考点追踪|系统化备考路径|助你高效突破技术面试瓶颈

立即刷题

平台总览|不只是题库,更是系统化成长路径

在当前就业环境趋紧、技术迭代加速的背景下,java笔试刷题已成为开发者职业进阶的必经之路。我们深知:一道题的价值不在于答案本身,而在于解题过程中暴露的知识盲区与思维路径偏差。因此,本平台以“题为引、思为径、系统为纲”,构建覆盖考点认知→真题演练→思维建模→错题闭环→策略优化的五维学习闭环。

平台核心优势在于:深度解析——每道题均包含命题意图、考点拆解、易错点预警、扩展延伸四层结构;场景还原——题目源自2023-2024年阿里、腾讯、字节等32家大厂真实面经;动态更新——基于用户反馈与面试风向变化,每月迭代题库与解析;路径引导——提供初级→中级→高级三级备考路线图,匹配不同阶段需求。

根据2024年Q1用户调研数据:持续使用本平台3个月以上的用户,Java技术面通过率提升至87.6%(行业平均为63.2%)。其中,JVM内存模型、Spring循环依赖、ConcurrentHashMap线程安全机制等高阶考点的掌握度提升最为显著。这印证了“精准打击薄弱环节”比“盲目刷题量”更有效。

为什么选择本平台?

  • ⚡ 题量真实:累计收录1827道真题,其中2024年新增416道,拒绝“过期模拟题”
  • ⚙️ 解析透彻:平均解析字数达420字/题,含源码片段、图解、扩展思考
  • 〔 路径清晰〕:按“基础→进阶→实战”三级标签分类,支持按时间轴/难度/频率筛选
  • 〈 互动反馈〕:每题开放“解题思路”讨论区,已有2863条高质量用户补充
  • 《 数据驱动〕:个人学习报告自动生成,精准定位知识薄弱点

题库总览|高频考点全覆盖

本平台题库严格依据《Java开发者能力模型(2024版)》构建,覆盖企业招聘中占比超85%的核心能力项。所有题目均标注来源(公司+批次+岗位)、考察维度、难度系数(1-5级)、正确率(基于真实用户作答数据)及更新时间。用户可根据自身阶段选择“新手入门”“进阶突破”“冲刺高薪”专项训练。

特别说明:我们反对“题海战术”。每道题均经过命题组三轮审核——第一轮:是否反映真实面试场景;第二轮:解析是否揭示底层原理;第三轮:是否有扩展价值。确保每道题都是“小切口、深挖掘”的典型样本。

题库结构说明

题库采用双维度分类体系:

  • 技术维度:按Java核心技术栈分层(语言基础→JVM→集合→并发→IO/NIO→网络→框架→工程化)
  • 能力维度:按面试考察目标分层(概念辨析→代码输出→场景设计→源码分析→故障排查)

例如“HashMap与HashTable区别”题,既属于“集合框架”技术模块,又属于“概念辨析”能力层级;而“设计高并发计数器”则属于“并发编程”+“场景设计”。这种双维度设计便于用户从知识体系与能力模型两个角度定位问题。

1. Java语言基础|2024年Q1平均正确率68%

以下题目反映开发者对语言底层机制的理解深度,常出现在一面技术面。错误率高的核心原因:死记结论,忽视JVM执行过程。

例题:final、finally、finalize区别?

命题意图:考察对Java关键字、异常处理机制、对象回收流程的区分能力

final class A {} // 不可继承 final int x = 5; // 常量 final void method() {} // 不可重写 try { throw new Exception(); } catch (Exception e) { // ... } finally { System.out.println("执行"); } Object obj = new Object(); obj = null; System.gc(); // 不保证finalize被调用

深度解析:final修饰类/方法/变量时,JVM会进行优化(如内联、消除同步检查);finally块在try-catch后执行,但若在finally中return或抛异常,会覆盖原返回值;finalize()是Object方法,由GC线程调用,但JDK9已标记为deprecated,推荐使用Cleaner或PhantomReference。

易错点预警:① finally中修改基本类型变量不影响try中的返回值(因值已复制);② finalize()调用不等于对象立即被回收;③ finalize()仅调用一次,重写后需显式调用super.finalize()。

扩展延伸:JDK11引入Cleaner机制替代finalize——基于PhantomReference与ReferenceHandler线程,避免finalize导致的内存泄漏与GC停顿。

2. Spring框架|2024年Q1平均正确率52%

Spring相关题多出现在二面及以上,考察对容器生命周期、AOP代理、事务传播的掌握。用户普遍反映“知道结论但说不清原理”,本平台提供源码级解析。

例题:Spring循环依赖如何解决?为什么需要三级缓存?

命题意图:考察对Bean生命周期、单例池、代理机制的综合理解

深度解析:Spring通过三级缓存解决循环依赖——

  • SingletonObjects(一级缓存):成品Bean
  • EarlySingletonObjects(二级缓存):早期暴露的Bean(已实例化但未填充属性)
  • SingletonFactories(三级缓存):ObjectFactory,用于生成代理对象

流程:① 创建Bean A → 放入三级缓存;② 填充属性时发现依赖B → 创建B;③ B创建时从三级缓存获取A的ObjectFactory → 调用getEarlyBeanReference生成代理(若需)→ 放入二级缓存;④ B完成初始化后,A继续填充属性获得B → A完成初始化。

关键点:三级缓存必要性在于——若只有二级缓存,A的代理对象需提前创建,但A可能无需代理(如无切面),造成性能浪费;三级缓存延迟代理创建,仅在真正需要时生成。

注意:构造器注入无法解决循环依赖(因Bean未实例化),必须使用setter注入或@Lazy注解。

3. 易错陷阱题|2024年Q1平均正确率仅39%

此类题故意设置“似是而非”的选项,考察对细节的敏感度。常见于大厂终面,用于筛选高精度开发者。

例题:以下代码输出?

String a = "abc"; String b = "ab" + "c"; System.out.println(a == b);

陷阱分析:看似考察字符串常量池,实则考察编译期常量折叠(Constant Folding)。编译器会将"ab"+"c"优化为"abc",故a与b指向同一常量池对象,输出true。但若改为"ab"+new String("c"),则输出false。

深度陷阱:JDK9+中String常量池实现变化——内部存储从char[]改为byte[]+encoding flag,但对==比较无影响。

JVM深度专题|从字节码到性能调优

JVM是Java开发者的“隐形护甲”。掌握其原理不仅能应对面试,更能定位线上问题(如GC停顿、内存泄漏、类加载冲突)。本专题聚焦2024年企业最关注的三大能力:内存模型理解、GC调优实战、字节码增强技术。

JVM内存模型核心要点

《Java虚拟机规范》将内存划分为:程序计数器(线程私有,记录当前指令地址)、虚拟机栈(线程私有,栈帧存储局部变量、操作数栈)、本地方法栈(线程私有,服务native方法)、堆(线程共享,对象实例存储区)、方法区(JDK8后为元空间,存储类信息、常量、静态变量)。

关键对比:

区域线程可见性异常类型典型OOM场景
堆共享OutOfMemoryError对象过多且无法回收
虚拟机栈私有StackOverflowError / OOM递归过深 / 栈帧过大
元空间共享OutOfMemoryError动态生成类过多(如CGLIB)

深度延伸:元空间(Metaspace)替代永久代(PermGen)的核心原因——永久代受-XX:MaxPermSize限制,且GC回收效率低;元空间使用本地内存,可动态扩展,并支持类元数据的精细回收(如卸载无用类)。

垃圾回收核心算法

① 标记-清除(Mark-Sweep)

流程:标记可达对象 → 清除未标记对象。缺陷:产生内存碎片,后续分配需遍历空闲链表。

② 复制(Copying)

将内存分为两块,存活对象复制到另一块,清空原块。优点:无碎片;缺点:内存利用率50%。HotSpot新生代使用此方案(Eden:S0:S1=8:1:1)。

③ 标记-整理(Mark-Compact)

标记后将存活对象向一端移动,清理边界外内存。用于老年代,避免碎片化。

面试技巧:当被问“如何选择GC算法”时,优先回答业务场景——低延迟选G1/ZGC,高吞吐选Parallel,内存受限选Serial。

HotSpot主流GC实现

Serial/Serial Old:单线程,Client模式默认(桌面应用)

ParNew:Serial的多线程版,常与CMS配合

Parallel Scavenge / Parallel Old:关注吞吐量(CPU时间用于GC的比例),Server模式默认

CMS(Concurrent Mark-Sweep):以停顿时间最小化为目标,但有碎片问题,JDK14已废弃

G1(Garbage-First):面向服务端,将堆划分为Region,支持预测性停顿(Region集合为Mixed GC)

ZGC(JDK11+):低延迟(停顿<10ms),使用染色指针、Load Barrier技术,适用于TB级堆内存

# 常用GC参数 -Xms2g -Xmx2g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 # 目标停顿时间 -XX:+UnlockExperimentalVMOptions -XX:ZCollectionInterval=10 # ZGC

线上GC调优实战案例

场景:某电商大促期间,应用偶发GC停顿超2秒,导致订单超时。

排查步骤:

  1. 添加JVM参数:-XX:+PrintGCDetails -Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=10M
  2. 分析日志发现:Full GC频繁,老年代增长过快
  3. 使用jmap -histo:live pid查看对象分布,发现大量byte[](约1.2GB)
  4. 定位代码:图片上传后未及时关闭InputStream,导致字节数组泄漏
  5. 修复方案:改用try-with-resources,GC停顿降至200ms内

经验总结:GC调优不是万能药,需结合业务定位根本原因。优先排查内存泄漏、大对象创建、缓存策略问题。

Java核心编程|集合、泛型、反射、IO

核心API是面试的“基本盘”。本专题聚焦高频考点:集合框架源码级对比、泛型擦除陷阱、反射性能优化、NIO与AIO实战。

集合框架深度对比

ArrayList vs LinkedList:

特性ArrayListLinkedList
底层结构动态数组双向链表
随机访问O(1)O(n)
插入/删除O(n)(需移动)O(1)(需定位)
内存开销仅存元素存元素+前后指针

HashMap vs ConcurrentHashMap:

  • HashMap:线程不安全,JDK8用数组+链表/红黑树
  • ConcurrentHashMap:JDK8用CAS+synchronized,分段锁优化
  • 关键差异:ConcurrentHashMap的get不加锁(利用volatile保证可见性),put需加锁
// ConcurrentHashMap线程安全实现(简化版) final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw NPE; int hash = spread(key.hashCode()); for (Node[] tab = table;;) { Node f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // CAS插入(无锁) if (casTabAt(tab, i, null, new Node(hash, key, value, null))) break; } else { // 链表/红黑树插入(加synchronized) synchronized (f) { ... } } } return null; }

泛型擦除与桥方法

Java泛型是伪泛型,仅在编译期存在,运行时被擦除为Object。例如:

List list = new ArrayList<>(); list.add("test"); // 反射获取类型 System.out.println(list.getClass().getName()); // java.util.ArrayList // 泛型信息丢失 Type t = list.getClass().getGenericSuperclass(); // null

桥方法:为实现多态,编译器生成桥方法(synthetic method)。例如:

class MyList extends ArrayList {} // 编译后生成: public Object get(int index) { return super.get(index); } // 桥方法

陷阱:泛型数组不能直接new(因擦除后无法确定类型),需用反射或集合替代。

反射性能优化方案

反射慢的核心原因:① 权限检查(每次调用都检查);② 动态类型解析;③ 无法内联优化。

优化方案:

  • 设置Accessible.setAccessible(true)绕过权限检查
  • 缓存Method/Field对象(避免重复获取)
  • 使用MethodHandle(JDK7+,更轻量)
  • 关键路径避免反射(如高频调用的getter/setter)
建议:反射适用于框架开发(如Spring),业务代码中应避免高频反射调用。

IO模型对比

模型阻塞点适用场景Java实现
BIO所有操作连接数少且稳定java.io
NIO仅注册事件高并发短连接java.nio
AIO无阻塞高并发长连接java.nio.channels.AsynchronousChannel

Netty优势:基于NIO实现,提供零拷贝、内存池、编解码器等高级特性,成为主流网络框架。

Spring生态|从核心到Cloud

Spring已成Java事实标准,其设计思想(IoC、AOP、约定优于配置)深刻影响现代框架。本专题覆盖Spring Core→Spring Boot→Spring Cloud的完整知识链。

Spring IoC容器启动流程

以AnnotationConfigApplicationContext为例:

  1. 创建BeanFactory(DefaultListableBeanFactory)
  2. 注册BeanDefinitionReader(如AnnotatedBeanDefinitionReader)
  3. 扫描包路径,解析@Component等注解 → 生成BeanDefinition
  4. 将BeanDefinition注册到BeanFactory
  5. 调用finishBeanFactoryInitialization()实例化单例Bean
  6. 执行BeanPostProcessor(如AOP代理)

关键点:BeanDefinition是Bean的元数据,包含class、scope、lazy-init、depends-on等;BeanFactoryPostProcessor在实例化前执行(如PropertySourcesPlaceholderConfigurer);BeanPostProcessor在初始化前后执行(如AutowiredAnnotationBeanPostProcessor)。

Spring AOP原理与实现

代理机制:

  • 目标类有接口 → JDK动态代理(基于InvocationHandler)
  • 目标类无接口 → CGLIB(生成子类,重写方法)

执行流程:

// JDK动态代理示例 Object proxy = Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), (proxy, method, args) -> { System.out.println("前置通知"); Object result = method.invoke(target, args); System.out.println("后置通知"); return result; } );

Spring AOP增强:自动选择代理方式、支持@Aspect注解、整合Pointcut表达式(execution(* com..*(..)))。

Spring Boot自动配置原理

核心注解:@SpringBootApplication → @EnableAutoConfiguration → @Import(AutoConfigurationImportSelector.class)

流程:

  1. 读取META-INF/spring.factories中的EnableAutoConfiguration配置
  2. 过滤@Conditional注解(如@ConditionalOnClass)
  3. 将符合条件的Configuration类注册为Bean

自定义 Starter:

// 1. 创建自动配置类 @Configuration @ConditionalOnClass(DsService.class) @EnableConfigurationProperties(DsProperties.class) public class DsAutoConfiguration { @Bean @ConditionalOnMissingBean public DsService dsService() { return new DsService(); } } // 2. META-INF/spring.factories org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.example.DsAutoConfiguration

Spring Cloud核心组件对比

组件功能替代方案
Eureka服务注册与发现Nacos/Zookeeper
Feign声明式HTTP客户端RestTemplate/WebClient
Hystrix熔断降级Resilience4j/Sentinel
Config分布式配置中心Nacos/Apollo

趋势:Spring Cloud Alibaba生态更受国内企业青睐(Nacos/Sentinel/SOFARPC)。

并发编程|从线程到高并发架构

并发是Java高阶开发的分水岭。本专题覆盖线程池、JUC工具类、锁优化、无锁编程等实战技能。

线程池参数设计原则

核心参数:corePoolSize、maximumPoolSize、keepAliveTime、workQueue。

CPU密集型任务:线程数≈CPU核心数(Runtime.getRuntime().availableProcessors())

IO密集型任务:线程数≈CPU核心数 × (1 + waitTime/computeTime)

混合型任务:拆分为CPU/IO子任务,分别用不同线程池

// 推荐线程池配置(Java 1.8+) ExecutorService pool = new ThreadPoolExecutor( 8, // corePoolSize 16, // maximumPoolSize 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000), new ThreadFactoryBuilder().setNameFormat("biz-pool-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略 );

避坑指南:避免使用Executors工具类创建线程池(FixedThreadPool/SingleThreadPool可能OOM),应显式指定参数。

JUC核心工具类

① CountDownLatch

倒计时器,线程等待多个任务完成。示例:主线程等待3个子线程初始化完毕。

② CyclicBarrier

循环栅栏,线程等待彼此到达屏障点。示例:多线程计算数据后合并结果。

③ Semaphore

信号量,控制并发访问数。示例:数据库连接池限流。

④ ConcurrentHashMap

JDK8使用CAS+synchronized,分段锁优化,性能远超Hashtable。

// CountDownLatch示例 CountDownLatch latch = new CountDownLatch(3); for (int i = 0; i < 3; i++) { new Thread(() -> { // 任务处理 latch.countDown(); }).start(); } latch.await(); // 等待3个任务完成 System.out.println("所有任务完成");

锁的升级与降级

HotSpot JVM中锁状态升级路径:无锁 → 偏向锁 → 轻量级锁 → 重量级锁。

  • 偏向锁:单线程访问时,通过CAS设置线程ID,避免CAS开销
  • 轻量级锁:多线程竞争但冲突少时,自旋等待(避免线程挂起)
  • 重量级锁:竞争激烈时,线程挂起等待

锁降级:写锁可降级为读锁(ReentrantReadWriteLock),但读锁不能升级为写锁。

Akka与Actor模型

Actor模型通过“消息传递+无共享状态”实现高并发。核心原则:

  • 每个Actor有唯一邮箱(Mailbox),消息按序处理
  • Actor间通过tell/ask通信,无共享变量
  • 失败时由Supervisor策略处理(restart/stop)

适用场景:高吞吐、低延迟的分布式系统(如金融交易、实时计算)。

网络编程|从TCP到分布式协议

网络是分布式系统的基础。本专题覆盖TCP/IP协议栈、HTTP/HTTPS、RPC原理、一致性算法等。

TCP三次握手与四次挥手

三次握手:

  1. Client → Server:SYN=1, seq=x
  2. Server → Client:SYN=1, ACK=1, seq=y, ack=x+1
  3. Client → Server:ACK=1, seq=x+1, ack=y+1

四次挥手:

  1. Client → Server:FIN=1, seq=u
  2. Server → Client:ACK=1, seq=v, ack=u+1
  3. Server → Client:FIN=1, ACK=1, seq=w, ack=u+1
  4. Client → Server:ACK=1, seq=u+1, ack=w+1

TIME_WAIT原因:

  • 保证最后一个ACK到达Server(重发FIN)
  • 防止旧连接数据干扰新连接(2MSL时间)

优化方案:设置SO_REUSEADDR允许端口复用;调整net.ipv4.tcp_tw_reuse。

HTTP/1.1 vs HTTP/2 vs HTTP/3

特性HTTP/1.1HTTP/2HTTP/3
连接复用需管道化(有限制)多路复用(单TCP连接)QUIC(UDP实现)
头部压缩无HPACKQPACK
安全性TLS可选强制TLS强制TLS
头部大小无限制≤4KB无限制

HTTP/2关键特性:

  • 二进制分帧(Frame):将HTTP消息拆分为帧,支持多路复用
  • Header压缩:Huffman编码减少头部体积
  • Server Push:服务端主动推送资源

RPC核心流程

1. 服务暴露:服务端将接口注册到注册中心(如Zookeeper)

2. 服务发现:客户端从注册中心获取服务地址列表

3. 负载均衡:客户端选择服务实例(如随机/轮询/一致性哈希)

4. 动态代理:生成代理对象,屏蔽网络细节

5. 序列化:将参数转为二进制(Protobuf/Kryo)

6. 网络传输:通过HTTP/TCP发送请求

7. 响应处理:解析响应结果,返回给调用方

面试重点:当被问“RPC如何保证可靠性”时,需覆盖:超时重试、熔断降级、序列化兼容性、幂等设计。

一致性算法对比

算法适用场景性能容错性
Paxos理论基础低N≥2F+1
Raft分布式协调(如ETCD)中N≥2F+1
ZABZooKeeper中N≥2F+1
Gossip最终一致性(如Cassandra)高无硬性要求

Raft核心机制:

  • Leader选举:心跳超时触发,随机超时避免冲突
  • 日志复制:Leader将日志条目发送给Follower
  • 安全性:Leader不会覆盖已有日志(Commit只基于自身日志)

设计模式与架构思想

设计模式是经验的结晶,但需避免“为模式而模式”。本专题聚焦高频模式在Java中的实战应用。

高频设计模式

模式Spring应用关键点
工厂模式BeanFactory解耦对象创建与使用
单例模式@Scope("singleton")线程安全(DCL/静态内部类)
代理模式AOPJDK/CGLIB选择
模板方法JdbcTemplate封装不变,暴露可变
策略模式SortingComparator消除if-else

策略模式实战:

// 定义策略接口 public interface DiscountStrategy { double calculate(double price); } // 具体策略 public class VIPDiscount implements DiscountStrategy { public double calculate(double price) { return price * 0.8; } } public class FestivalDiscount implements DiscountStrategy { public double calculate(double price) { return price - 50; } } // 上下文 public class PriceContext { private DiscountStrategy strategy; public void setStrategy(DiscountStrategy strategy) { this.strategy = strategy; } public double executeStrategy(double price) { return strategy.calculate(price); } } // 调用 PriceContext context = new PriceContext(); context.setStrategy(new VIPDiscount()); double finalPrice = context.executeStrategy(100); // 80

领域驱动设计(DDD)核心概念

分层架构:

  • 展示层:UI/Controller
  • 应用层:Application Service(协调领域对象)
  • 领域层:Domain Model(核心业务逻辑)
  • 基础设施层:Repository/Tool

核心元素:

  • 实体(Entity):有唯一标识(如User)
  • 值对象(Value Object):无标识, immutable(如Money)
  • 聚合(Aggregate):聚合根+聚合成员(如Order+OrderItem)
  • 领域事件(Domain Event):跨聚合通信(如OrderPaidEvent)

实践建议:小项目无需DDD;复杂业务领域(如金融、电商)优先考虑。

Clean Architecture分层原则

核心原则:依赖规则(Dependency Rule)——内层依赖外层,但外层不能依赖内层。

// 依赖方向:Domain ← Application ← Interface Adapters ← Frameworks & Drivers // Domain:纯业务逻辑(无框架依赖) // Application:用例(Use Cases) // Interface Adapters:Controller/Presenter // Frameworks & Drivers:Spring/Database/FrameWork

优势:业务逻辑独立于框架,易于测试与重构。

CQRS模式

Command Query Responsibility Segregation:命令查询职责分离。

  • 命令(Command):修改状态(写操作)
  • 查询(Query):返回数据(读操作)

典型实现:

  • 写模型:基于DDD,保证强一致性
  • 读模型:独立优化的查询模型(如ES/Cassandra)
  • 事件驱动:写操作发布领域事件,异步更新读模型

适用场景:读写比高的系统(如社交、内容平台)。

算法与数据结构|高频面试题精解

算法题是大厂面试的“门槛”。本专题覆盖LeetCode高频题(按公司标签分类),提供最优解+多种解法对比。

经典题型解析

① 两数之和(LeetCode #1)

题目:给定数组和目标值,返回两个数的索引。

// 最优解:哈希表(O(n)时间) public int[] twoSum(int[] nums, int target) { Map map = new HashMap<>(); for (int i = 0; i < nums.length; i++) { int complement = target - nums[i]; if (map.containsKey(complement)) { return new int[]{map.get(complement), i}; } map.put(nums[i], i); } return new int[]{-1, -1}; }

扩展:若数组有序,可用双指针(O(n)时间,O(1)空间)。

② 旋转数组的最小数字(LeetCode #153)

题目:给定旋转后的有序数组,找出最小值。

// 二分查找(O(log n)) public int findMin(int[] nums) { int left = 0, right = nums.length - 1; while (left < right) { int mid = left + (right - left) / 2; if (nums[mid] > nums[right]) { left = mid + 1; } else { right = mid; } } return nums[left]; }

陷阱:mid与right比较(非left),避免死循环。

滑动窗口技巧

适用场景:子串/子数组问题(如LeetCode #3最长无重复子串)。

public int lengthOfLongestSubstring(String s) { Set set = new HashSet<>(); int left = 0, max = 0; for (int right = 0; right < s.length(); right++) { while (set.contains(s.charAt(right))) { set.remove(s.charAt(left++)); } set.add(s.charAt(right)); max = Math.max(max, right - left + 1); } return max; }

扩展:可替换为Map记录字符最后出现位置,优化左指针跳跃。

链表快慢指针

① 判断链表是否有环(LeetCode #141)

② 找链表中点(LeetCode #876)

③ 找链表倒数第k个节点

// 快慢指针找中点 ListNode slow = head, fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; } // slow即为中点

二叉树遍历模板

// 前序遍历(递归) void preorder(TreeNode root) { if (root == null) return; visit(root); preorder(root.left); preorder(root.right); } // 中序遍历(非递归) void inorder(TreeNode root) { Stack stack = new Stack<>(); while (root != null || !stack.isEmpty()) { while (root != null) { stack.push(root); root = root.left; } root = stack.pop(); visit(root); root = root.right; } }

面试技巧:树问题优先考虑递归;迭代需用栈模拟;层序用队列。

学习资源推荐|精选书单与工具

必读书单

  1. 《Effective Java》(第3版):Java开发圣经,36条准则覆盖最佳实践
  2. 《Java并发编程实战》:并发领域权威著作,深入JMM与线程安全
  3. 《深入理解Java虚拟机》(第3版):JVM原理与调优实战
  4. 《Spring源码深度解析》:Spring核心机制源码级解读
  5. 《设计模式:可复用面向对象软件的基础》:GoF经典,理解设计思想本质

在线工具推荐

  • ⚡ LeetCode:刷题+面经库
  • ⚙️ byte-buddy:动态字节码生成
  • 〔 jconsole〕:JVM监控
  • 〈 jvisualvm〕:性能分析
  • 《 ProcessOn〕:架构图绘制

开源项目推荐

  • 【 Spring Boot】:快速开发框架
  • 【 Netty】:高性能网络框架
  • 【 Dubbo】:分布式RPC框架
  • 【 MyBatis】:半自动ORM
  • 【 Hutool】:Java工具类库

常见问题解答|高频疑问深度回应

Q1:应届生如何准备Java面试?

建议路径:

  1. 夯实基础:Java核心(集合/并发/JVM)+ 数据结构 + 算法
  2. 项目深挖:选择1-2个项目,准备“为什么选A方案?”“遇到什么问题?”
  3. 模拟面试:使用本平台题库进行专项训练
  4. 准备反问:面试结束时的提问(体现思考深度)

避坑:避免“背题”,重点理解“为什么这样设计”。

Q2:工作3年如何突破瓶颈?

建议方向:

  • 技术深度:深入JVM/分布式架构/源码
  • 技术广度:了解服务治理/可观测性/云原生
  • 业务理解:深入行业知识(如金融、电商)
  • 软技能:技术方案设计 + 跨团队协作
关键:从“执行者”转向“决策者”,能主导技术方案设计与落地。

Q3:如何准备系统设计题?

回答框架:

  1. 明确需求:确认QPS、数据量、延迟要求
  2. 设计拓扑:客户端→网关→服务层→存储层→缓存
  3. 关键决策:数据库选型(MySQL/Redis/TiDB)、缓存策略(本地缓存+分布式缓存)、服务拆分
  4. 高可用方案:主从复制、分库分表、降级熔断
  5. 扩展性:水平扩展能力、监控告警

示例题:设计一个短链服务(如t.cn)

  • 需求:生成6位短链,支持跳转,高并发
  • 方案:Base62编码(ID自增) + Redis缓存 + 分库分表
  • 优化:预生成短链 + Redis布隆过滤器防缓存击穿

网友还关心