未命名

Java 基础（总结：涵盖Java核心特性、开发环境组成、基础语法及面向对象基础）

基础概念与常识（总结：讲解Java语言核心概念与基础常识）

Java 语言有哪些特点（总结：面向对象特性（封装隐藏实现细节、继承实现代码复用、多态提高灵活性）；平台无关性（通过JVM解释字节码实现跨平台）；可靠性（异常处理+GC自动内存管理）；安全性（访问修饰符限制+API隔离系统资源）；高效性（JIT编译器优化热点代码））

封装（总结：通过访问控制符保护数据，隐藏实现细节，提高可维护性）

继承（总结：代码复用机制，子类扩展父类功能，单继承结构）

多态（总结：同一接口不同实现，方法重写+接口实现，提高代码扩展性）

JVM vs JDK vs JRE（总结：JVM执行字节码实现跨平台；JDK包含开发工具+JRE；JRE包含运行环境类库；JDK9+采用模块化替代传统结构）

什么是字节码？采用字节码的好处是什么？（总结：.class中间码，JVM跨平台基础；结合解释执行+JIT编译提升效率，实现"一次编译到处运行"）

AOT 有什么优点？为什么不全部使用 AOT 呢？（总结：提升启动速度+减少内存占用，但无法支持反射等动态特性，JDK17移除实验性实现，转向静态镜像技术）

Java 和 C++ 的区别（总结：无指针保证内存安全；单继承+接口多继承；自动GC；不支持操作符重载；无全局变量）

基本语法（总结：语言基础元素与结构）

注释有哪几种形式？（总结：单行//、多行/* /、文档/* */，用于代码说明与文档生成）

标识符和关键字的区别是什么？（总结：标识符是用户定义名称，关键字是语言保留的特殊含义词汇）

Java 语言关键字有哪些？（总结：包含访问控制、类修饰、流程控制、异常处理等8类共53个关键字）

自增自减运算符（总结：前缀先运算后使用，后缀先使用后运算）

基本数据类型（总结：8种基本类型及包装类机制）

Java 中的几种基本数据类型了解么？（总结：6种数字类型（byte/short/int/long + float/double）+ char + boolean）

基本类型和包装类型的区别？（总结：默认值差异、存储位置不同（栈/堆）、包装类支持泛型与null、自动装箱拆箱机制）

包装类型的缓存机制了解么？（总结：数值类缓存-128~127，Boolean缓存true/false，Character缓存0-127）

自动装箱与拆箱了解吗？原理是什么？（总结：自动调用valueOf()和xxxValue()，需注意频繁操作的性能损耗）

如何解决浮点数运算的精度丢失问题？（总结：使用BigDecimal进行精确计算，避免float/double直接运算）

变量（总结：变量类型与作用域）

成员变量与局部变量的区别？（总结：声明位置、存储方式（堆/栈）、生命周期、默认值不同）

静态变量有什么作用？（总结：类级别共享，内存单次分配，通过类名直接访问）

字符型常量和字符串常量的区别（总结：单引号vs双引号；char是基本类型值，String是对象引用；内存占用差异）

方法（总结：函数定义与使用规范）

静态方法为什么不能调用非静态成员?（总结：静态方法加载时机早于对象实例化，无法访问未初始化的实例成员）

静态方法和实例方法有何不同？（总结：调用方式（类名/对象）、访问权限限制（静态方法只能访问静态成员））

重载和重写有什么区别？（总结：重载是同类同名不同参，编译期绑定；重写是子类覆盖父类方法，运行期动态绑定）

什么是可变长参数？（总结：方法参数声明为Xxx... args，编译后转为数组，需注意多个参数时的位置限制）

面向对象基础（总结：OOP核心概念与实现）

面向对象和面向过程的区别（总结：对象为中心组织代码 vs 过程为中心；强调数据封装 vs 算法流程）

创建一个对象用什么运算符？对象实体与对象引用有何不同？（总结：new运算符；对象实体在堆内存，引用是栈内存指针；参数传递为值传递引用地址）

创建对象的几种方式（总结：new、反射Class.newInstance()、clone()、反序列化、构造器对象、工厂模式、依赖注入等）

对象的相等和引用相等的区别（总结：equals()比较内容，==比较内存地址）

构造方法特点（总结：与类同名无返回值，对象初始化时执行，支持重载不可重写，默认提供无参构造）

面向对象三大特征（总结：封装（访问控制）、继承（extends）、多态（接口/父类引用指向子类对象））

接口和抽象类的共同点和区别？（总结：都不能实例化；接口强调行为契约（多实现），抽象类代码复用（单继承）；接口成员变量默认public static final，抽象类可普通变量；Java8+接口支持默认/静态方法）

Object（总结：所有类的基类方法）

Object 类的常见方法有哪些？（总结：11个核心方法包括getClass()、hashCode()、equals()、clone()、线程通信方法（wait/notify）、finalize()等）

== 和 equals() 的区别（总结：==比较值（基本类型）或地址（对象），equals()默认比较地址，可重写为内容比较）

hashCode() 有什么用？（总结：用于哈希表快速定位，需与equals()保持逻辑一致，相同对象必须相同hashCode）

为什么重写 equals() 时必须重写 hashCode() 方法？（总结：维护hashCode契约，保证哈希表存储的正确性）

String（总结：字符串处理机制）

String、StringBuffer、StringBuilder 的区别？（总结：String不可变（线程安全），后两者可变；StringBuffer线程安全（同步方法），StringBuilder非线程安全；性能Builder > Buffer > String）

String 为什么是不可变的?（总结：final char数组私有+无修改方法+防止子类破坏，保障哈希缓存安全性）

字符串拼接用 "+" 还是 StringBuilder?（总结：少量拼接用+（编译器优化），循环内拼接必须用StringBuilder避免多次创建对象）

字符串常量池的作用了解吗？（总结：避免重复创建，提升性能，直接赋值时优先使用池中对象）

String s1 = new String("abc"); 这句话创建了几个字符串对象？（总结：1或2个，常量池已有时1个（堆对象），无时2个（常量池+堆对象））

String.intern 方法有什么作用?（总结：将字符串对象放入常量池，返回池中引用，减少重复创建）

异常（总结：错误处理机制）

Java 异常类层次结构图（总结：Throwable <- Exception(checked/runtime) + Error）

Exception 和 Error 有什么区别？（总结：Exception程序可处理，Error系统级严重错误（如OOME））

Checked Exception 和 Unchecked Exception 有什么区别？（总结：Checked需显式处理（IOException），Unchecked不需处理（RuntimeException））

try-catch-finally 如何使用？（总结：try监控代码，catch捕获异常，finally必执行；注意资源关闭顺序与try-with-resources优化）

finally 中的代码一定会执行吗？（总结：正常情况下执行，但线程终止/JVM退出等情况不执行）

注解（总结：元数据标记机制）

何谓注解？（总结：代码级别标记，提供元数据信息，可用于编译检查、框架配置等场景）

注解的解析方法有哪几种？（总结：编译期处理（如@Override检查）、运行期反射解析（如Spring注解））

SPI（总结：服务发现机制）

何谓 SPI?（总结：接口与实现解耦，运行时动态加载，JDBC驱动加载典型案例）

SPI 的优缺点？（总结：优点灵活扩展，缺点全量加载效率低+并发安全问题）

I/O（总结：输入输出流体系）

Java IO 流了解吗？（总结：字节流（InputStream/OutputStream）处理二进制，字符流（Reader/Writer）处理文本，装饰器模式增强功能）

字节流和字符流区别（总结：字符流自动处理编码，避免乱码；字节流通用性强，字符流基于字节流+编码转换）

Java 泛型（总结：类型参数化机制）

泛型的使用方式（总结：泛型类、接口、方法，类型擦除实现，通配符? extends/super限定）

类型擦除（总结：编译后去泛型化，桥方法保持多态，无法用instanceof判断泛型类型）

Java 序列化（总结：对象持久化机制）

序列化协议（总结：JDK原生效率低，常用Hessian/Protobuf等二进制协议，JSON/XML文本协议可读性好性能差）

为什么不推荐使用 JDK 自带的序列化？（总结：安全问题（反序列化漏洞）、性能差、跨语言支持弱）

Java 反射（总结：运行时类型操作）

反射的优缺点（总结：灵活但破坏封装，性能略低，安全问题需注意）

反射实战（总结：获取Class对象的四种方式，反射API操作字段/方法/构造器）

Java 语法糖（总结：语法便捷性增强）

常见语法糖（总结：泛型、自动装箱、变长参数、内部类、foreach循环、try-with-resources、lambda等，编译时解糖）

Java 值传递（总结：参数传递机制）

值传递原理（总结：基本类型传值副本，引用类型传地址副本，方法内修改引用指向不影响原对象）

Java 代理模式（总结：结构型设计模式）

动态代理实现（总结：JDK动态代理（接口代理）vs CGLIB（类代理），Spring AOP默认组合使用）

BigDecimal（总结：精确计算类）

使用注意事项（总结：用String构造避免精度丢失，比较用compareTo()，运算设置精度+舍入模式）

Unsafe（总结：底层操作类）

核心功能（总结：直接内存操作、CAS原子操作、线程调度、类实例化绕过构造等，需谨慎使用）

SPI 机制（总结：服务加载规范）

SPI 实现原理（总结：META-INF/services接口全限定名文件声明实现类，ServiceLoader加载）

Java 集合（总结内容：Java集合分为Collection和Map两大接口，Collection下分List、Set、Queue子接口）

集合概述（总结内容：集合框架由数组和链表等数据结构实现，提供动态存储和多样化数据操作能力）

Java 集合概览（总结内容：Collection存储单一元素，Map存储键值对；List有序可重复，Set无序唯一，Queue按规则排序）

说说List，Set，Queue，Map四者的区别（总结内容：List维护顺序，Set保证唯一性，Queue按规则排队，Map通过key搜索）

集合框架底层数据结构总结（总结内容：ArrayList用数组，LinkedList用双向链表；HashSet基于HashMap，TreeSet用红黑树；HashMap数组+链表/红黑树）

List（总结内容：ArrayList和Vector用数组，LinkedList用双向链表）

Set（总结内容：HashSet依赖HashMap，LinkedHashSet维护插入顺序，TreeSet基于红黑树排序）

Queue（总结内容：PriorityQueue用小顶堆，ArrayDeque用动态双向数组）

Map（总结内容：JDK8后HashMap链表转红黑树优化查询，LinkedHashMap维护访问顺序，TreeMap用红黑树排序）

如何选用集合（总结内容：根据键值需求选Map，元素唯一性用Set，顺序访问用List；线程安全场景用ConcurrentHashMap）

为什么要使用集合（总结内容：集合提供动态扩容、泛型支持、内置算法，比数组更灵活高效）

List（总结内容：List接口实现类处理有序元素集合，重点关注ArrayList和LinkedList特性）

ArrayList简介（总结内容：基于动态数组实现，支持快速随机访问，实现RandomAccess和序列化接口）

ArrayList和Array的区别（总结内容：ArrayList动态扩容、支持泛型、只能存对象；Array长度固定、可存基本类型）

ArrayList和Vector的区别（总结内容：ArrayList非线程安全性能高，Vector线程安全但已过时）

Vector和Stack的区别（总结内容：Stack继承Vector实现栈结构，两者都被并发集合替代）

ArrayList可以添加null值吗（总结内容：允许存储null但增加代码维护难度）

ArrayList插入和删除元素的时间复杂度（总结内容：头部操作O(n)，尾部操作O(1)，指定位置操作平均O(n)）

LinkedList简介（总结内容：基于双向链表实现，适合频繁插入删除场景）

LinkedList插入删除时间复杂度（总结内容：头尾操作O(1)，指定位置操作O(n)）

LinkedList为什么不能实现RandomAccess接口（总结内容：链表结构不支持索引快速访问）

ArrayList与LinkedList区别（总结内容：ArrayList随机访问快，LinkedList插入删除快；内存占用各有优劣）

ArrayList扩容机制（总结内容：初始容量10，扩容1.5倍，首次添加元素时初始化数组）

Set（总结内容：Set接口实现类处理唯一元素集合，依赖equals和hashCode方法）

Comparable和Comparator的区别（总结内容：Comparable内置排序，Comparator扩展多种排序规则）

无序性和不可重复性（总结内容：无序指存储顺序不等于添加顺序，不可重复依赖hashCode和equals判断）

比较HashSet、LinkedHashSet和TreeSet（总结内容：HashSet最快无序，LinkedHashSet维护插入顺序，TreeSet支持排序）

Queue（总结内容：队列接口实现先进先出或优先级处理，包含双端队列Deque）

Queue与Deque的区别（总结内容：Queue单端操作，Deque支持双端插入删除）

ArrayDeque与LinkedList的区别（总结内容：ArrayDeque数组实现更高效，LinkedList支持null值但性能低）

PriorityQueue（总结内容：基于小顶堆实现优先级队列，时间复杂度O(logn)）

BlockingQueue（总结内容：线程安全阻塞队列，用于生产者-消费者模型）

Map（总结内容：键值对存储结构，HashMap为核心实现类）

HashMap和Hashtable的区别（总结内容：HashMap非线程安全效率高，Hashtable线程安全过时；Null值处理策略不同）

HashMap和HashSet区别（总结内容：HashSet基于HashMap实现，仅存储key）

HashMap和TreeMap区别（总结内容：HashMap无序高效，TreeMap支持自然/定制排序）

HashSet检查重复机制（总结内容：先比较hashCode，再equals验证）

HashMap底层实现（总结内容：JDK8前数组+链表，JDK8后链表转红黑树优化查询）

HashMap长度为什么是2的幂（总结内容：位运算代替取模，扩容时均匀分布元素）

HashMap多线程死循环问题（总结内容：JDK7头插法导致环形链表，JDK8改用尾插法）

HashMap线程不安全原因（总结内容：多线程扩容导致数据覆盖/丢失）

ConcurrentHashMap和Hashtable区别（总结内容：分段锁/CAS+synchronized实现高效并发）

ConcurrentHashMap线程安全实现（总结内容：JDK8用Node+CAS+synchronized，锁粒度细化到桶）

ConcurrentHashMap禁止null值（总结内容：避免二义性判断键值是否存在）

Collections工具类（总结内容：提供排序、查找、同步控制等方法）

Java集合使用注意事项（总结内容：推荐isEmpty判空，避免foreach删除元素，用Set去重，注意集合转数组类型匹配）

JVM（总结：Java虚拟机核心概念，涵盖内存管理、垃圾回收、类加载机制及性能调优工具。）

JVM 内存区域详解（总结：JVM内存划分为多个逻辑区域，包括程序计数器、虚拟机栈、堆、方法区等，各区域功能与生命周期不同。）

运行时数据区域（总结：JVM运行时的核心内存区域，分为线程私有和共享区域，管理方法调用、对象存储及类元数据。）

程序计数器（总结：线程私有，记录当前线程执行字节码的行号，确保线程切换后能正确恢复执行位置。）

Java 虚拟机栈（总结：线程私有，存储方法调用的栈帧，包含局部变量表、操作数栈等，可能引发StackOverflowError和OOM。）

局部变量表（总结：存储方法内的局部变量，包括基本类型和对象引用，编译期确定大小。）

操作数栈（总结：方法执行时的临时数据存储区，用于计算和参数传递，遵循后进先出原则。）

动态链接（总结：将符号引用转换为直接引用，支持方法调用时的动态绑定。）

StackOverFlowError（总结：栈深度超过限制时抛出，常见于无限递归或过深方法调用。）

栈帧生命周期（总结：随方法调用创建，方法结束（正常返回或异常）时销毁。）

OutOfMemoryError（总结：栈内存扩展失败时抛出，通常因线程过多或栈设置过大导致。）

本地方法栈（总结：为Native方法服务，功能类似虚拟机栈，HotSpot中与虚拟机栈合并。）

堆（总结：最大内存区域，线程共享，存放对象实例，分新生代和老年代，GC主要管理区域。）

为什么年龄只能是 0-15？（总结：对象头中年龄占4位，最大值为15，超过则晋升老年代。）

方法区（总结：逻辑区域，存储类信息、常量、静态变量，JDK8后由元空间实现，使用本地内存。）

方法区和永久代以及元空间是什么关系呢？（总结：永久代和元空间是方法区的不同实现，元空间避免永久代内存限制，提升GC效率。）

为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) 呢？（总结：解决永久代内存溢出、GC效率低及与JRockit整合问题。）

运行时常量池（总结：方法区的一部分，存储编译期生成的符号引用和字面量，可能触发OOM。）

字符串常量池（总结：堆中特殊区域，避免重复创建字符串，JDK7后移至堆以提升回收效率。）

直接内存（总结：堆外内存，通过NIO的DirectByteBuffer操作，不受JVM内存限制，但可能引发OOM。）

HotSpot 虚拟机对象探秘（总结：对象创建、内存布局及访问定位机制，涉及类加载、内存分配和访问优化。）

对象的创建（总结：过程包括类加载检查、内存分配、初始化、设置对象头和执行init方法，考虑线程安全与内存分配策略。）

类加载检查（总结：验证类是否已加载，未加载则触发类加载过程。）

分配内存（总结：根据堆是否规整选择指针碰撞或空闲列表分配，CAS和TLAB解决并发问题。）

内存分配的两种方式（总结：指针碰撞用于规整内存，空闲列表用于碎片内存，依赖GC算法特性。）

内存分配并发问题（总结：通过CAS+失败重试或TLAB（线程本地分配缓冲）保证线程安全。）

初始化零值（总结：对象内存分配后初始化为零值，确保实例字段无需显式初始化。）

设置对象头（总结：存储对象哈希码、GC年龄、锁状态等元数据，区分对象类型和状态。）

执行 init 方法（总结：执行构造函数初始化对象，完成真正可用的对象创建。）

对象的内存布局（总结：分为对象头（标记字段、类型指针）、实例数据和对齐填充，保证内存对齐。）

对象的访问定位（总结：通过句柄（稳定）或直接指针（高效）访问对象，HotSpot默认使用直接指针。）

JVM 垃圾回收详解（总结：管理对象生命周期，通过分代收集、垃圾判定算法及多种GC器实现内存自动回收。）

内存分配和回收原则（总结：对象优先在Eden分配，大对象直接进老年代，长期存活对象晋升，空间分配担保避免Minor GC失败。）

对象优先在 Eden 区分配（总结：新生代对象主要在Eden分配，空间不足触发Minor GC。）

大对象直接进入老年代（总结：避免大对象在新生代频繁复制，提升GC效率。）

长期存活的对象将进入老年代（总结：对象年龄计数器达阈值（默认15）后晋升，由-XX:MaxTenuringThreshold控制。）

主要进行 gc 的区域（总结：分代收集针对新生代（Minor GC）、老年代（Major GC）及整堆（Full GC），策略不同。）

空间分配担保（总结：Minor GC前检查老年代空间是否足够，避免Full GC频繁触发。）

死亡对象判断方法（总结：通过引用计数法（弃用）和可达性分析（GC Roots）判定对象存活，辅以引用类型区分。）

引用计数法（总结：简单但无法解决循环引用问题，未成为主流JVM实现方案。）

可达性分析算法（总结：通过GC Roots（栈、静态变量等）判定对象可达性，不可达对象标记为可回收。）

哪些对象可以作为 GC Roots 呢？（总结：包括虚拟机栈、静态变量、常量、同步锁持有对象等根引用。）

对象可以被回收，就代表一定会被回收吗？（总结：两次标记过程，finalize()方法给予对象自救机会，但不推荐依赖。）

三色标记算法（总结：通过白（未访问）、灰（处理中）、黑（已处理）标记对象状态，解决并发标记问题。）

引用类型总结（总结：强引用（不回收）、软引用（内存不足回收）、弱引用（GC即回收）、虚引用（跟踪回收状态）。）

强引用（Strong Reference）（总结：最常见引用，不回收，可能导致内存泄漏。）

软引用（Soft Reference）（总结：内存不足时回收，适合缓存场景。）

弱引用（Weak Reference）（总结：GC时立即回收，用于WeakHashMap等临时缓存。）

虚引用（Phantom Reference）（总结：无法通过引用访问对象，仅用于回收跟踪和资源清理。）

如何判断一个常量是废弃常量？（总结：常量池中常量无任何引用时，GC时被清理。）

如何判断一个类是无用的类？（总结：类无实例、加载器被回收、Class对象无引用，满足则可能被卸载。）

垃圾收集算法（总结：标记-清除（碎片）、复制（高效但浪费）、标记-整理（老年代）、分代收集（综合策略）。）

标记-清除算法（总结：标记并清除不可达对象，产生内存碎片，效率较低。）

复制算法（总结：新生代常用，Eden和Survivor区复制存活对象，避免碎片但内存利用率减半。）

标记-整理算法（总结：老年代适用，存活对象向一端移动，减少碎片但开销较大。）

分代收集算法（总结：按对象生命周期划分新生代和老年代，分别采用复制和标记整理/清除算法。）

垃圾收集器（总结：实现垃圾回收的具体组件，如G1、ZGC，追求低延迟、高吞吐或平衡。）

G1 垃圾收集器（总结：分区回收，优先处理高收益Region，适合大堆，通过Mixed GC平衡延迟与吞吐。）

ZGC 收集器（总结：低延迟（<10ms），染色指针和读屏障实现并发整理，支持TB级堆内存。）

JVM 类文件结构详解（总结：Class文件结构包含魔数、版本号、常量池等，定义字节码存储格式。）

Class 文件结构（总结：二进制格式，包含魔数、版本、常量池、访问标志等字段，支撑跨平台执行。）

JVM 类加载过程详解（总结：类从加载到卸载的生命周期，包括加载、链接、初始化等阶段，双亲委派模型保障安全。）

类的生命周期（总结：加载、验证、准备、解析、初始化、使用、卸载七阶段，连接含验证、准备、解析。）

类加载过程（总结：加载（二进制到方法区）、链接（验证、准备、解析）、初始化（执行clinit）。）

加载（总结：获取类二进制流，转换方法区数据结构，生成Class对象，触发类加载器机制。）

验证（总结：确保Class文件符合JVM规范，含文件格式、元数据、字节码、符号引用验证。）

文件格式验证（总结：检查魔数、版本号等，确保符合Class文件结构。）

符号引用验证（总结：解析阶段检查类、方法是否存在，防止非法访问。）

准备（总结：为类变量分配内存并初始零值（如static变量），final static变量直接赋值。）

解析（总结：符号引用转直接引用，解析类、字段、方法等常量池项。）

初始化（总结：执行类构造器clinit()，初始化静态变量和代码块，JVM保障线程安全。）

类加载器（总结：实现类加载的组件，包括Bootstrap、Extension、Application及自定义加载器。）

类加载器作用（总结：加载类到内存，生成Class对象，实现类动态加载和隔离。）

类加载器加载规则（总结：双亲委派模型，优先委派父加载器，避免重复加载，保障核心类安全。）

类加载器类型（总结：Bootstrap（C++实现）、Extension（加载扩展类）、Application（用户类路径）。）

自定义类加载器（总结：继承ClassLoader，重写findClass()，实现特定类加载逻辑如加密解密。）

类加载器应用场景（总结：热部署、模块化、OSGi，Tomcat隔离Web应用类加载。）

双亲委派模型（总结：层次化类加载机制，优先父加载器加载，避免重复并保护核心类库。）

双亲委派模型（总结：加载请求逐级委派，Bootstrap为顶级，确保基础类优先加载。）

双亲委派模型优势（总结：避免类重复加载、防止核心API篡改、保证类全局唯一性。）

打破双亲委派模型（总结：重写loadClass()，Tomcat等容器为隔离应用自定义加载器，线程上下文加载器实现逆向委托。）

类卸载（总结：Class对象被GC的条件：无实例、加载器回收、无引用，由自定义加载器加载的类可能卸载。）

JVM 参数详解（总结：配置堆、元空间、GC日志等参数，优化内存使用和垃圾回收效率。）

堆内存相关（总结：-Xms/-Xmx设置堆初始/最大，-Xmn新生代大小，-XX:MetaspaceSize调优元空间。）

垃圾收集相关（总结：配置GC日志路径、堆转储参数，分析OOM原因及GC行为。）

JDK 监控和故障处理工具（总结：提供命令行和可视化工具监控JVM状态，诊断性能问题。）

JDK 命令行工具（总结：jps（进程状态）、jstat（GC统计）、jmap（堆转储）、jstack（线程快照）等。）

JDK 可视化分析工具（总结：JConsole、VisualVM监控内存、线程、类加载，分析堆转储文件。）

JVM线上问题排查和性能调优案例（总结：通过GC日志、内存分析定位OOM、死锁，调整参数优化吞吐和延迟。）

GC（总结：通过调整堆大小、分代比例降低GC频率/停顿，小步调整避免内存波动。）

Java 新特性概览（总结内容：涵盖Java 8至21核心特性，重点为函数式编程、API增强及并发模型改进）

Java 8 新特性概览（总结内容：引入Lambda、Stream、Optional等，推动函数式编程）

Interface 接口（总结内容：支持默认/静态方法，与抽象类对比：接口定义规范，抽象类提供部分实现）

functional interface 函数式接口（总结内容：单抽象方法接口，@FunctionalInterface注解强制规范，支持Lambda表达式）

Lambda 表达式（总结内容：匿名函数简化代码，语法(参数)->表达式，替代匿名内部类，支持方法引用）

Lambda 语法格式（总结内容：参数列表→箭头→主体，支持省略括号和类型推断）

Lambda 作用（总结内容：简化集合操作、多线程编程，实现函数式编程风格）

Lambda 使用场景（总结内容：集合操作配合Stream，事件处理，并发任务传递）

Lambda 实战（总结内容：通过函数式接口参数传递行为，::操作符引用方法）

Lambda 注意事项（总结内容：外部变量隐式final，返回类型需匹配函数式接口）

Stream 流（总结内容：声明式数据操作API，惰性求值，支持并行处理）

Stream 操作（总结内容：中间操作（filter/map/sorted）链式调用，终端操作（collect/forEach）触发计算）

map() 和 flatMap() 有什么区别的？（总结内容：map返回新值集合，flatMap展平嵌套集合）​

Stream 特性（总结内容：不可变性、声明式编程、短路优化，并行流提升性能）

stream 实战（总结内容：过滤/映射/排序数据，并行流处理大数据集）

Stream 优势（总结内容：代码简洁、可读性高、支持并行，优化复杂数据处理）

Stream 局限性（总结内容：不适用索引控制场景，小数据性能不如循环）

Optional（总结内容：容器类避免NPE，提供空值安全操作，orElse/orElseGet处理空值）

Optional 特性（总结内容：不可变容器，函数式方法支持如map/filter）

Optional 用法（总结内容：ofNullable创建，isPresent判断，orElse获取值，链式处理嵌套对象）

Date-Time API（总结内容：替代Calendar/Date，LocalDate/LocalTime不可变线程安全，支持时区与格式转换）

Date-Time API 优势（总结内容：易读、线程安全、丰富操作方法，国际化支持）

Date-Time API 的主要核心类（总结内容：LocalDate（日期）、LocalTime（时间）、LocalDateTime（日期时间））

Java 17 新特性概览（总结内容：PRNG增强，移除实验性编译器）

JEP 356:增强的伪随机数生成器（总结内容：新接口统一PRNG算法，便于替换实现）

JEP 410:删除实验性的 AOT 和 JIT 编译器（总结内容：移除过时特性，简化JDK维护）

Java 21 新特性概览（总结内容：语法增强与并发模型革新，虚拟线程为核心）

JEP 430：字符串模板（预览）（总结内容：${}占位符嵌入变量，支持表达式计算，简化字符串拼接）

JEP 431：序列化集合（总结内容：Sequenced Collections定义顺序集合，提供首尾元素访问及反向视图）

JEP 439：分代 ZGC（总结内容：ZGC支持分代回收，默认关闭需配置，优化内存管理）

JEP 441：switch 的模式匹配（总结内容：case支持类型模式匹配，简化多条件分支处理）

JEP 444：虚拟线程（总结内容：轻量级线程解决平台线程资源瓶颈，适用于高并发I/O场景）

背景（总结内容：传统线程资源消耗大，虚拟线程降低创建开销，支持百万级并发）

虚拟线程的工作原理（总结内容：JVM调度托管，平台线程驱动执行，协作式多任务让出控制权）

使用方法（总结内容：Thread.ofVirtual创建，Executors虚拟线程池，复用Thread API平滑过渡）

Java 并发编程（总结：介绍Java并发编程的核心概念，涵盖线程、进程、同步机制、锁、线程池、内存模型等内容。）

线程（总结：线程是轻量级执行单位，共享进程资源，拥有独立的程序计数器、栈等结构，生命周期包括多个状态转换。）

什么是线程和进程?（总结：进程是程序执行实例，拥有独立资源；线程是进程内更小的执行单位，共享堆和方法区，但有自己的程序计数器、虚拟机栈和本地方法栈。）

Java 线程和操作系统的线程有什么区别？（总结：JDK1.2后Java线程基于操作系统内核线程实现，使用一对一模型，用户线程由应用管理，内核线程由OS管理，创建和切换成本不同。）

Java 线程模型（总结：Java采用一对一线程模型，每个Java线程对应一个内核线程，由OS调度。）

请简要描述线程与进程的关系，区别及优缺点？（总结：线程是进程的子单位，共享资源但易相互影响；进程独立但开销大。线程执行开销小但资源管理弱，进程反之。）

程序计数器为什么是私有的?（总结：保证线程切换后能恢复正确执行位置，记录当前指令地址，native方法时记录undefined。）

虚拟机栈和本地方法栈为什么是私有的?（总结：虚拟机栈存储方法调用栈帧，本地方法栈服务Native方法，私有化防止其他线程访问局部变量。）

如何创建线程？（总结：本质通过new Thread().start()创建，其他方式如Runnable、Callable、线程池最终依赖此方式。）

说说线程的生命周期和状态?（总结：包括NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED，状态转换由锁获取、等待等触发。）

为什么 JVM 没有区分 READY 和 RUNNING 状态呢？（总结：OS时间片轮转调度使状态切换频繁，区分意义不大。）

什么是线程上下文切换?（总结：线程切换时保存和恢复上下文的过程，涉及程序计数器等寄存器状态，频繁切换影响性能。）

Thread.sleep() 方法和 Object.wait() 方法对比（总结：sleep不释放锁，自动恢复；wait释放锁，需notify唤醒，用于线程间交互。）

为什么 wait() 方法不定义在 Thread 中？（总结：wait操作对象锁，需与对象监视器关联，属于对象级别的行为。）

可以直接调用 Thread 类的 run 方法吗？（总结：直接调用run()视为普通方法，不会启动新线程，需通过start()触发线程执行。）

多线程（总结：多线程提升并发性能，需处理同步、原子性等问题，涉及并发与并行、线程安全等核心概念。）

并发与并行的区别（总结：并发是时间段内交替执行，并行是同时执行，依赖多核CPU。）

同步和异步的区别（总结：同步等待结果返回，异步不等待直接返回，通过回调处理结果。）

为什么要使用多线程?（总结：提高资源利用率，减少线程切换开销，适应多核CPU时代，提升系统吞吐量和响应速度。）

单核 CPU 支持 Java 多线程吗？（总结：支持，通过时间片轮转模拟并行，OS调度实现线程切换。）

单核 CPU 上运行多个线程效率一定会高吗？（总结：取决于任务类型，CPU密集型可能因切换开销降低效率，IO密集型可提高效率。）

使用多线程可能带来什么问题？（总结：线程安全问题如死锁、内存泄漏，上下文切换开销，资源竞争导致性能下降。）

如何理解线程安全和不安全？（总结：线程安全指多线程访问共享资源时数据一致；不安全指未受保护导致数据混乱。）

死锁（总结：多个线程互相等待资源导致阻塞，需破坏互斥、请求保持、不可剥夺、循环等待条件来预防。）

什么是线程死锁?（总结：线程互相持有对方所需资源且不释放，导致无限等待，程序无法继续执行。）

产生死锁的四个必要条件（总结：互斥、请求与保持、不可剥夺、循环等待，缺一不可。）

如何检测死锁？（总结：使用jstack、VisualVM等工具分析线程栈，查找阻塞链和资源竞争。）

如何预防死锁?（总结：破坏必要条件，如一次性申请资源、允许资源剥夺、按序申请资源。）

如何避免死锁?（总结：资源分配前进行安全性检查，银行家算法确保系统处于安全状态。）

volatile 关键字（总结：保证变量可见性，防止指令重排序，适用于状态标记、双重校验锁等场景，不保证原子性。）

如何保证变量的可见性？（总结：volatile修饰变量，每次访问直接读主存，写操作立即刷回主存。）

volatile 关键字与 synchronized 关键字的区别？（总结：volatile仅保证可见性和有序性，synchronized还保证原子性，后者更重量级。）

如何禁止指令重排序？（总结：volatile通过内存屏障禁止编译器和处理器重排序，用于单例模式等需要严格顺序的场景。）

volatile 可以保证原子性么？（总结：不能，自增等复合操作需synchronized或原子类保证原子性。）

乐观锁和悲观锁（总结：悲观锁假定竞争需加锁，乐观锁通过版本号或CAS无锁实现，前者适合写多，后者适合读多。）

什么是悲观锁？（总结：独占资源，如synchronized和ReentrantLock，适合写多场景，可能引起线程阻塞。）

悲观锁的实现（总结：通过synchronized或ReentrantLock的lock()/unlock()实现，阻塞其他线程访问。）

什么是乐观锁？（总结：通过版本号或CAS更新数据，失败重试，适合低冲突场景，如Atomic类。）

乐观锁的实现（总结：CAS算法比较并替换，版本号机制检查数据是否被修改。）

如何选择乐观锁和悲观锁？（总结：高冲突用悲观锁，低冲突用乐观锁，根据场景权衡性能与安全性。）

如何实现乐观锁？（总结：版本号机制或CAS，后者依赖CPU指令，如Atomic类使用Unsafe的CAS操作。）

Java 中 CAS 是如何实现的？（总结：通过Unsafe类调用底层CPU指令，循环重试直到成功，解决多线程竞争。）

CAS 算法存在哪些问题？（总结：ABA问题（版本号解决）、自旋开销、只能保证单个变量原子性。）

synchronized 关键字（总结：JVM内置锁，通过监视器实现，支持重入，经锁升级优化性能，适用于方法或代码块同步。）

synchronized 是什么？有什么用？（总结：保证多线程同步访问资源，可修饰方法或代码块，经优化后性能较高。）

如何使用 synchronized？（总结：修饰实例方法（锁对象）、静态方法（锁类）、代码块（指定锁对象或类）。）

构造方法可以用 synchronized 修饰么？（总结：不能，但可在构造方法内使用同步块，确保线程安全初始化。）

synchronized 底层原理了解吗？（总结：通过monitorenter/monitorexit指令实现，对象头记录锁状态，支持锁升级过程。）

锁升级（总结：无锁→偏向锁→轻量级锁→重量级锁，根据竞争情况动态调整，减少性能开销。）

synchronized 和 volatile 有什么区别？（总结：synchronized保证原子性、可见性，volatile仅保证可见性和有序性，后者更轻量。）

ReentrantLock（总结：基于AQS的可重入锁，支持公平/非公平锁、可中断、超时等高级功能，需手动释放锁。）

ReentrantLock 是什么？（总结：Lock接口实现类，通过Sync及其子类管理锁状态，提供比synchronized更灵活的控制。）

公平锁和非公平锁有什么区别？（总结：公平锁按队列顺序获取，非公平锁允许插队，后者吞吐量高但可能饥饿。）

synchronized 和 ReentrantLock 有什么区别？（总结：synchronized自动释放，JVM实现；ReentrantLock需手动释放，API实现，支持更多功能如条件变量。）

可中断锁和不可中断锁有什么区别？（总结：ReentrantLock可响应中断，synchronized不可，前者更灵活处理阻塞。）

ReentrantReadWriteLock（总结：读写分离锁，读共享，写独占，适合读多写少场景，提升并发性能。）

ReentrantReadWriteLock 适合什么场景？（总结：读远多于写的场景，如缓存，减少锁竞争提高吞吐量。）

线程持有读锁还能获取写锁吗？（总结：不能，需先释放读锁，避免死锁；写锁可降级为读锁。）

StampedLock（总结：JDK8引入，支持乐观读、读写锁，适合读多写少，性能优于ReentrantReadWriteLock。）

StampedLock 的性能为什么更好？（总结：乐观读不加锁，允许写线程插入，减少阻塞，但需处理数据版本变化。）

StampedLock 适合什么场景？（总结：读多写少且对数据一致性要求不严格的场景，如统计、监控等。）

StampedLock 的底层原理了解吗？（总结：基于CLH锁变体，使用state和队列管理锁状态，支持三种访问模式。）

ThreadLocal（总结：线程局部变量，每个线程独立副本，通过ThreadLocalMap实现，需注意内存泄漏问题。）

ThreadLocal 有什么用？（总结：为每个线程提供独立变量副本，避免共享变量竞争，如数据库连接、Session管理等。）

ThreadLocal 原理了解吗？（总结：线程持有ThreadLocalMap，以ThreadLocal为key存储值，get/set操作基于当前线程的map。）

ThreadLocal 内存泄露问题是怎么导致的？（总结：Entry的key为弱引用，value强引用，线程存活时可能导致value无法回收，需主动remove。）

如何跨线程传递 ThreadLocal 的值？（总结：InheritableThreadLocal支持父子线程继承，线程池场景需用TransmittableThreadLocal。）

线程池（总结：池化技术管理线程，减少创建销毁开销，核心参数包括核心线程数、队列、拒绝策略，需合理配置。）

什么是线程池?（总结：复用线程处理任务，控制并发数量，提高响应速度和管理性。）

为什么要用线程池？（总结：降低资源消耗，提高响应速度，管控线程数量，避免OOM等问题。）

Executor 框架介绍（总结：提供线程池管理接口，包括ExecutorService、ScheduledExecutorService等，简化并发编程。）

Executor 框架结构（总结：任务（Runnable/Callable）、执行（ExecutorService）、结果（Future）三层结构，支持任务提交与结果获取。）

ThreadPoolExecutor 类介绍（重要）（总结：核心类，参数包括corePoolSize、maximumPoolSize、workQueue等，处理任务流程分四步。）

线程池参数分析（总结：核心线程数、最大线程数、队列类型决定任务处理策略，拒绝策略处理满载情况。）

拒绝策略（总结：AbortPolicy抛异常，CallerRunsPolicy调用者线程执行，Discard静默丢弃，DiscardOldest丢弃最旧任务。）

线程池创建的两种方式（总结：推荐手动配置ThreadPoolExecutor，避免Executors创建导致OOM风险。）

线程池常用的阻塞队列总结（总结：LinkedBlockingQueue（无界）、SynchronousQueue（直接传递）、DelayedWorkQueue（延迟任务）等。）

线程池原理分析（重要）（总结：任务提交后，核心线程未满则新建线程，否则入队；队列满且线程未达最大值则新建非核心线程，否则拒绝。）

线程池的核心线程会被回收吗？（总结：默认不回收，allowCoreThreadTimeOut设置为true后允许回收。）

如何监测线程池运行状态？（总结：通过扩展线程池或使用监控工具，如Spring Boot Actuator，查看任务数、活跃线程等指标。）

如何设计一个能够根据任务的优先级来执行的线程池？（总结：使用PriorityBlockingQueue作为任务队列，任务实现Comparable或传入Comparator排序。）

Java 线程池最佳实践（总结：手动创建线程池，合理配置参数，命名线程池，区分业务，及时关闭，避免使用ThreadLocal可能导致的问题。）

Future（总结：异步计算结果容器，通过FutureTask封装，CompletableFuture支持链式调用和组合，解决回调地狱。）

Future 类有什么用？（总结：获取异步任务结果，提供取消、查询完成状态等方法，但get()阻塞。）

Callable 和 Future 有什么关系？（总结：Callable定义带返回值的任务，FutureTask包装其执行结果，通过submit提交到线程池。）

CompletableFuture 类有什么用？（总结：增强Future，支持函数式编程、任务组合、异常处理，避免阻塞和复杂同步。）

CompletableFuture 常见操作（总结：创建（supplyAsync/runAsync）、结果处理（thenApply/thenAccept）、组合（thenCompose/thenCombine）、并行（allOf/anyOf）。）

AQS（总结：抽象队列同步器，CLH锁变体实现，state表示资源状态，支持自定义同步器如ReentrantLock、Semaphore。）

AQS 是什么？（总结：构建锁和同步器的框架，通过FIFO队列管理线程，提供acquire/release模板方法。）

AQS 原理（总结：state表示资源状态，线程通过CAS修改state，失败则加入队列等待，前驱节点释放后唤醒后继。）

AQS 的核心思想（总结：共享资源状态管理，CLH队列线程排队，自旋+阻塞平衡性能与公平性。）

常见同步工具类（总结：Semaphore（信号量控制并发数）、CountDownLatch（等待多任务完成）、CyclicBarrier（循环栅栏同步多线程）。）

Semaphore（信号量）（总结：控制同时访问资源的线程数，acquire获取许可，release释放，用于限流或资源池。）

CountDownLatch（倒计时器）（总结：等待指定数量任务完成，countDown减计数，await阻塞直到计数归零。）

CyclicBarrier（循环栅栏）（总结：多线程到达屏障后同时执行后续逻辑，可重复使用，支持回调任务。）

Atomic（总结：原子变量类基于CAS实现无锁线程安全操作，如AtomicInteger，适用于计数器、状态标记等场景。）

Atomic 原子类介绍（总结：提供基本类型和引用类型的原子操作，避免synchronized开销，依赖Unsafe类的CAS实现。）

JMM（总结：Java内存模型定义线程与主内存交互规则，保证可见性、有序性，happens-before原则解决指令重排序问题。）

JMM（总结：主内存存储共享变量，线程本地内存保存副本，通过volatile、锁等机制保证可见性和顺序一致性。）

从 CPU 缓存模型说起（总结：CPU缓存导致内存可见性问题，内存模型定义多线程下读写规则，保证一致性。）

指令重排序（总结：编译器和处理器优化可能导致执行顺序变化，JMM通过内存屏障限制重排序，保证程序正确性。）

再看并发编程三个重要特性（总结：原子性（synchronized/原子类）、可见性（volatile）、有序性（volatile/happens-before）。）