备战金九银十，Java面试题总结，苦战30天拿下高薪Java岗！-CSDN博客

本文链接：https://blog.csdn.net/cxyxysam/article/details/148405705

说在前面的话

金九银十求职季快到了，在准备跳槽或者找第一份工作的程序员。在6月份这个时间点真的很关键，也非常需要系统性的指导。

也不知道大家的经验级别，但既然是“备战”，就默认大家是3年内的开发者，可能偏初级或中级。需要掌握基础到进阶的内容。

小编首先想到Java面试的几个核心板块：基础语法、集合、并发、JVM、新特性。还有数据库和框架也必不可少。

作为面试者来说可能更关注实际面试高频题，而不是教科书式的知识点罗列。

Java面试题的深度和广度都要有，才能提升面试成功的概率。

比如String的题目几乎必考，但不能只给“String是否可变”这种基础答案，得延伸到JVM优化和设计考量。集合部分HashMap是重中之重，必须包含扩容、线程安全等实战问题。

并发编程现在越来越受重视，得涵盖线程池参数、锁优化这些常问点。JVM虽然理论性强，但调优和GC问题在面试中经常出现，需要用实际案例解释。

作为面试官可能经常遇到“八股文”比较多，所以每个知识点都要搭配应用场景。比如讲synchronized时，要说明在什么业务场景下用，而不是单纯背特性。

数据库部分必须包含隔离级别和索引优化，这两个是SQL问题的重灾区。框架方面Spring Boot的自动配置原理最近问得很多，需要重点准备。

同样项目经验的重要性很关键，很多面试者死记硬背题目但讲不清实战项目。建议大家用STAR法则整理项目案例。

对了，新特性如Lambda和Stream API现在基本是必考题，但要注意解释底层原理而不只是用法。比如问“Stream是延迟执行的”就要能说清楚中间操作和终止操作的区别。

作为面试者可能时间紧张，所以回复要结构化。先分大类，每类给3-5个典型问题，配上深度解析和回答要点。避免信息过载，但又要足够应对中高级岗位的考察。

那么，需不需要掌握算法相关技能呢？大家如果是面试中大厂的话，算法肯定是必备的，大厂必考！LeetCode中等难度题，300-500道，字节的话要600道以上。

备战“金九银十”Java面试，这份核心知识点总结助你一臂之力！我结合近年高频考点和面试官关注点，为你梳理了以下核心内容，覆盖基础到进阶，帮你针对性准备：

一、 Java 核心基础 (必考！)

面向对象编程 (OOP)
四大特性： 封装、继承、多态、抽象。深入理解其概念、意义和应用场景。
类与对象： 区别？创建对象的方式？构造方法作用？this 和 super 关键字？
重载 vs 重写： 区别？（方法名、参数列表、返回类型、访问修饰符、异常、发生位置）
接口 vs 抽象类：
接口：多重继承、默认方法、静态方法、函数式接口、成员变量（只能是 public static final）。
抽象类：可以有构造方法、可以有普通成员变量和方法、单继承。
如何选择？优先使用接口实现多态和行为约定；当需要定义公共状态或行为模板时考虑抽象类。
final 关键字： 修饰类、方法、变量（成员变量、局部变量、参数）分别表示什么？final、finally、finalize() 区别？
static 关键字： 修饰变量、方法、代码块、内部类。静态成员的特点（类级别、访问方式、生命周期）。静态导入。
Java 集合框架 (Collection Framework)
核心接口： Collection (List, Set, Queue), Map。理解继承关系。
List:
ArrayList：底层数组，随机访问快（O(1)），增删（特别是中间）慢（O(n)），线程不安全。扩容机制（默认10，1.5倍）。
LinkedList：底层双向链表，增删快（O(1)，尤其头尾），随机访问慢（O(n)），线程不安全。实现了 Deque。
Vector：线程安全的 ArrayList（方法加 synchronized），性能较差。Stack (继承自 Vector，不推荐)。
CopyOnWriteArrayList：写时复制，读操作无锁，适合读多写少场景。
Set:
HashSet：基于 HashMap，无序，唯一（依赖 equals() 和 hashCode()）。允许 null。
LinkedHashSet：继承 HashSet，内部维护链表，保持插入顺序。
TreeSet：基于 TreeMap（红黑树），元素有序（自然顺序或 Comparator）。元素必须实现 Comparable 或提供 Comparator。
CopyOnWriteArraySet：基于 CopyOnWriteArrayList，适合读多写少。
Map:
HashMap (绝对重点！):
底层：数组+链表/红黑树（JDK8+）。解决哈希冲突：链地址法。
put 过程：计算 key.hashCode() -> 高位运算 & 取模定位桶 -> 遍历链表/树（存在则覆盖，否则新增）-> 是否需要树化（链表长度 >=8 & 数组长度 >=64）。
resize 扩容：触发条件（size > threshold = capacity * load factor），默认16, 0.75。扩容为2倍，重新计算索引（高效方式：(e.hash & oldCap) == 0 则位置不变，否则位置+oldCap）。
线程不安全（并发 put 可能导致死循环 - JDK7链表头插法问题，JDK8尾插法已解决但仍有数据覆盖等问题）。
允许 null key 和 null value。
LinkedHashMap：继承 HashMap，维护插入顺序或访问顺序（LRU实现基础）。
TreeMap：基于红黑树，key 有序（自然顺序或 Comparator）。
Hashtable：线程安全（方法加 synchronized），性能差。不允许 null。
ConcurrentHashMap (重点！):
JDK7：分段锁 (Segment 数组 + HashEntry 数组)，锁粒度更细。
JDK8+：摒弃分段锁，采用 Node 数组 + CAS + synchronized（锁单个链表头/树根节点）。sizeCtl 控制初始化、扩容状态。并发度更高。
迭代器 (Iterator)： fail-fast (快速失败，如 ArrayList, HashMap) vs fail-safe (安全失败，如 CopyOnWriteArrayList, ConcurrentHashMap 的迭代器视图)。
equals() 和 hashCode()：
关系：两个对象 equals 相等，则 hashCode 必须相等；hashCode 相等，equals 不一定相等。
重写规则：一致性（多次调用结果相同）、对称性、传递性、非空性。重写 equals 必须重写 hashCode。
在 HashMap/HashSet 中的作用：定位桶位置、判断是否重复。
Java 异常处理
Throwable 体系：Error (严重错误，程序无法处理) vs Exception (程序可以捕获处理的异常)。
Exception：RuntimeException (运行时异常，非受检异常，如 NullPointerException, IndexOutOfBoundsException) vs Checked Exception (受检异常，编译时检查，如 IOException, SQLException)。
try-catch-finally：执行流程。finally 块一定会执行吗？（try 或 catch 中有 System.exit(0) 或线程死亡则不执行）。
try-with-resources (JDK7+)：自动关闭实现了 AutoCloseable 的资源，简化代码。
自定义异常：继承 Exception 或 RuntimeException。
Java I/O
流 (Stream)： 字节流 (InputStream/OutputStream) vs 字符流 (Reader/Writer)。
常用类：FileInputStream/FileOutputStream, FileReader/FileWriter, BufferedInputStream/BufferedOutputStream, BufferedReader/BufferedWriter, ObjectInputStream/ObjectOutputStream (序列化/反序列化)。
NIO (New I/O, JDK1.4+):
核心组件：Channel (通道), Buffer (缓冲区), Selector (选择器)。
特点：非阻塞 I/O (NIO 核心)，基于缓冲区，面向块 (Block-Oriented)。
ByteBuffer 使用：allocate, put, flip, get, clear/compact。
Selector 作用：监听多个 Channel 上的事件 (OP_ACCEPT, OP_CONNECT, OP_READ, OP_WRITE)，实现单线程管理多个连接。
Java 泛型
目的：类型安全，消除强制类型转换。
类型擦除：编译后泛型信息被擦除，替换为原始类型 (Object 或边界类型)，并在必要处插入强制类型转换。
通配符：<?> (无界), <? extends T> (上界), <? super T> (下界)。PECS 原则 (Producer-Extends, Consumer-Super)。
泛型方法：在方法返回值前声明 <T>。
Java 反射 (Reflection)
核心类：Class, Field, Method, Constructor。
作用：运行时动态获取类信息、创建对象、调用方法、操作字段。
应用：框架 (如 Spring IOC/AOP)、动态代理、注解处理。
优缺点：灵活 vs 性能开销、破坏封装性、安全问题。
Java 注解 (Annotation)
元注解：@Target, @Retention, @Documented, @Inherited。
常见内置注解：@Override, @Deprecated, @SuppressWarnings。
自定义注解：定义、使用、通过反射读取和处理。
Java 8+ 新特性 (重点考察！)
Lambda 表达式： 匿名函数。语法 (parameters) -> expression 或 (parameters) -> { statements; }。函数式接口 (@FunctionalInterface) 是其基础。
函数式接口 (Functional Interface)： 只有一个抽象方法的接口。常用：Runnable, Callable, Comparator, Predicate, Function, Supplier, Consumer。
Stream API：
核心概念：源 (集合、数组、生成器) -> 中间操作 (过滤 filter、映射 map、排序 sorted、去重 distinct 等) -> 终止操作 (收集 collect、计数 count、遍历 forEach、聚合 reduce 等)。
特点：声明式、链式调用、内部迭代、惰性求值 (中间操作延迟执行)。
Optional 类： 优雅处理 null，避免 NullPointerException。of, ofNullable, isPresent, ifPresent, orElse, orElseGet, orElseThrow, map, flatMap。
接口默认方法 (default) 和静态方法 (static): 允许在接口中提供方法实现，增强接口能力。
新的日期时间 API (java.time): 替代 Date/Calendar，更清晰、线程安全、功能强大。核心类：LocalDate, LocalTime, LocalDateTime, Instant, Duration, Period, DateTimeFormatter。
CompletableFuture (JDK8)： 强大的异步编程工具，支持链式调用、组合多个异步任务、异常处理等。
模块化 (JPMS, JDK9)： 了解基本概念（模块、module-info.java），解决 JAR 地狱问题。

二、 Java 并发编程 (重中之重！)

线程基础
创建线程的三种方式：继承 Thread、实现 Runnable、实现 Callable + FutureTask/线程池。
线程状态：NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED。状态转换图。
线程基本方法：start(), run(), sleep(), yield(), join(), interrupt(), isInterrupted(), interrupted()。wait(), notify(), notifyAll() (Object 类的方法)。
守护线程 (setDaemon(true))：为用户线程提供服务，JVM 退出时不会等待守护线程完成。
线程安全
问题根源：共享数据的可见性、操作的原子性、指令重排序。
JMM (Java 内存模型)：
主内存 vs 工作内存。
volatile 关键字：保证可见性、禁止指令重排序（通过内存屏障）。不保证原子性。适用场景：状态标志位、double-check 单例模式。
happens-before 原则：程序顺序规则、锁规则、volatile 规则、传递性等。解决可见性问题。
原子性： 通过锁 (synchronized, Lock) 或 CAS (Compare-And-Swap) 操作 (java.util.concurrent.atomic 包) 保证。
AtomicInteger, AtomicLong, AtomicReference, AtomicStampedReference (解决 ABA 问题)。
CAS 原理：Unsafe 类，CPU 指令支持。自旋开销、ABA 问题。
锁机制
synchronized (内置锁/监视器锁)：
使用方式：修饰实例方法（锁当前实例）、修饰静态方法（锁当前类的 Class 对象）、修饰代码块（锁指定对象）。
底层原理：
同步代码块：monitorenter 和 monitorexit 字节码指令。锁对象关联一个 Monitor 对象。
锁升级 (JDK6 优化)：无锁 -> 偏向锁 (适用于同一线程反复进入) -> 轻量级锁 (CAS，适用于线程交替执行) -> 重量级锁 (操作系统互斥量，线程阻塞)。
锁消除 (Lock Elimination)、锁粗化 (Lock Coarsening)。
特点：互斥性、可重入性（同一个线程可多次获取同一把锁）、不可中断性（等待锁时无法响应中断）。
Lock 接口 (java.util.concurrent.locks):
核心实现：ReentrantLock (可重入锁)。
相比 synchronized 的优势：可中断 (lockInterruptibly())、可尝试非阻塞获取锁 (tryLock())、可设置超时 (tryLock(long, TimeUnit))、可实现公平锁 (new ReentrantLock(true))、支持多个条件变量 (Condition 对象，await(), signal(), signalAll())。
使用范式：lock() -> try { ... } finally { unlock() }。
读写锁 ReentrantReadWriteLock： 允许多个读线程并发访问，写线程互斥访问。适用于读多写少场景。
StampedLock (JDK8)： 提供乐观读锁，在读多写少场景下性能可能优于 ReentrantReadWriteLock。
线程间通信/协作
wait(), notify(), notifyAll()：必须在 synchronized 块内使用，基于对象监视器。
Condition 接口：与 Lock 配合使用，提供更灵活的等待/通知机制 (await(), signal(), signalAll())。
管道流 (PipedInputStream/PipedOutputStream, PipedReader/PipedWriter)：较少用。
BlockingQueue：线程安全的阻塞队列，是生产者-消费者模式的理想实现。常用实现：ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue, DelayQueue。
线程池 (ThreadPoolExecutor) (绝对重点！)
为什么使用线程池？ 降低资源消耗（线程创建销毁开销）、提高响应速度（任务到达直接执行）、提高线程可管理性（统一分配、调优、监控）。
核心参数 (构造方法)：
corePoolSize (核心线程数)
maximumPoolSize (最大线程数)
keepAliveTime (非核心线程空闲存活时间)
unit (时间单位)
workQueue (工作队列 - BlockingQueue 实现)
threadFactory (线程工厂)
handler (拒绝策略 - RejectedExecutionHandler 实现)
工作原理 (任务提交流程)：
1. 当前线程数 < corePoolSize？是 -> 创建新线程执行任务。
2. 否 -> 尝试将任务放入工作队列。
3. 入队成功？是 -> 等待线程空闲执行。
4. 入队失败（队列已满）？-> 当前线程数 < maximumPoolSize？是 -> 创建新线程执行任务。
5. 否 -> 执行拒绝策略。
拒绝策略：
AbortPolicy (默认)：抛出 RejectedExecutionException。
CallerRunsPolicy：由调用者线程（提交任务的线程）执行该任务。
DiscardPolicy：直接丢弃任务，不抛异常。
DiscardOldestPolicy：丢弃队列中最老的任务，然后尝试重新提交当前任务。
常用线程池 (Executors 工厂方法 - 了解问题，推荐手动创建 ThreadPoolExecutor)：
newFixedThreadPool：固定大小线程池，无界队列 (LinkedBlockingQueue)，可能 OOM。
newSingleThreadExecutor：单线程线程池，无界队列。
newCachedThreadPool：可缓存线程池，核心线程0，最大线程 Integer.MAX_VALUE，SynchronousQueue，可能创建过多线程 OOM。
newScheduledThreadPool：支持定时及周期性任务执行。
线程池状态： RUNNING, SHUTDOWN (不再接受新任务，处理队列中任务), STOP (中断所有任务), TIDYING (所有任务终止，工作线程数为0), TERMINATED (terminated() 钩子方法执行完毕)。
合理配置线程池： 考虑任务类型（CPU 密集型 vs IO 密集型）、系统资源（CPU 核数）、队列容量。经验公式（参考）：CPU 密集型：N(cpu) + 1；IO 密集型：2 * N(cpu) 或 N(cpu) * (1 + WT / ST) (WT: 平均等待时间, ST: 平均服务时间)。实际需要压测调整。
并发工具类 (java.util.concurrent)
CountDownLatch：倒计时门闩。让一个或多个线程等待其他线程完成操作。countDown(), await()。
CyclicBarrier：循环栅栏。让一组线程互相等待，到达一个公共屏障点再继续执行。可重用。await()。
Semaphore：信号量。控制同时访问特定资源的线程数量。acquire(), release()。
Exchanger：两个线程交换数据的同步点。
Phaser (JDK7)：更灵活的分阶段屏障。
Future & FutureTask：异步计算结果。get() (阻塞), isDone(), cancel()。
Fork/Join 框架 (JDK7)：并行执行任务，将大任务拆分成小任务 (RecursiveTask/RecursiveAction)，利用工作窃取 (Work-Stealing) 算法提高效率。核心类：ForkJoinPool, ForkJoinTask。

三、 JVM (Java 虚拟机) (深度考察点)

JVM 内存区域 (运行时数据区)
线程私有：
程序计数器 (PC Register)：当前线程执行的字节码行号指示器。唯一不会 OOM 的区域。
虚拟机栈 (VM Stack)：Java 方法执行的内存模型（栈帧：局部变量表、操作数栈、动态链接、方法出口）。StackOverflowError (递归过深), OutOfMemoryError (线程过多)。
本地方法栈 (Native Method Stack)：为 Native 方法服务。
线程共享：
堆 (Heap)：存放对象实例。GC 主要区域。-Xmx/-Xms 设置最大/初始堆大小。OutOfMemoryError: Java heap space。
方法区 (Method Area) / 元空间 (Metaspace - JDK8+)：存储已被加载的类信息、常量、静态变量、即时编译器编译后的代码等。JDK7 及以前是永久代 (PermGen)，JDK8 移除了永久代，使用本地内存的元空间 (Metaspace)。OutOfMemoryError: Metaspace/PermGen space。
运行时常量池 (Runtime Constant Pool)：方法区的一部分，存放编译期生成的字面量和符号引用。
直接内存 (Direct Memory)：NIO 使用 Native 函数库直接分配的堆外内存。OutOfMemoryError: Direct buffer memory。
垃圾回收 (GC)
判断对象是否可回收：
引用计数法：循环引用问题。
可达性分析算法 (主流)： 从 GC Roots 对象开始，向下搜索，不可达的对象即为可回收。GC Roots 包括：虚拟机栈局部变量表引用的对象、方法区中类静态属性引用的对象、方法区中常量引用的对象、本地方法栈 JNI 引用的 Native 对象、同步锁持有的对象、Class 对象等。
引用类型：
强引用 (Strong Reference)：普遍存在，只要强引用存在，对象就不会被回收。
软引用 (Soft Reference)：内存不足时会被回收。用于实现缓存。
弱引用 (Weak Reference)：下一次 GC 时会被回收。用于实现 WeakHashMap、监控对象生命周期。
虚引用 (Phantom Reference)：最弱，无法通过它获取对象，仅用于在对象被回收时收到系统通知。必须和 ReferenceQueue 配合使用。管理堆外内存。
垃圾回收算法：
标记-清除 (Mark-Sweep)： 简单，产生内存碎片。
复制 (Copying)： 效率高，无碎片，但内存利用率低（需一半空间）。适合新生代。
标记-整理 (Mark-Compact)： 无碎片，需移动对象，效率较低。适合老年代。
分代收集 (Generational Collection)： 结合多种算法，根据对象存活周期将堆划分为新生代 (Young Generation) 和老年代 (Old Generation/Tenured Generation)。
HotSpot 虚拟机 GC 收集器：
新生代收集器：
Serial：单线程，Stop-The-World (STW)。
ParNew：Serial 的多线程版本。与 CMS 配合使用。
Parallel Scavenge：吞吐量优先。使用复制算法。
老年代收集器：
Serial Old：Serial 的老年代版本。标记-整理算法。
Parallel Old：Parallel Scavenge 的老年代版本。标记-整理算法。
CMS (Concurrent Mark Sweep)：以获取最短回收停顿时间为目标。步骤：初始标记 (STW) -> 并发标记 -> 重新标记 (STW) -> 并发清除。缺点：对 CPU 资源敏感、无法处理浮动垃圾、标记-清除算法产生碎片。JDK9 标记废弃，JDK14 移除。
G1 (Garbage-First, JDK7u4+ 正式商用)：面向服务端应用。特点：将堆划分为多个大小相等的 Region (不再物理分代)，可预测停顿模型，整体基于标记-整理，局部 (Region 之间) 基于复制。步骤：初始标记 -> 并发标记 -> 最终标记 -> 筛选回收。JDK9 默认收集器。
ZGC (JDK11+ 实验，JDK15+ 生产可用)：低延迟 (<10ms)，可扩展 (TB 级堆)。基于 Region，使用染色指针和读屏障技术实现并发标记、转移和重定位。几乎全程并发。
Shenandoah (OpenJDK 提供，Red Hat 主导)：目标与 ZGC 类似，低停顿，高并发。采用连接矩阵和读屏障/写屏障技术。
内存分配与回收策略：
对象优先在 Eden 区分配。
大对象直接进入老年代 (-XX:PretenureSizeThreshold)。
长期存活的对象进入老年代 (-XX:MaxTenuringThreshold，对象年龄计数器)。
动态对象年龄判定：Survivor 空间中相同年龄所有对象大小总和 > Survivor 空间一半，则年龄 >= 该年龄的对象晋升老年代。
空间分配担保：Minor GC 前检查老年代最大可用连续空间是否大于新生代所有对象总空间或历次晋升平均大小，否则可能触发 Full GC。
类加载机制
生命周期： 加载 (Loading) -> 链接 (Linking: 验证、准备、解析) -> 初始化 (Initialization) -> 使用 (Using) -> 卸载 (Unloading)。
类加载器 (ClassLoader)：
启动类加载器 (Bootstrap ClassLoader)：加载 JAVA_HOME/lib 核心库 (rt.jar 等)，C++ 实现，无父类。
扩展类加载器 (Extension ClassLoader)：加载 JAVA_HOME/lib/ext 目录库，Java 实现，父加载器为 null (实际是 Bootstrap)。
应用程序类加载器 (Application/System ClassLoader)：加载用户类路径 (ClassPath) 上的类库。是 ClassLoader.getSystemClassLoader() 的返回值。父加载器为 Extension。
自定义类加载器：继承 ClassLoader，重写 findClass() 方法。可实现热部署、模块化加载、加密解密等。
双亲委派模型 (Parent Delegation Model)：
工作流程：一个类加载器收到加载请求，首先委派给父加载器加载。只有当父加载器无法完成时，子加载器才尝试自己加载。
目的：保证核心类库的安全性和唯一性（避免用户自定义同名类覆盖核心类）。
破坏双亲委派：如 SPI (JDBC, JNDI) 使用线程上下文类加载器 (Thread Context ClassLoader)、OSGi 模块化热部署。
JVM 性能监控与调优
命令行工具：
jps：列出 JVM 进程。
jstat：查看 JVM 统计信息 (类加载、GC、编译)。
jinfo：查看和修改 JVM 配置参数。
jmap：生成堆转储快照 (heapdump)。
jhat：分析 heapdump (内置 HTTP 服务器)。
jstack：生成线程快照 (threaddump)，查看线程状态和锁信息。
图形化工具：
jconsole：JMX 客户端，监控内存、线程、类、MBean。
VisualVM：功能强大的多合一监控、故障诊断、性能分析工具 (可安装插件)。
JMC (Java Mission Control)：商业级监控分析工具 (部分功能需商业许可)。
常用 JVM 参数：
堆内存：-Xms, -Xmx, -Xmn (新生代大小)。
元空间：-XX:MetaspaceSize, -XX:MaxMetaspaceSize。
GC 日志：-Xloggc:<file>, -XX:+PrintGCDetails, -XX:+PrintGCDateStamps, -XX:+PrintHeapAtGC。
OOM 时 Dump：-XX:+HeapDumpOnOutOfMemoryError, -XX:HeapDumpPath=<path>。
选择 GC 收集器：-XX:+UseSerialGC, -XX:+UseParallelGC, -XX:+UseConcMarkSweepGC (JDK8), -XX:+UseG1GC, -XX:+UseZGC, -XX:+UseShenandoahGC。
其他：-XX:MaxTenuringThreshold, -XX:PretenureSizeThreshold, -XX:SurvivorRatio (Eden:Survivor), -XX:NewRatio (老年代:新生代)。
调优思路： 监控分析 (GC 日志、堆栈信息、性能指标) -> 定位瓶颈 (CPU、内存、IO、锁) -> 调整参数或代码优化。常见问题：频繁 Full GC、Young GC 时间长、OOM、线程死锁、CPU 占用过高。

四、数据库 (通常是 MySQL)

基础与 SQL
数据库范式 (1NF, 2NF, 3NF, BCNF)。
SQL 语句：DDL, DML, DQL, DCL, TCL。JOIN (INNER, LEFT/RIGHT OUTER, FULL OUTER, CROSS), UNION/UNION ALL, 子查询 (相关/非相关)。
聚合函数：COUNT, SUM, AVG, MAX, MIN。GROUP BY 与 HAVING。
索引 (Index)
为什么需要索引？ 加快数据检索速度。
数据结构：
B+树 (主流)： 多路平衡查找树。非叶子节点只存储键值（索引）和指针，叶子节点存储所有键值和数据指针（或数据本身），叶子节点通过指针相连形成有序链表。适合范围查询和排序。
Hash 索引：精确查询快 (=)，不支持范围查询、排序、最左前缀匹配。InnoDB 自适应 Hash 索引。
全文索引 (FULLTEXT)：用于文本搜索 (MATCH ... AGAINST)。
索引类型 (InnoDB)：
聚簇索引 (Clustered Index)：主键索引，叶子节点存储整行数据。表只有一个聚簇索引。
非聚簇索引 (Secondary Index / 辅助索引)：叶子节点存储主键值。查询时需要回表 (通过主键值去聚簇索引查完整数据)。
覆盖索引 (Covering Index)： 查询的列都包含在索引中，无需回表。EXPLAIN 的 Extra 列显示 Using index。
最左前缀原则： 联合索引 ((col1, col2, col3)) 生效条件：查询条件必须包含索引的最左前列 (col1)，或 col1 和 col2，或全部。col2 或 col3 单独查询无法使用该索引。
索引失效场景：
对索引列进行计算、函数或类型转换 (WHERE YEAR(date_col) = 2023, WHERE id + 1 = 5)。
!= 或 <> 操作符。
OR 连接的条件（除非所有条件都有索引）。
LIKE 以通配符开头 (%abc)。
联合索引不满足最左前缀原则。
隐式类型转换 (WHERE varchar_col = 123)。
索引列上使用 IS NULL / IS NOT NULL (取决于表设计，NULL 值过多可能失效)。
索引优化： 选择合适的列、避免冗余索引、考虑索引选择性（区分度高的列）、使用覆盖索引、利用索引下推 (ICP, Index Condition Pushdown - MySQL 5.6+)。
存储引擎 (重点 InnoDB)
InnoDB vs MyISAM：
事务：InnoDB 支持 ACID 事务，MyISAM 不支持。
锁：InnoDB 支持行级锁，MyISAM 只有表级锁。
外键：InnoDB 支持，MyISAM 不支持。
崩溃恢复：InnoDB 有 redo log 支持，更健壮。
索引：InnoDB 是聚簇索引，MyISAM 是非聚簇索引 (数据文件和索引文件分离)。
全文索引：MyISAM 原生支持，InnoDB 从 5.6+ 开始支持。
场景：InnoDB 适合 OLTP (高并发事务)，MyISAM 适合 OLAP (读多写少、报表)。
InnoDB 关键特性：
MVCC (多版本并发控制)： 实现非锁定读（快照读），提高并发性。通过 Undo Log 链和 Read View 实现。READ COMMITTED 和 REPEATABLE READ 隔离级别依赖 MVCC。
行级锁： 共享锁 (S Lock)、排他锁 (X Lock)。锁的粒度更细，并发度更高。锁冲突检测基于索引。
间隙锁 (Gap Lock)： REPEATABLE READ 级别下，防止幻读。锁定索引记录之间的间隙。Next-Key Lock = 记录锁 + 间隙锁。
Redo Log (重做日志)： 物理日志，记录对数据页的修改。保证事务的持久性 (Durability)。先写日志 (WAL - Write-Ahead Logging)，再写磁盘。
Undo Log (回滚日志)： 逻辑日志，记录事务修改前的数据版本。用于事务回滚和 MVCC。存放在 Undo 表空间。
事务 (Transaction)
ACID 特性：
原子性 (Atomicity)：事务要么全部成功，要么全部失败回滚。由 Undo Log 保证。
一致性 (Consistency)：事务执行前后数据库状态保持一致（业务逻辑约束）。
隔离性 (Isolation)：并发事务之间互不干扰。由锁和 MVCC 保证。
持久性 (Durability)：事务提交后，修改永久保存。由 Redo Log 保证。
事务隔离级别：
READ UNCOMMITTED (读未提交)：可能脏读、不可重复读、幻读。
READ COMMITTED (读已提交，RC)：解决脏读。可能不可重复读、幻读 (InnoDB 通过 MVCC 避免幻读？在 RC 下，MVCC 的快照读无法避免幻读，因为每次读生成新 Read View；当前读通过间隙锁可以避免部分幻读)。
REPEATABLE READ (可重复读，RR - InnoDB 默认)：解决脏读、不可重复读 (MVCC)。通过 Next-Key Lock 解决幻读 (锁定范围)。（注意：标准 SQL RR 无法避免幻读，但 InnoDB 的 RR 通过 Next-Key Lock 解决了幻读）。
SERIALIZABLE (串行化)：最高隔离级别，所有操作串行执行。解决所有问题，性能最低。
并发问题：
脏读 (Dirty Read)：读到未提交的数据。
不可重复读 (Non-repeatable Read)：同一事务内多次读同一数据，结果不一致（数据被其他事务修改并提交）。
幻读 (Phantom Read)：同一事务内多次查询同一范围，返回的行数不一致（其他事务新增或删除了行并提交）。注意幻读侧重于记录数量的变化，不可重复读侧重于单条记录内容的变化。
分布式事务： XA 协议 (两阶段提交 - 2PC)、TCC (Try-Confirm-Cancel)、Saga、本地消息表、Seata 等框架。
锁
类型：
乐观锁 vs 悲观锁：乐观锁（版本号、CAS），悲观锁（SELECT ... FOR UPDATE）。
共享锁 (S Lock) vs 排他锁 (X Lock)。
意向锁 (Intention Lock)：表级锁，表明事务打算在表中的行上加什么类型的锁。IS (意向共享锁), IX (意向排他锁)。
记录锁 (Record Lock)：锁住索引记录。
间隙锁 (Gap Lock)：锁住索引记录之间的间隙。
临键锁 (Next-Key Lock)：记录锁 + 间隙锁，锁住记录本身和记录之前的间隙。InnoDB RR 级别默认行锁算法。
插入意向锁 (Insert Intention Lock)：Gap Lock 的一种，表明事务想在某个间隙插入记录。
死锁： 两个或多个事务相互等待对方释放锁。检测：等待图。解决：超时机制 (innodb_lock_wait_timeout)、死锁检测 (innodb_deadlock_detect)，回滚代价最小的事务。
性能优化
EXPLAIN 分析 SQL 执行计划：type (访问类型，const, eq_ref, ref, range, index, ALL), key (使用的索引), rows (预估扫描行数), Extra (Using index, Using filesort, Using temporary 等)。
避免 SELECT *。
优化 JOIN，小表驱动大表。
分页优化：避免 LIMIT 大偏移量（使用索引覆盖或记录上次查询位置）。
批量操作 (INSERT ... VALUES (...), (...), ...; UPDATE ... CASE ...; LOAD DATA INFILE)。
读写分离、分库分表 (Sharding)。

五、主流框架 (Spring Boot 是核心)

Spring Framework
IoC (控制反转) / DI (依赖注入)： 核心思想。容器管理 Bean 的创建和依赖关系。BeanFactory, ApplicationContext。配置方式：XML, 注解 (@Component, @Service, @Repository, @Controller, @Autowired, @Qualifier, @Resource), Java Config (@Configuration, @Bean)。
AOP (面向切面编程)： 核心思想。将横切关注点（日志、事务、安全）与核心业务逻辑分离。概念：切面 (Aspect), 连接点 (Joinpoint), 通知 (Advice - @Before, @After, @AfterReturning, @AfterThrowing, @Around), 切点 (Pointcut - @Pointcut), 引入 (Introduction), 织入 (Weaving)。动态代理实现 (JDK Proxy, CGLIB)。
Spring Bean：
作用域：singleton (默认), prototype, request, session, application。
生命周期：实例化 -> 属性填充 -> BeanNameAware -> BeanFactoryAware -> ApplicationContextAware -> BeanPostProcessor.postProcessBeforeInitialization -> @PostConstruct / InitializingBean.afterPropertiesSet -> BeanPostProcessor.postProcessAfterInitialization -> 使用 -> @PreDestroy / DisposableBean.destroy -> destroy-method。
Spring 事务管理： 声明式事务 (@Transactional)。传播行为 (PROPAGATION_REQUIRED, PROPAGATION_REQUIRES_NEW 等), 隔离级别 (isolation), 超时 (timeout), 只读 (readOnly), 回滚规则 (rollbackFor/noRollbackFor)。基于 AOP 实现。
Spring MVC： 请求流程 (DispatcherServlet -> HandlerMapping -> HandlerAdapter -> Controller -> ModelAndView -> ViewResolver -> View)。常用注解 (@RequestMapping, @GetMapping, @PostMapping, @PathVariable, @RequestParam, @RequestBody, @ResponseBody, @RestController, @ModelAttribute, @SessionAttributes)。
Spring Boot
核心理念： 约定优于配置 (Convention over Configuration)，快速创建独立、生产级的 Spring 应用。
核心特性：
自动配置 (Auto-Configuration)：基于类路径 (Classpath) 上的 jar 包、已定义的 Bean 和配置 (application.properties/application.yml)，自动配置 Spring 应用。原理：@SpringBootApplication -> @EnableAutoConfiguration -> META-INF/spring.factories -> XXXAutoConfiguration -> @Conditional 条件注解 (@ConditionalOnClass, @ConditionalOnBean, @ConditionalOnProperty 等)。
起步依赖 (Starter Dependencies)：简化 Maven/Gradle 配置，提供开箱即用的功能集合 (e.g., spring-boot-starter-web, spring-boot-starter-data-jpa, spring-boot-starter-test)。
嵌入式 Servlet 容器：Tomcat (默认), Jetty, Undertow。
Actuator：生产级监控和管理端点 (/actuator/health, /actuator/info, /actuator/metrics, /actuator/env 等)。
外部化配置：支持多种配置文件 (properties, yaml)，优先级顺序，@Value, @ConfigurationProperties。
如何自定义配置？ 覆盖自动配置 Bean、使用 @ConfigurationProperties 绑定配置、使用 @Profile 环境隔离配置、自定义 Starter。
Spring Boot 启动流程： 深入理解 SpringApplication.run() 方法执行过程（准备环境、创建应用上下文、刷新上下文、执行 ApplicationRunner/CommandLineRunner 等）。
Spring Data (特别是 JPA)
简化数据访问层 (DAO) 开发。
Spring Data JPA： 基于 JPA 规范的 Repository 抽象。
核心接口：Repository, CrudRepository, PagingAndSortingRepository, JpaRepository。
方法名查询：根据方法名自动生成查询 (findByLastNameAndFirstName, countByAgeGreaterThan)。
@Query 注解：自定义 JPQL 或原生 SQL 查询。
分页和排序：Pageable, Sort, Page<T>。
JPA (Java Persistence API) 基础： Entity, @Entity, @Id, @GeneratedValue, @Column, @OneToMany/@ManyToOne/@OneToOne/@ManyToMany, EntityManager, PersistenceContext。
Spring Cloud (分布式/微服务相关)
构建分布式系统、微服务架构的工具集合。
核心组件：
服务注册与发现：Eureka (Netflix), Consul, Zookeeper, Nacos (Alibaba)。
负载均衡：Ribbon (客户端负载均衡), LoadBalancer (Spring Cloud 新推荐)。
服务调用：OpenFeign (声明式 REST 客户端)。
服务熔断与降级：Hystrix (Netflix, 已停更), Resilience4j, Sentinel (Alibaba)。
网关：Zuul (Netflix, 已停更), Spring Cloud Gateway。
配置中心：Spring Cloud Config, Nacos Config, Apollo。
分布式链路追踪：Sleuth + Zipkin。
消息总线：Spring Cloud Bus。

六、其他重要主题

设计模式： 了解常见模式的意图、结构和应用场景。如：单例 (多种实现及优缺点)、工厂方法、抽象工厂、建造者、原型、适配器、装饰器、代理 (静态、JDK 动态、CGLIB)、观察者、策略、模板方法、责任链、状态。
数据结构与算法： 数组、链表、栈、队列、树 (二叉树、二叉搜索树、AVL、红黑树 - 了解特性)、堆、图 (基本概念)、哈希表。排序 (快速、归并、堆、冒泡、选择、插入)、查找 (二分查找)。常见算法思想 (递归、分治、贪心、动态规划、回溯)。LeetCode 刷题 (Top 100, Hot 100)。
网络基础：
OSI 七层模型 / TCP/IP 四层模型。
TCP vs UDP：区别？TCP 三次握手、四次挥手。为什么三次握手？为什么四次挥手？TIME_WAIT 状态意义？TCP 可靠性保证 (确认应答、超时重传、流量控制、拥塞控制 - 慢启动、拥塞避免、快重传、快恢复)。
HTTP/HTTPS：
HTTP 方法 (GET, POST, PUT, DELETE, HEAD, OPTIONS), 状态码 (200, 301, 302, 304, 400, 401, 403, 404, 500, 502, 503)。
HTTP 1.0 vs 1.1 (持久连接、管道化、Host 头) vs HTTP/2 (二进制分帧、多路复用、头部压缩、服务器推送)。
HTTPS：SSL/TLS 加密流程 (非对称加密协商对称密钥 -> 对称加密通信)。
DNS 解析过程。
操作系统： 进程 vs 线程、进程间通信 (IPC)、死锁条件及避免、虚拟内存、分页/分段、页面置换算法 (FIFO, LRU)、磁盘调度算法。用户态 vs 内核态。
消息队列： 作用 (解耦、异步、削峰)。常见产品：RabbitMQ (AMQP), Kafka (分布式、高吞吐、日志场景), RocketMQ (阿里, 金融级), ActiveMQ。核心概念：Producer、Consumer、Broker、Topic/Queue、Partition、Replication、消息确认机制 (ACK)、持久化、顺序性、事务消息。如何保证消息不丢失？如何保证消息不被重复消费 (幂等性)？
缓存： 作用 (提升性能、降低数据库压力)。本地缓存 (Caffeine, Guava Cache) vs 分布式缓存 (Redis, Memcached)。缓存穿透 (缓存和 DB 都没有 -> 布隆过滤器)、缓存击穿 (热点 key 失效瞬间大量请求 -> 互斥锁)、缓存雪崩 (大量 key 同时失效 -> 随机过期时间、永不过期)。缓存更新策略 (Cache Aside, Read/Write Through, Write Behind)。Redis 重点：数据类型 (String, Hash, List, Set, Sorted Set, HyperLogLog, Geo, Stream)、持久化 (RDB, AOF)、主从复制、哨兵 (Sentinel)、集群 (Cluster)、事务、Lua 脚本、发布订阅、内存淘汰策略。
分布式：
CAP 定理： 一致性 (Consistency)、可用性 (Availability)、分区容忍性 (Partition Tolerance)。三者只能同时满足其二。分布式系统必须选择 P。CA 系统 (单机数据库) -> CP (Zookeeper, etcd) or AP (Cassandra, DynamoDB, Eureka)。
BASE 理论： 基本可用 (Basically Available)、软状态 (Soft State)、最终一致性 (Eventual Consistency)。对 CAP 中 AP 的扩展。
分布式事务： 见数据库部分。
分布式锁： 实现方式：数据库唯一索引、Redis (SETNX + EXPIRE, RedLock 算法)、Zookeeper (临时有序节点)。对比选型。
分布式 ID 生成： 要求：全局唯一、趋势递增、高可用。方案：UUID、数据库自增、Redis 自增、Snowflake 算法 (Twitter)、Leaf (美团)、TinyID (滴滴)。
一致性协议： 2PC、3PC、Paxos、Raft、ZAB (Zookeeper)。了解基本思想。
项目经验： 这是面试的核心！准备 1-2 个最能体现你技术深度和解决问题能力的项目。使用 STAR 法则 (Situation, Task, Action, Result) 描述项目背景、你的职责、采用的技术方案、遇到的挑战及如何解决、最终成果和量化指标。重点突出： 架构设计、性能优化、解决复杂问题、线上故障排查、技术选型考量、团队协作。

面试准备建议

针对性复习： 根据目标公司和职位要求（JD）调整复习重点。大厂通常更注重基础和并发、JVM、分布式；业务线可能更关注框架、数据库和项目。
深入理解原理： 不要停留在表面概念，要理解背后的设计思想、实现机制和优缺点。面试官喜欢追问“为什么”。
动手实践： 理论知识结合代码实践。尝试自己实现一些核心数据结构/算法、设计模式、并发工具。阅读优秀开源项目源码（如 JDK、Spring、MyBatis）。
模拟面试： 找朋友、同学或使用在线平台进行模拟面试，锻炼表达能力和临场反应。录音复盘。
准备问题： 思考面试官可能从哪个角度深入提问。准备一些高质量的问题在面试最后反问面试官（体现你的思考和对公司的兴趣）。
简历打磨： 简历是敲门砖！确保技术栈描述准确、项目经验突出亮点、数据量化成果。简历上的每一个点都要能展开讲清楚。
心态调整： 保持自信、积极、诚实。面试是双向选择的过程。坦然面对不会的问题，表达学习意愿。

金九银十，机会总是青睐有准备的人！这份总结为你指明了方向，但真正的提升在于持续的学习和实践。祝你面试顺利，拿到心仪的 Offer！

最后，再给大家分享一份小编这几年来总结的Java面试题，面试通过率非常之高！

从基础到进阶都有，深度和广度都满足了面试要求，Java相关（基础&进阶）、Java并发编程、JVM面试题、数据结构与算法、网络协议面试题、数据库、框架相关面试题、微服务、中间件相关、Linux、分布式、中间件、大数据与高并发、设计模式与实践、Java面试场景题；

由于包含的内容比较多，所以这里只做了简单的目录介绍，目录里面包含很多章节，每个章节里面都有相对应的小节，每个小节又包含很多的知识点；