2026年Java面试八股文(完整版)

1. JVM运行时数据区

   • 线程私有区：
     1. 虚拟机栈：每次调用方法都会在虚拟机栈中产生一个栈帧，每个栈帧中都有方法的参数、局部变量、方法出口等信息，方法执行完毕后释放栈帧
     2. 本地方法栈：为native修饰的本地方法提供的空间，在HotSpot中与虚拟机合二为一
     3. 程序计数器：保存指令执行的地址，方便线程切回后能继续执行代码
   • 线程共享区
     1. 堆内存：Jvm进行垃圾回收的主要区域，存放对象信息，分为新生代和老年代
     2. 方法区：存放类信息、静态变量、常量、运行时常量池等信息。JDK1.8之前用持久代实现，JDK1.8后用元空间实现，元空间使用的是本地内存，而非在JVM内存结构中

2. 什么情况下会内存溢出

   • 堆内存溢出：
     1. 当对象一直不停的创建而不被回收时
     2. 加载的类越来越多时
     3. 虚拟机栈的线程越来越越多时
   • 栈溢出： 方法调用次数过多，一般递归不当造成

3. JVM有哪些垃圾回收算法

   1. 标记清除算法： 标记不需要回收的对象，然后清除没有标记的对象，会造成许多内存碎片。
   2. 复制算法： 将内存分为两块，只使用一块，进行垃圾回收时，先将存活的对象复制到另一块区域，然后清空之前的区域。用在新生代
   3. 标记整理算法： 与标记清除算法类似，但是在标记之后，将存活对象向一端移动，然后清除边界外的垃圾对象。用在老年代

4. GC如何判断对象可以被回收

   1. 引用计数法：已淘汰，为每个对象添加引用计数器，引用为0时判定可以回收；这个可能会出现两个对象相互引用无法回收的问题
   2. 可达性分析法：从GCRoot开始往下搜索，搜索过的路径称为引用链，若一个对象GCRoot没有任何的引用链，则判定可以回收
   • GCRoot有：虚拟机栈中引用的对象，方法区中静态变量引用的对象，本地方法栈中引用的对象

5. 典型垃圾回收器
   G1 ：JDK1.9以后的默认垃圾回收器，支持并发，采用标记整理+复制算法，注重响应速度

6. 类加载器和双亲委派机制

   从父类加载器到子类加载器分别为：

   • BootStrapClassLoader 加载路径为：JAVA_HOME/jre/lib
   • ExtensionClassLoader 加载路径为：JAVA_HOME/jre/lib/ext
   • ApplicationClassLoader 加载路径为：classpath

   还有一个自定义类加载器

   当一个类加载器收到类加载请求时，会先把这个请求交给父类加载器处理，若父类加载器找不到该类，再由自己去寻找。该机制可以避免类被重复加载，还可以避免系统级别的类被篡改

篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc

需要全套面试笔记及答案【点击此处即可/免费获取】​https://docs.qq.com/doc/DQXdYWE9LZ2ZHZ1ho

1. 类加载过程

   1. 加载：加载字节码文件，将字节码中的静态变量和常量转换到方法区，在堆中生成class对象作为方法区入口
   2. 连接：
      • 验证：验证字节码文件的正确性
      • 准备：正式为类变量在方法区中分配内存，并设置初始值
      • 解析：将符号引用解析为直接的一个引用（类在实际内存中的地址）
   3. 初始化：执行类构造器（这里不是常规的构造方法），为静态变量赋值并初始化静态代码块

2. JVM中有哪些引用
   强引用：new的对象。哪怕内存溢出也不会回收
   软引用：只有内存不足时才会回收
   弱引用：每次垃圾回收都会回收（例如：ThreadLocal中的key）
   虚引用：必须配合引用队列使用，一般用于追踪垃圾回收动作

3. 对象头中有哪些信息
   对象头中有两部分，一部分是MarkWork,存储对象运行时的数据，如GC分代年龄、GC标记、锁的状态、线程ID等；另外一部分是指向对象类型的指针，如果是数组，还有一个部分存放数组长度

4. JVM内存参数
   -Xmx[]: 堆空间最大内存
   -Xms[]: 堆空间最小内存，一般设置成跟堆空间最大内存一样的
   -Xmn[]: 新生代的最大内存
   -xx[use 垃圾回收器名称]：指定垃圾回收器
   -xss: 设置单个线程栈大小
   一般设堆空间为最大可用物理地址的百分之80

5. JVM类初始化顺序
   父类静态代码块和静态成员变量->子类静态代码块和静态成员变量->父类代码块和普通成员变量->父类构造方法->子类代码块和普成员变量->子类构造方法

四、Mysql

1. MyIAm和InnoDB的区别
   InnoDB支持事务，MyIAm不支持
   InnoDB支持外键，MyIAm不支持
   InnoDB是聚簇索引，MyIAm是非聚簇索引
   InnoDB支持行锁和表锁，MyIAm只支持表锁
   InnoDB不支持全文索引，MyIAm支持
   InnoDB支持自增和MVCC模式的读写，MyIAm不支持

2. Mysql事务特性

   原子性：一个事务内的操作要么成功要么失败会滚，不存在中间状态
   一致性：事务前后的数据总量不变，也就是说一个事务执行之前和执行之后都必须处于一致性状态
   隔离性：是指多个事务并发执行的时候，事务与事务之间相互不影响
   持久性：事务一旦提交发生的改变不可逆的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作

3. 事务靠什么保证

   • 原子性：由undolog日志保证，他记录了需要回滚的日志信息，回滚时撤销已执行的sql
   • 一致性：由其他三大特性共同保证，是事务的目的
   • 隔离性：由MVCC保证
   • 持久性：由redolog日志和内存保证，mysql修改数据时内存和redolog会记录操作，宕机时可恢复

4. 事务的隔离级别
   在高并发情况下，并发事务会产生脏读、不可重复读、幻读问题，这时需要用隔离级别来控制
   1、脏读
   出现原因：一个事务读取到了缓存中另一个事务未提交的脏数据。
   (说明：当事务B对data进行了修改但是未提交事务，此时事务A对data进行读取，并使用事务B修改的数据做业务处理。)
   2、幻读
   出现原因：一个事务在读取数据时，另一个事务插入了数据，导致上个事务第二次读取数据时，数据不一致。
   (说明：data 表有一条数据，事务A对data进行读取， 事务B对data进行数据新增 ，此时事务A读取只有一条数据，而最后实际data是有两条数据，就好象发生了幻觉一样情况成为幻读)
   3、不可重复读
   出现原因：读取数据的同时可以进行修改
   (说明：事务A、事务B同时对data进行访问，事务A对data进行读取，事务B对data进行修改，当事务A第一次对data进行读取完后事务B提交，此时当事务A第二次读取该数据时的数据就与第一次读取的数据不同，这种情况称为不可重复读)

   • read_uncommitted（读未提交）：可读取未提交事务的操作数据，最低的隔离级别，一般都没有用的。这种情况会出现脏读。
   • read_committed（读已提交）：一个事务等另一个事务提交之后才可进行读取，解决了脏读问题，但会出现不可重复读
   • repeatable_read（可重复读）：读取事务开启的时候不能对数据进行修改，解决了不可重复读问题，但是存在幻读问题
   • serializable（序列化）：是最高的事务隔离级别，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用

5. 什么是快照读和当前读

   • 快照读：读取的是当前数据的可见版本，可能是会过期数据，不加锁的select就是快照读
   • 当前读：读取的是数据的最新版本，并且当前读返回的记录都会上锁，保证其他事务不会并发修改这条记录。如update、insert、delete、select for undate（排他锁）、select lockin share mode（共享锁） 都是当前读

6. MVCC是什么

   MVCC是多版本并发控制，为每次事务生成一个新版本数据，每个事务都由自己的版本，从而不加锁就决绝读写冲突，这种读叫做快照读。只在读已提交和可重复读中生效。
   实现原理由四个东西保证，他们是

   • undolog日志：记录了数据历史版本
   • readView: 事务进行快照读时产生的视图，记录了当前系统中活跃的事务id，控制哪个历史版本对当前事务可见
   • 隐藏字段DB_TRC_ID： 最近修改记录的事务ID
   • 隐藏字段DB_Roll_PTR： 回滚指针，配合undolog指向数据的上一个版本

7. MySQL有哪些索引

   • 主键索引：一张表只能有一个主键索引，主键索引列不能有空值和重复值
   • 唯一索引：唯一索引不能有相同值，但允许为空
   • 普通索引：允许出现重复值
   • 组合索引：对多个字段建立一个联合索引，减少索引开销，遵循最左匹配原则
   • 全文索引：myisam引擎支持，通过建立倒排索引提升检索效率，广泛用于搜索引擎

8. 聚簇索引和非聚簇索引的区别

   • 聚簇索引：将索引和值放在了一起，根据索引可以直接获取值，如果主键值很大的话，辅助索引也会变得很大
   • 非聚簇索引：叶子节点存放的是数据行地址，先根据索引找到数据地址，再根据地址去找数据

   他们都是b+数结构

9. B和B+数的区别，为什么使用B+数

   • 二叉树：索引字段有序，极端情况会变成链表形式
   • AVL数：树的高度不可控
   • B数：控制了树的高度，但是索引值和data都分布在每个具体的节点当中，若要进行范围查询，要进行多次回溯，IO开销大
   • B+树：非叶子节点只存储索引值，叶子节点再存储索引+具体数据，从小到大用链表连接在一起，范围查询可直接遍历不需要回溯

10. MySQL有哪些锁

    • 基于粒度：

      1. 表级锁：对整张表加锁，粒度大并发小
      2. 行级锁：对行加锁，粒度小并发大
      3. 间隙锁：间隙锁，锁住表的一个区间，间隙锁之间不会冲突只在可重复读下才生效，解决了幻读

    • 基于属性：

      1. 共享锁：又称读锁，一个事务为表加了读锁，其它事务只能加读锁，不能加写锁
      2. 排他锁：又称写锁，一个事务加写锁之后，其他事务不能再加任何锁，避免了脏读问题

11. MySQL如果做慢查询优化

    1. 分析sql语句，是否加载了不需要的数据列
    2. 分析sql执行计划，字段有没有索引，索引是否失效，是否用对索引
    3. 表中数据是否太大，是不是要分库分表

篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc

需要全套面试笔记及答案【点击此处即可/免费获取】​https://docs.qq.com/doc/DQXdYWE9LZ2ZHZ1ho

1. 哪些情况索引会失效

   1. where条件中有or，除非所有查询条件都有索引，否则失效
   2. like查询用%开头，索引失效
   3. 索引列参与计算，索引失效
   4. 违背最左匹配原则，索引失效
   5. 索引字段发生类型转换，索引失效
   6. mysql觉得全表扫描更快时（数据少），索引失效

2. Mysql内连接、左连接、右链接的区别

   • 内连接(inner join)：结合两张表的记录，返回相关的查询结果，返回的是两个表的交集部分。
     select * from A a inner join B b on a.id=b.id
   • 左连接(left join)：左连接查询，左表的信息全部展示出来，右表只会展示符合搜索条件的信息，不足的地方记为NULL
     select * from A a left join B b on a.id=b.id
   • 右连接(rigth join)：右连接查询，右表的信息全部展示出来，左表只会展示符合搜索条件的信息，不足的地方记为NULL
     select * from A a right join B b on a.id=b.id

五、Spring系列

1. Bean的作用域

   1. Singleton:一个IOC容器只有一个
   2. Prototype:每次调用getBean()都会生成一个新的对象
   3. request:每个http请求都会创建一个自己的bean
   4. session:同一个session共享一个实例
   5. application:整个serverContext只有一个bean
   6. webSocket:一个websocket只有一个bean

2. Bean的生命周期

   1. 通过构造方法创建bean实例（无参构造）
   2. 为bean的属性设置值和对其它bean引用（调用set方法）
   3. 把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
   4. 调用bean的初始化方法（需要进行配置初始化的方法）
   5. 把bean实例传递bean后置处理的方法postProcessAfterInitialization
   6. bean可以使用了（对象获取到了）
   7. 当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）

   如果没有配置后置处理器，bean的生命周期将没有3和5

3. Spring 事务原理
   spring事务有编程式和声明式，我们一般使用声明式，在某个方法上增加@Transactional注解，这个方法中的sql会统一成功或失败

   • 原理是：
     • 当一个方法加上@Transactional注解，spring会基于这个类生成一个代理对象并将这个代理对象作为bean，当使用这个bean中的方法时，如果存在@Transactional注解，就会将事务自动提交设为false，然后执行方法，执行过程没有异常就会提交，有异常就会回滚

4. spring事务失效场景

   1. 事务方法所在的类没有加载到容器中
   2. 事务方法不是public类型
   3. 同一类中，一个没有添加事务的方法调用另外以一个添加事务的方法，事务不生效
   4. spring事务默认只回滚运行时异常，可以用rollbackfor属性设置
   5. 业务自己捕获了异常，那么事务会认为程序正常秩序

5. spring事务的隔离级别
   default:默认级别，使用数据库自定义的隔离级别
   其它四种隔离级别与mysql一样

6. spring事务的传播行为

   • spring的7种传播行为：
     1. required：(默认传播行为)，它是Spring里面默认的事务传播行为，也就新当前存在事务就加入到当前事务去执行，如果不存在事务就创建一个事务
        例如：方法A调用方法B，它们用同一个事务。(如果B没有事务，它们会用同一个事务。)(只要有一个回滚，整体就会回滚)
     2. requires_new：它不管是否存在事务，它都会新开启一个事务来执行，新老事务相互独立的，外部事务抛出异常，并不会影响内部事务的一个正常提交
        例如：方法A调用方法B，它们用不同的事务。(B不会用A的事务，会新增事务。)
     3. supports:表示支持当前的事务，如果当前不存在事务，就以非事务的方式去执行
        例如：方法A调用方法B，如果A没有事务，那么B就以非事务运行。
        如果A有事务就以A事务为准。如果A没有事务，那么B就会以非事务执行。
     4. mandatory:它是一个强制的事务执行，如果当前不存在事务就抛出一个异常
        支持当前事务，如果当前没有事务就会抛出异常。
        例如：方法A调用方法B，如果方法A没有事务，那么就会抛出异常。
     5. not_supported：表示以非事务的方式来运行，如果当前存在事务，就需要把当前的事务挂起来。
        例如：方法A调用方法B，方法B会挂起事务A以非事务方式执行。
     6. never:就是以非事务执行，如果存在事务，抛出异常。
        总是以非事务执行，如果存在事务，那么就抛出异常。
     7. nested:如果当前存在事务，就嵌套当前事务中去执行，如果当前没有事务，那么就新建一个事务，类似 requires_new这个样一个传播行为
        例如：方法A中调用了方法B，B中try catch手动回滚，A不会回滚。

7. Spring IoC

   • IOC（Inversion of Control 即控制反转）将对象交给容器管理
     我们要考虑：谁控制谁控制什么？为了是反转？哪些方面反转？

     • 是容器控制了对象
     • 主要控制了外部资源及生命周期
     • 由容器帮我们查找并注入依赖的对象，对象只能被动的接收依赖对象，依赖对象的获取被反转了

   • spring中提供了一种IOC容器，来控制对象的创建，无论是你创建对象，处理对象之间的依赖关系，对象的创建时间还是对象的创建数量，都是spring提供IOC容器上配置对象的信息就可以了。

   • IOC能做什么: 由IOC容器帮对象找相应的依赖思想并注入，并不是由对象主动去找资源集中管理，实现资源的可配置和易管理降低了使用资源双方的依赖程度，解耦合

8. spring用了哪些设计模式

   1. 简单工厂模式
      • spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定
   2. 工厂方法模式
      • 通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离,采用工厂模式,即应用程序将对象的创建及初始化职责交给工厂对象。
      • 一般情况下,应用程序有自己的工厂对象来创建bean.如果将应用程序自己的工厂对象交给Spring管理,那么Spring管理的就不是普通的bean,而是工厂Bean。
   3. 单例模式
      • 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
      • spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。
   4. 适配器模式
      在Spring的Aop中，使用的Advice(通知)来增强被代理类的功能。Spring实现这一AOP功能的原理就使用代理模式对类进行方法级别的切面增强，即，生成被代理类的代理类， 并在代理类的方法前，设置拦截器，通过执行拦截器重的内容增强了代理方法的功能，实现的面向切面编程。
   5. 包装器模式
      spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。
      6.代理模式
      为其他对象提供一种代理以控制对这个对象的访问。 从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。
      7.观察者模式
      定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
      8.策略模式
      定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。这个模式使得了算法可独立于使用他的客户而变化。

篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc

需要全套面试笔记及答案【点击此处即可/免费获取】​https://docs.qq.com/doc/DQXdYWE9LZ2ZHZ1ho

1. springboot常用注解

   @RestController ：修饰类，该控制器会返回Json数据
   @RequestMapping(“/path”) ：修饰类，该控制器的请求路径
   @Autowired : 修饰属性，按照类型进行依赖注入
   @PathVariable : 修饰参数，将路径值映射到参数上
   @ResponseBody :修饰方法，该方法会返回Json数据
   @RequestBody（需要使用Post提交方式） :修饰参数，将Json数据封装到对应参数中
   @Controller@Service@Compont: 将类注册到ioc容器