java经典面试题

我不只给题目名，而是会按模块分类，这样你可以直接拿去做面试复习清单**。

经典 Java 面试题大全（按模块整理）

我把它分成 12 大块：

  1. Java 基础
  2. 集合
  3. 并发 / 多线程
  4. JVM
  5. Spring / Spring Boot
  6. MyBatis / ORM
  7. MySQL
  8. Redis
  9. 消息队列
  10. 微服务 / 分布式
  11. 设计模式 / 系统设计
  12. 项目场景题 / 性能优化题

1）Java 基础经典面试题

1.1 面向对象与语言特性

  1. Java 的三大特性是什么？分别怎么理解？
  2. 重载和重写的区别是什么？
  3. == 和 equals() 的区别？
  4. hashCode() 和 equals() 为什么要一起重写？
  5. String、StringBuilder、StringBuffer 的区别？
  6. final、finally、finalize 的区别？
  7. static 关键字的作用？
  8. this 和 super 的区别？
  9. 抽象类和接口的区别？
  10. Java 为什么是“平台无关”的？

1.2 基本类型与包装类

  1. Java 基本数据类型有哪些？各占多少字节？
  2. int 和 Integer 的区别？
  3. 自动装箱 / 拆箱底层是怎么实现的？
  4. 为什么 Integer 会有缓存机制？
  5. Integer a = 127; Integer b = 127; a==b 为什么是 true？
  6. Integer a = 128; Integer b = 128; a==b 为什么可能是 false？

1.3 String 相关

  1. String 为什么不可变？
  2. String 为什么适合作为 HashMap 的 key？
  3. String s = "abc" 和 new String("abc") 的区别？
  4. 字符串常量池是什么？
  5. intern() 方法的作用是什么？

1.4 异常机制

  1. Java 异常体系结构是什么？
  2. Exception 和 Error 的区别？
  3. checked exception 和 unchecked exception 的区别？
  4. try-catch-finally 的执行顺序？
  5. finally 一定会执行吗？
  6. throw 和 throws 的区别？

1.5 泛型 / 反射 / 注解

  1. Java 泛型是什么？有什么好处？
  2. 泛型擦除是什么？
  3. List<Object> 和 List<String> 是父子关系吗？
  4. 什么是反射？反射有哪些应用场景？
  5. 反射为什么性能较低？
  6. 注解的本质是什么？
  7. @Retention、@Target 的作用是什么？

2）集合框架经典面试题

2.1 List / Set / Map 基础

  1. Java 集合框架有哪些主要接口？
  2. List、Set、Map 的区别？
  3. ArrayList 和 LinkedList 的区别？
  4. HashSet 为什么能去重？
  5. TreeSet 的底层是什么？
  6. HashMap 和 Hashtable 的区别？
  7. HashMap 和 ConcurrentHashMap 的区别？
  8. LinkedHashMap 的特点是什么？
  9. TreeMap 的底层实现是什么？

2.2 ArrayList

  1. ArrayList 底层是如何实现的？
  2. ArrayList 的扩容机制是什么？
  3. 为什么 ArrayList 查询快、插入删除慢？
  4. ArrayList 是线程安全的吗？为什么？

2.3 HashMap（必考）

  1. HashMap 底层数据结构是什么？
  2. JDK1.7 和 JDK1.8 的 HashMap 有什么区别？
  3. 为什么 JDK1.8 要引入红黑树？
  4. HashMap 的 put 流程是什么？
  5. HashMap 的 get 流程是什么？
  6. HashMap 为什么数组长度通常是 2 的幂次方？
  7. HashMap 如何解决哈希冲突？
  8. HashMap 的负载因子为什么默认是 0.75？
  9. HashMap 扩容时做了什么？
  10. 多线程下 HashMap 为什么可能死循环（JDK1.7）？
  11. 为什么重写 equals 必须重写 hashCode？
  12. HashMap 中 key 可以为 null 吗？

2.4 ConcurrentHashMap

  1. ConcurrentHashMap 为什么线程安全？
  2. JDK1.7 和 JDK1.8 的 ConcurrentHashMap 区别？
  3. ConcurrentHashMap 为什么不允许 key/value 为 null？
  4. ConcurrentHashMap 的 size 是精确的吗？

2.5 CopyOnWriteArrayList

  1. CopyOnWriteArrayList 的原理是什么？
  2. 它适用于什么场景？
  3. 为什么它适合“读多写少”？

3）并发 / 多线程经典面试题

这部分是Java 面试最核心的模块之一。

3.1 线程基础

  1. 进程和线程的区别？
  2. 创建线程有哪几种方式？
  3. Runnable 和 Callable 的区别？
  4. run() 和 start() 的区别？
  5. 线程有哪些状态？
  6. sleep() 和 wait() 的区别？
  7. wait() / notify() / notifyAll() 必须在什么场景下使用？
  8. yield() 的作用是什么？
  9. join() 的作用是什么？

3.2 synchronized / volatile / Lock

  1. synchronized 的底层原理是什么？
  2. synchronized 锁的是什么？
  3. synchronized 修饰实例方法和静态方法的区别？
  4. volatile 的作用是什么？
  5. volatile 能保证原子性吗？
  6. volatile 为什么能保证可见性？
  7. 什么是指令重排？volatile 如何禁止重排？
  8. synchronized 和 volatile 的区别？
  9. Lock 和 synchronized 的区别？
  10. ReentrantLock 为什么叫可重入锁？
  11. 什么是公平锁和非公平锁？
  12. ReentrantReadWriteLock 适合什么场景？
  13. StampedLock 了解吗？

3.3 AQS（高频）

  1. 什么是 AQS？
  2. AQS 的核心思想是什么？
  3. AQS 为什么使用 FIFO 双向队列？
  4. ReentrantLock 是如何基于 AQS 实现的？
  5. CountDownLatch、Semaphore、CyclicBarrier 的原理分别是什么？
  6. CountDownLatch 和 CyclicBarrier 的区别？
  7. Semaphore 有什么应用场景？

3.4 CAS / 原子类 / 线程安全

  1. 什么是 CAS？
  2. CAS 会有什么问题？
  3. 什么是 ABA 问题？如何解决？
  4. AtomicInteger 的底层实现是什么？
  5. LongAdder 和 AtomicLong 的区别？
  6. 什么是乐观锁和悲观锁？
  7. 什么是线程安全？如何判断一个类是否线程安全？

3.5 线程池（必考）

  1. 为什么要使用线程池？
  2. Java 中线程池的核心参数有哪些？
  3. ThreadPoolExecutor 的工作流程是什么？
  4. 线程池的拒绝策略有哪些？
  5. 核心线程数、最大线程数、阻塞队列之间的关系是什么？
  6. 为什么不建议使用 Executors 创建线程池？
  7. 如何根据业务场景设置线程池参数？
  8. CPU 密集型任务和 IO 密集型任务线程数如何设置？
  9. 线程池中的线程异常会怎样？
  10. 线程池如何优雅关闭？

3.6 线程模型与并发问题

  1. 什么是死锁？如何排查死锁？
  2. 什么是活锁、饥饿？
  3. 什么是可见性、原子性、有序性？
  4. 什么是 happens-before 原则？
  5. 什么是 ThreadLocal？有哪些应用场景？
  6. ThreadLocal 为什么可能导致内存泄漏？
  7. InheritableThreadLocal 是什么？
  8. 多线程下如何保证一个方法只执行一次？

4）JVM 经典面试题

4.1 JVM 内存模型

  1. JVM 运行时数据区有哪些？
  2. 程序计数器、虚拟机栈、本地方法栈、堆、方法区分别存什么？
  3. 栈和堆的区别？
  4. 方法区在 JDK1.8 之后是什么？
  5. 什么是元空间（Metaspace）？
  6. Java 对象在内存中的布局是什么？

4.2 类加载机制

  1. 类加载过程有哪些阶段？
  2. 什么是双亲委派模型？
  3. 为什么要有双亲委派？
  4. 什么情况下会打破双亲委派？
  5. 类加载器有哪些？
  6. 自定义类加载器怎么写？应用场景有哪些？
  7. JVM 的沙箱机制是什么？

4.3 垃圾回收（高频）

  1. 如何判断对象是否可回收？
  2. 什么是 GC Root？
  3. 引用计数法为什么不适合 Java？
  4. 可达性分析算法是什么？
  5. Java 中有哪些引用类型？
  6. 强引用、软引用、弱引用、虚引用的区别？
  7. 垃圾回收算法有哪些？
  8. 标记清除、复制、标记整理分别有什么优缺点？
  9. 分代收集思想是什么？
  10. 年轻代、老年代、永久代 / 元空间的区别？
  11. Minor GC、Major GC、Full GC 分别是什么？
  12. 对象什么时候会进入老年代？
  13. 大对象如何分配？
  14. 什么是空间分配担保？

4.4 垃圾收集器

  1. CMS 和 G1 的区别？
  2. G1 为什么适合大堆？
  3. G1 的回收过程是什么？
  4. ZGC、Shenandoah 了解吗？
  5. 生产环境如何选择 GC 收集器？

4.5 JVM 调优与排查

  1. JVM 常用参数有哪些？
  2. 如何排查频繁 Full GC？
  3. OOM 有哪些常见类型？
  4. Java heap space 和 Metaspace OOM 的区别？
  5. 如何排查线上内存泄漏？
  6. jmap、jstack、jstat、arthas 常怎么用？
  7. CPU 飙高怎么排查？
  8. 线程死锁怎么排查？
  9. 一个对象一定分配在堆上吗？逃逸分析了解吗？

5）Spring / Spring Boot 经典面试题

5.1 Spring 核心

  1. Spring 是什么？核心功能有哪些？
  2. IOC 和 DI 是什么？
  3. BeanFactory 和 ApplicationContext 的区别？
  4. Spring Bean 的生命周期是什么？
  5. Spring 如何解决循环依赖？
  6. Spring 的三级缓存是什么？
  7. 为什么构造器循环依赖无法解决？
  8. @Autowired 和 @Resource 的区别？
  9. @Component、@Service、@Repository 有什么区别？

5.2 AOP / 代理

  1. Spring AOP 是什么？
  2. AOP 的应用场景有哪些？
  3. JDK 动态代理和 CGLIB 的区别？
  4. Spring 默认使用哪种代理方式？
  5. 事务为什么会失效？
  6. 自调用为什么会导致事务失效？
  7. @Transactional 的底层原理是什么？

5.3 Spring 事务（必考）

  1. Spring 事务的传播行为有哪些？
  2. REQUIRED、REQUIRES_NEW、NESTED 的区别？
  3. Spring 事务隔离级别有哪些？
  4. Spring 声明式事务和编程式事务的区别？
  5. Spring 事务什么时候会失效？
  6. 为什么默认只回滚运行时异常？
  7. 如果方法内部 try-catch 了异常，事务还会回滚吗？
  8. 多线程场景下事务会失效吗？

5.4 Spring Boot / 自动配置

  1. Spring Boot 自动配置原理是什么？
  2. @SpringBootApplication 包含哪些注解？
  3. @Conditional 系列注解的作用？
  4. Starter 的原理是什么？
  5. Spring Boot 启动流程了解吗？

6）MyBatis / ORM 经典面试题

  1. MyBatis 和 Hibernate 的区别？
  2. MyBatis 的执行流程是什么？
  3. #{} 和 ${} 的区别？
  4. 为什么 ${} 容易造成 SQL 注入？
  5. MyBatis 一级缓存和二级缓存的区别？
  6. MyBatis 插件机制是什么？
  7. 分页插件是怎么实现的？
  8. MyBatis 如何处理一对一、一对多映射？
  9. 动态 SQL 标签有哪些？
  10. MyBatis 中 resultMap 的作用是什么？

7）MySQL 经典面试题（高频中的高频）

7.1 基础与索引

  1. MySQL 常见存储引擎有哪些？
  2. InnoDB 和 MyISAM 的区别？
  3. 什么是聚簇索引？什么是二级索引？
  4. 索引底层为什么用 B+ 树，不用红黑树？
  5. 联合索引为什么遵循最左前缀原则？
  6. 覆盖索引是什么？
  7. 回表是什么？
  8. 索引下推（ICP）是什么？
  9. 什么情况下索引会失效？
  10. like '%xx' 为什么索引失效？
  11. 为什么对索引列做函数运算会失效？
  12. 什么是索引选择性？
  13. 为什么不建议建太多索引？

7.2 SQL 优化

  1. SQL 优化你一般怎么做？
  2. explain 关键字段有哪些？
  3. type 从好到坏有哪些级别？
  4. extra 中 using filesort、using temporary 代表什么？
  5. 慢 SQL 的排查流程是什么？
  6. 大分页为什么慢？怎么优化？
  7. count(*) 为什么有时会慢？
  8. in 很长时怎么优化？
  9. 深分页优化方案有哪些？
  10. join 查询怎么优化？
  11. 为什么有索引还是很慢？

7.3 事务与锁

  1. MySQL 事务四大特性（ACID）是什么？
  2. MySQL 的隔离级别有哪些？
  3. 脏读、不可重复读、幻读分别是什么？
  4. MVCC 是什么？解决了什么问题？
  5. undo log、redo log、binlog 分别是什么？
  6. 两阶段提交是什么？为什么需要它？
  7. InnoDB 的行锁是怎么实现的？
  8. 什么是记录锁、间隙锁、临键锁？
  9. 为什么会有间隙锁？
  10. 什么情况下会发生死锁？
  11. MySQL 如何检测死锁？
  12. 乐观锁和悲观锁在数据库里怎么实现？
  13. select ... for update 锁的是什么？

8）Redis 经典面试题

8.1 基础

  1. Redis 为什么快？
  2. Redis 是单线程的吗？
  3. Redis 6.0 为什么引入多线程？
  4. Redis 的数据类型有哪些？
  5. String、Hash、List、Set、ZSet 的典型应用场景是什么？

8.2 持久化

  1. Redis 的持久化机制有哪些？
  2. RDB 和 AOF 的区别？
  3. 生产环境如何选择 RDB 和 AOF？
  4. AOF 重写是什么？
  5. Redis 宕机后数据一定不会丢吗？

8.3 缓存问题

  1. 缓存穿透、击穿、雪崩分别是什么？
  2. 如何解决缓存穿透？
  3. 如何解决热点 key 问题？
  4. 如何保证缓存与数据库一致性？
  5. 延时双删是什么？有什么问题？
  6. 删除缓存还是更新缓存，怎么选？
  7. 大 key / 热 key 如何治理？

8.4 高级特性

  1. Redis 事务是什么？
  2. Redis 的事务和 MySQL 事务有什么区别？
  3. Lua 脚本在 Redis 中有什么用？
  4. Redis 分布式锁如何实现？
  5. Redis 分布式锁为什么要设置过期时间？
  6. Redisson 的可重入锁原理是什么？
  7. 什么是 RedLock？是否可靠？
  8. Redis Pipeline 是什么？
  9. 布隆过滤器是什么？适合什么场景？
  10. HyperLogLog 和 Bitmap 的应用场景是什么？

8.5 集群与高可用

  1. Redis 主从复制原理是什么？
  2. 哨兵模式的作用是什么？
  3. Redis Cluster 的数据分片怎么做？
  4. 为什么 Redis Cluster 有 16384 个槽？
  5. Redis 脑裂是什么？怎么避免？

9）消息队列经典面试题

以 Apache RocketMQ、Apache Kafka、RabbitMQ 为代表。

  1. 为什么要使用消息队列？
  2. 消息队列的优点和缺点是什么？
  3. 如何保证消息不丢失？
  4. 如何保证消息不重复消费？
  5. 如何保证消息顺序性？
  6. 消息积压了怎么办？
  7. 消费失败怎么处理？
  8. 什么是死信队列？
  9. 什么是延迟消息？
  10. 如何设计幂等消费？
  11. RocketMQ、Kafka、RabbitMQ 的区别是什么？
  12. RocketMQ 的事务消息是什么？
  13. Kafka 为什么吞吐量高？
  14. 消息队列如何实现削峰填谷？

10）微服务 / 分布式经典面试题

10.1 微服务基础

  1. 什么是微服务？和单体架构相比优缺点是什么？
  2. 服务注册与发现是怎么做的？
  3. 配置中心有什么作用？
  4. 网关有什么作用？
  5. 负载均衡怎么实现？
  6. 熔断、限流、降级分别是什么？
  7. 服务调用超时怎么处理？
  8. RPC 和 HTTP 的区别？

10.2 分布式事务 / 一致性

  1. 分布式事务有哪些解决方案？
  2. 2PC、3PC、TCC、SAGA 分别是什么？
  3. 本地消息表方案是什么？
  4. 最终一致性如何保证？
  5. 幂等设计怎么做？
  6. 分布式系统中为什么要引入唯一 ID？常见方案有哪些？
  7. 雪花算法是什么？有什么问题？

10.3 分布式锁 / 分布式缓存

  1. 分布式锁有哪些实现方式？
  2. 用 Redis 做分布式锁要注意什么？
  3. 用数据库做分布式锁有什么问题？
  4. 分布式 Session 怎么解决？
  5. CAP 理论和 BASE 理论是什么？

11）设计模式 / 系统设计经典题

  1. 单例模式有哪几种写法？哪种最好？
  2. 工厂模式、抽象工厂模式、策略模式分别适合什么场景？
  3. 代理模式和装饰器模式的区别？
  4. 观察者模式在实际开发中怎么用？
  5. 模板方法模式的应用场景是什么？
  6. 责任链模式在 Spring 中有哪些体现？
  7. 设计一个秒杀系统需要考虑什么？
  8. 设计一个排行榜系统怎么做？
  9. 设计一个延迟任务系统怎么做？
  10. 设计一个分布式 ID 系统怎么做？
  11. 设计一个支付系统要注意哪些问题？
  12. 如何设计一个高并发下单系统？

12）项目场景题 / 面试官最喜欢追问的实战题

这部分是最能拉开差距的，很多公司最后都会落到这些题。

12.1 性能优化类

  1. 你做过最有价值的一次 SQL 优化是什么？
  2. 遇到慢 SQL 你是如何排查的？
  3. 线上 CPU 飙高怎么排查？
  4. 线上内存泄漏怎么排查？
  5. Full GC 频繁怎么定位？
  6. Redis 热点 key 怎么处理？
  7. 消息积压怎么处理？
  8. 大促 / 高并发时你做过哪些优化？

12.2 业务设计类

  1. 如果让你设计一个优惠券系统，你会怎么设计？
  2. 如果让你设计一个库存扣减系统，如何避免超卖？
  3. 订单重复提交如何解决？
  4. 支付回调如何保证幂等？
  5. 如何实现一个“60 秒后开奖 / 抓捕”的游戏逻辑？
  6. 如何设计一个操作日志系统？
  7. 如果一个接口 200ms 只能返回 200 条数据，怎么优化到 500ms 返回 1000 条？

12.3 稳定性类

  1. 服务突然大量报超时，你怎么排查？
  2. 某个接口 RT 突然从 50ms 升到 2s，怎么办？
  3. 数据库连接池打满怎么处理？
  4. 某个线程池队列积压严重怎么处理？
  5. 第三方接口不稳定时怎么做隔离？
  6. 如何防止一个下游服务把整个系统拖垮？

如果按“Java后端面试八股”来背，最重要的 50 题是这些

如果你时间不多，优先把下面这些吃透：

Java / 集合

  1. HashMap 底层原理，JDK1.7 vs 1.8
  2. ConcurrentHashMap 原理
  3. ArrayList 扩容机制
  4. String 为什么不可变
  5. equals 和 hashCode

并发

  1. synchronized 原理
  2. volatile 原理
  3. CAS 和 ABA 问题
  4. AQS 原理
  5. ReentrantLock 原理
  6. CountDownLatch / Semaphore / CyclicBarrier
  7. 线程池参数和执行流程
  8. ThreadLocal 原理和内存泄漏

JVM

  1. JVM 内存结构
  2. 对象什么时候进入老年代
  3. GC Root 是什么
  4. CMS 和 G1 的区别
  5. 类加载过程
  6. 双亲委派模型
  7. Full GC 排查

Spring

  1. Bean 生命周期
  2. Spring 循环依赖与三级缓存
  3. AOP 原理
  4. Spring 事务传播行为
  5. @Transactional 失效场景
  6. JDK 动态代理和 CGLIB 区别
  7. Spring Boot 自动配置原理

MySQL

  1. InnoDB 和 MyISAM 区别
  2. 聚簇索引和二级索引
  3. B+ 树为什么适合数据库索引
  4. 最左前缀原则
  5. 覆盖索引、回表、索引下推
  6. SQL 优化思路
  7. explain 关键字段
  8. 事务隔离级别
  9. MVCC 原理
  10. undo log / redo log / binlog
  11. 行锁、间隙锁、临键锁
  12. 死锁排查

Redis

  1. Redis 为什么快
  2. 缓存穿透 / 击穿 / 雪崩
  3. Redis 分布式锁
  4. RDB 和 AOF
  5. Redis 主从复制、哨兵、集群
  6. 热 key / 大 key 治理

MQ / 分布式

  1. 如何保证消息不丢失
  2. 如何保证幂等消费
  3. 如何保证顺序消息
  4. 分布式事务方案
  5. 分布式锁与 CAP / BASE

给你的建议：怎么准备最有效

如果你的目标是Java后端 / 中高级开发 / 面试跳槽，建议按这个顺序复习：

第一阶段：先打牢 4 大核心

  1. MySQL
    • 索引
    • 事务
    • 锁
    • SQL优化
  2. Redis
    • 缓存三大问题
    • 持久化
    • 分布式锁
    • 集群
  3. 并发
    • synchronized / volatile / CAS / AQS / 线程池
  4. Spring
    • IOC / AOP / 事务 / 循环依赖 / 自动配置

第二阶段：再补 JVM + MQ + 微服务

  • JVM 内存结构 / GC / 类加载 / 调优
  • MQ 消息可靠性、顺序性、幂等
  • 微服务注册中心、网关、配置中心、分布式事务

第三阶段：准备“项目亮点回答”

你一定要准备 5 类项目题：

  1. 你做过的最难问题是什么
  2. 你做过的性能优化案例
  3. 你做过的高并发设计
  4. 你处理过的线上故障
  5. 你负责过的系统稳定性治理

我可以继续直接帮你整理成“真正能背的面试题答案版”

如果你愿意，我下一条可以直接给你一份：

《Java面试八股文终极版（带标准答案）》

我会按下面格式写，每题都给你“面试可直接背”的答案：

  • HashMap 底层原理
  • ConcurrentHashMap 原理
  • synchronized 原理
  • AQS 原理
  • 线程池原理
  • JVM 内存模型
  • Spring 循环依赖
  • Spring 事务失效场景
  • MySQL 索引 / MVCC / 锁
  • Redis 缓存三兄弟 / 分布式锁
  • MQ 消息可靠性 / 幂等 / 顺序性

如果你要的话，你直接回复我一句：

“按阿里面试风格，给我整理 Java 面试题 + 标准答案”

posted on 2026-07-05 16:09  日思日睿  阅读(16)  评论(0)    收藏  举报