java 面试题 400 道题

1. Java 基础语法（50 道）

Java 的基本数据类型有哪些？
== 和 equals() 的区别？
final、finally、finalize() 的区别？
static 修饰符的作用？
Java 中的自动装箱和拆箱是什么？
Java 中的强制类型转换与自动类型转换区别？
Java 中的 String 是不可变对象吗？为什么？
String、StringBuilder、StringBuffer 区别？
什么是 Java 的包装类？
Java 中的 transient 关键字作用？
Java 中的 volatile 关键字作用？
instanceof 的作用是什么？
super 和 this 的区别？
Java 中的默认访问修饰符是什么？
构造函数和方法有什么区别？
Java 中的局部变量和成员变量区别？
Java 中的接口和抽象类区别？
Java 中的多态是什么？举例说明。
Java 中的重载与重写区别？
Java 的包装类有哪些？
Java 中的 break、continue 区别？
Java 中的 enum 用法？
Java 中的 hashCode() 和 equals() 关系？
Java 中的 Object 类有哪些常用方法？
Java 中的异常体系结构？
checked 异常和 unchecked 异常区别？
如何自定义异常？
Java 中 try-with-resources 用法？
Java 中 assert 关键字作用？
Java 中的 package 用法？
Java 中的 import 和 package 区别？
Java 中的 Class.forName() 作用？
Java 中的 getClass() 与 Class.forName() 区别？
Java 中的 clone() 方法作用？
Java 中的浅拷贝与深拷贝区别？
Java 中的 finalize() 方法作用？
Java 中 System.gc() 的作用？
Java 中的 Math 类常用方法？
Java 中的 Random 类和 ThreadLocalRandom 区别？
Java 中的 Arrays 和 Collections 工具类作用？
Java 中的 Optional 类作用？
Java 8 新特性有哪些？
Java 8 的 Lambda 表达式语法？
Java 8 的 Stream 流操作？
Java 中方法引用（Method Reference）用法？
Java 中的 Predicate、Function、Consumer 区别？
Java 中的 default 方法作用？
Java 中 var 关键字作用？
Java 中 record 关键字作用？
Java 中的模块化（Module）机制是什么？

2. Java 集合框架（50 道）

Java 中的 Collection 和 Map 区别？
List、Set、Map 的区别？
ArrayList 和 LinkedList 区别？
HashMap 和 Hashtable 区别？
HashMap 内部结构？
HashMap 如何处理哈希冲突？
HashMap 的负载因子（load factor）作用？
HashMap 的扩容机制？
HashMap 是线程安全的吗？
ConcurrentHashMap 原理？
HashSet 底层实现？
TreeSet 底层实现？
TreeMap 和 HashMap 区别？
LinkedHashMap 的实现原理？
Collections.synchronizedXXX 与 ConcurrentXXX 区别？
CopyOnWriteArrayList 作用？
阻塞队列（BlockingQueue）有哪些？
PriorityQueue 原理？
Deque 接口用法？
Stack、Vector 和 ArrayList 区别？
Java 中 Iterator、ListIterator 区别？
fail-fast 和 fail-safe 集合区别？
Enumeration 与 Iterator 区别？
Map 中 key 的 hash 冲突如何处理？
Map 中 key 为自定义对象时需要重写什么方法？
WeakHashMap 的用途？
IdentityHashMap 作用？
EnumMap 作用？
LinkedHashMap 如何实现 LRU 缓存？
ConcurrentHashMap 分段锁原理？
Java 集合排序方法有哪些？
Java 中 Collections.sort() 与 Arrays.sort() 区别？
Comparable 和 Comparator 区别？
集合深拷贝和浅拷贝实现方式？
Map 中 get() 返回 null 的原因？
Map 中 key 和 value 可以为 null 吗？
HashMap 允许 key 重复吗？
Set 如何保证元素唯一性？
如何使用 Stream 对集合进行过滤和排序？
集合框架的线程安全策略？
CopyOnWriteArraySet 用途？
LinkedList 如何实现队列和栈？
Deque 双端队列的应用场景？
PriorityQueue 自定义比较器使用方法？
Map 的 keySet()、values()、entrySet() 区别？
集合遍历方式有哪些？
Stream 流和 Collection 的区别？
HashMap 的 putIfAbsent() 方法作用？
Java 9 新增集合工厂方法？
集合工具类（Collections/Arrays）常用方法？

3. Java 多线程与并发（51-100）

Java 中线程的生命周期？
Java 中如何创建线程？有哪些方式？
Runnable 和 Callable 区别？
Thread 和 Runnable 哪个更优？
Java 中的线程池（ThreadPool）有哪些类型？
Executors.newFixedThreadPool() 和 newCachedThreadPool() 区别？
Java 中线程优先级如何设置？
Java 中的 synchronized 关键字作用？
synchronized 方法和 synchronized 块区别？
synchronized 修饰静态方法与实例方法区别？
Java 中的重入锁（ReentrantLock）作用？
ReentrantLock 和 synchronized 区别？
ReentrantReadWriteLock 用法？
Condition 的作用？
Java 中的 volatile 关键字作用？
volatile 可以替代 synchronized 吗？为什么？
Java 内存模型（JMM）概念？
Java 中的 happens-before 原则？
原子操作类（AtomicInteger/AtomicReference）作用？
CAS（Compare-And-Swap）原理？
Java 中 CountDownLatch 用法？
Java 中 CyclicBarrier 用法？
Java 中 Semaphore 用法？
Java 中 Exchanger 用法？
BlockingQueue 实现原理？
LinkedBlockingQueue 和 ArrayBlockingQueue 区别？
ConcurrentHashMap 如何保证线程安全？
CopyOnWriteArrayList 的特点与适用场景？
ThreadLocal 原理及使用场景？
Java 中的死锁原因及解决方案？
Java 中的活锁和饥饿问题？
Thread.join() 用法？
Thread.sleep() 和 Object.wait() 区别？
notify()、notifyAll() 与 wait() 用法？
Java 中线程中断机制？
daemon 线程作用？
Java 线程优先级的实现原理？
Java 中 Future、FutureTask 区别？
ForkJoinPool 用法？
ForkJoinPool 的工作窃取算法？
Java 并发包中的 DelayQueue 用法？
Phaser 类用途？
ThreadPoolExecutor 拒绝策略有哪些？
Java 中线程安全集合有哪些？
Java 中不可变集合如何保证线程安全？
synchronized 与 Lock 哪个性能更高？
Java 并发包中的双重检查锁（Double-Checked Locking）？
Java 中原子类的底层实现？
Java 中线程安全单例实现方法？
Java 并发工具类有哪些常用方法？

4. JVM 与内存管理（101-150）

101. JVM 组成部分？

JVM主要由五个部分组成：
第一是类加载器子系统，负责把Java类加载到内存，并进行验证、解析和初始化；
第二是运行时数据区，包括堆、方法区、程序计数器、Java栈和本地方法栈，用于存储对象、方法和线程私有数据；
第三是执行引擎，负责字节码的执行，包括解释器和JIT即时编译器，同时负责垃圾回收；
第四是本地方法接口，支持调用C/C++等本地代码；
第五是本地方法库，存放具体实现的本地方法。
总结来说，JVM就是通过类加载、内存管理和执行引擎，把Java程序运行起来的虚拟机。”

102. JVM 内存结构？

-----------------------------------
|          元数据空间/Metaspace    |  ← 堆外内存
-----------------------------------
|          直接内存/DirectMemory   |  ← 堆外内存
-----------------------------------
|             堆 Heap              |  ← G1 GC 管理
|  Eden | Survivor | Old Gen | Humongous |
-----------------------------------
|        线程私有内存区域          |
|---------------------------------|
| 程序计数器 | Java栈 | 本地方法栈   |
-----------------------------------

103. 堆（Heap）和栈（Stack）区别？

对比项	堆（Heap）	栈（Stack）
作用范围	线程共享	线程私有
主要存储内容	对象实例、数组	局部变量、方法参数、返回地址
内存分配速度	较慢（需GC管理）	快（方法调用即分配）
生命周期	由垃圾回收器决定	随方法调用结束立即销毁
是否有GC参与	是	否
内存溢出错误	`OutOfMemoryError: Java heap space`	`StackOverflowError`
管理者	JVM的垃圾回收器（GC）	JVM自动分配和释放
示例	`new` 出来的对象	局部变量、方法参数

方法区（Method Area）作用？

内容类型	说明
类的结构信息	类名、访问修饰符、字段、方法、父类、接口等
运行时常量池	存放编译期生成的各种字面量和符号引用
静态变量（static）	属于类而非实例的变量
JIT 编译后的代码	热点方法编译成机器码后的缓存
类加载信息	类加载器、常量池引用等信息

Java 堆分代（Young/Old/Perm/Metaspace）？

区域	主要职责	说明
Eden 区	新对象的主要分配区	对象创建后首先进入此处
Survivor 区	存活对象的中转区	经历多次 Minor GC 后晋升老年代
Old 区	存放长期存活对象	Major GC/Full GC 在此执行
PermGen/Metaspace	存放类元数据	不在堆中，属于方法区的一部分

106. 新生代（Young Generation）组成？

┌───────────────────────────────┐
│         新生代 (Young)         │
│ ┌────────────┬────┬────┐      │
│ │    Eden     │ S0 │ S1 │      │
│ │ (约80%)     │10% │10% │      │
│ └────────────┴────┴────┘      │
└───────────────────────────────┘

107. Eden、Survivor 区作用？

Eden 和 Survivor 区都属于年轻代（Young Generation）。当新对象被创建时，首先会分配在 Eden 区；当 Eden 区满时，会触发 Minor GC（年轻代垃圾回收），存活下来的对象会从 Eden 复制到 Survivor 区（S0/S1），Survivor 区有两个，叫 From 区和 To 区，在回收过程中不断交换。对象在 Survivor 区多次存活后，会晋升（Promote）到老年代。这样可以减少对象在老年代的数量，提高 GC 效率。
108. GC（垃圾回收）机制？

109. Minor GC 和 Major GC 区别？

区别点	Minor GC（Young GC）	Major GC（Old GC）/Full GC
回收区域	只回收年轻代（Eden + Survivor）	回收老年代（可能连年轻代、元空间一起）
触发条件	Eden 区空间不足	老年代空间不足 / System.gc() / JDK 工具触发
速度	较快（存活对象少）	较慢（对象多、扫描范围大）
频率	频繁	较少
暂停类型	Stop-The-World（暂停所有线程）	Stop-The-World（耗时更长）
算法	复制算法（Copying）	标记–清除（Mark-Sweep）或标记–整理（Mark-Compact）
是否回收整个堆	否，只回收新生代	Major 只回收老年代，Full GC 会回收整个堆 + 元空间
对应用影响	停顿短	停顿长，影响性能大

Java 中垃圾收集器有哪些？

111. Serial、Parallel、CMS、G1 区别？

Java 中内存泄漏原因？
如何避免内存泄漏？
Java 中常见 OutOfMemoryError 类型？
Java 堆内存溢出与栈溢出区别？
GC Roots 是什么？

类型	描述
栈帧中的本地变量	方法调用栈（Stack Frame）中引用的对象，包括方法参数和局部变量
方法区中的类静态变量	被类静态字段引用的对象
方法区中的常量	常量池中引用的对象
JNI 引用的对象	通过 JNI 调用本地代码时引用的对象
活跃线程	线程对象本身在运行过程中是 GC Roots
其他 JVM 内部引用	如系统类加载器引用等

引用类型（强、软、弱、虚引用）区别？
ReferenceQueue 的作用？
finalize() 方法作用？
System.gc() 是否强制回收？
JVM 参数 -Xmx、-Xms、-XX:PermSize 作用？
JIT 编译器作用？
JVM 如何进行方法内联优化？
JVM 对象的内存布局？
对象头（Mark Word）作用？
Java 对象对齐原则？
Escape Analysis 原理？
Thread-Local 变量对内存影响？
WeakHashMap 和内存回收关系？
G1 垃圾回收器特点？
CMS 垃圾回收器缺点？
Serial 收集器适用场景？
Parallel 收集器适用场景？
GC 日志分析方法？
Java 中内存溢出的调试方法？
如何优化 Java 内存使用？
常见的内存泄漏场景？
尽管 Java 拥有自动垃圾回收机制（Garbage Collector, GC），但仍会发生内存泄漏（Memory Leak）。

在 Java 中，“内存泄漏”的准确定义是：应用程序代码中存在对不再需要的对象的引用，导致 GC 无法回收这些对象所占用的内存。 随着时间推移，这些堆积起来的“僵尸对象”最终会导致 java.lang.OutOfMemoryError。

以下是 Java 中最常见和典型的内存泄漏原因：

1. 静态集合（Static Collections）的滥用

原因： 静态字段在整个应用程序生命周期中都存在于内存中，GC 永远不会回收静态字段本身。如果一个静态集合（如 static HashMap 或 static ArrayList）存储了大量的对象引用，并且没有适时地从集合中移除不再需要的对象，那么这些被引用的对象将永远无法被 GC 回收。

示例：

public class CacheManager {
    // 静态集合在整个应用生命周期中都不会被回收
    private static final List<HeavyObject> cache = new ArrayList<>();

    public static void add(HeavyObject obj) {
        cache.add(obj); // 持续添加，但从不移除
    }
}
// 即使其他地方不再使用 HeavyObject 实例，只要它在静态列表中，就不会被回收。

2. 未注销的监听器和回调（Listeners and Callbacks）

原因： 在使用观察者模式（Observer Pattern）或注册监听器（Listener）时，如果一个对象（观察者）注册到另一个生命周期更长的对象（主题/Subject）上，但随后没有调用 removeListener() 或 unregister() 来取消注册，那么主题对象就会持有观察者对象的引用。

示例： 在一个长时间运行的 Web 服务器中：

主题： Web 容器管理的全局对象或静态对象。
观察者： 某个短暂的业务组件（如一个 Session 范围的 Bean）。
如果该业务组件注册为一个监听器后被销毁，但全局对象仍然持有它的引用，就会导致该业务组件及其依赖的对象无法被回收。

3. `ThreadLocal` 的不当使用

原因： ThreadLocal 变量提供了线程本地的存储能力。在使用线程池的服务器环境（如 Web 应用）中，线程会被复用。

当一个 ThreadLocal 变量被设置值后，它会存储在一个与当前线程绑定的 ThreadLocalMap 中。
如果不调用 ThreadLocal.remove() 来清理该值，即使业务代码执行完毕，线程仍然持有该值的引用。当该线程被回收利用执行下一个请求时，上一个请求的数据仍然存在，造成内存泄漏。

4. 未关闭的资源（Unclosed Resources）

原因： 文件流（InputStream/OutputStream）、数据库连接（Connection）、结果集（ResultSet）和网络套接字（Socket）等资源，在使用后必须显式地调用 close() 方法释放。这些资源在底层通常会占用操作系统资源，并在 Java 堆中持有对缓冲区的引用。

示例：

public void readFile(File file) {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(file);
        // ... 读取文件 ...
    } catch (IOException e) {
        // 异常处理
    } 
    // <--- 危险：如果这里没有 finally 块或 try-with-resources 关闭 fis，会泄漏！
}

解决方案： 强烈推荐使用 try-with-resources 语句，它能确保实现了 AutoCloseable 接口的资源总能被自动关闭。

5. `equals()` 和 `hashCode()` 方法实现不当

原因： 当对象被用作基于散列的集合（如 HashMap、HashSet、Hashtable）的键（Key）时，如果该类的 equals() 和 hashCode() 方法没有被正确地或一致地实现，可能导致：

对象无法被正确检索： 您可能无法通过 get() 方法找到先前插入的对象。
重复对象堆积： 即使您试图用相同的逻辑对象覆盖键，由于 hashCode() 不一致，新的对象仍可能被视为不同的键插入，导致集合中堆积了逻辑上重复但物理上不同的对象，从而泄漏内存。

6. 内部类持有外部类引用

原因： 非静态内部类（Inner Class）会隐式持有其外部类（Outer Class）的引用。如果一个非静态内部类的实例生命周期比其外部类实例长，那么非静态内部类实例就会阻止外部类实例被 GC 回收。

解决方案： 如果内部类不需要访问外部类实例的成员，应该将其声明为 static 内部类（或静态嵌套类），从而切断对外部类的隐式引用。

138. 常见的对象过度创建问题？

常见的对象过度创建问题主要是指在程序中频繁创建短生命周期对象，导致 GC 压力大、CPU 占用高，甚至触发频繁的 Stop-The-World。常见场景包括：大量临时对象、字符串频繁拼接、大数组或集合重复创建、重复包装/拆箱等。解决方法通常包括对象重用、缓存、对象池以及减少不必要的创建。

类型	典型例子	问题
字符串过度创建	`"a" + "b"` 在循环里，每次都会生成新对象	增加堆内存和 GC 压力
临时集合/对象频繁创建	循环里每次 `new ArrayList<>()`	对象生命周期短，GC 频繁触发
自动装箱/拆箱	`Integer i = i + 1;`	产生大量临时包装对象
重复大对象分配	每次请求都创建大数组或缓存	内存占用高，影响性能
不可复用对象	没有使用对象池或缓存	CPU 和 GC 压力增加

139. JVM 堆外内存（Direct Memory）作用？

对比项	堆内内存（Heap）	堆外内存（Direct / Off-Heap）
内存位置	JVM 堆	操作系统内存（Native Memory）
管理方式	JVM GC 自动管理	不受 GC 直接管理，需要系统或显式释放
访问速度	相对慢	快，可直接与操作系统 IO 交互
分配/释放成本	低	高，频繁分配可能影响性能
典型使用场景	一般对象分配	大量网络/文件 IO、高性能缓存、NIO Buffer

140. Java NIO 的 ByteBuffer 与堆内存区别？

对比项	Heap ByteBuffer	Direct ByteBuffer
内存位置	JVM 堆内	堆外内存（Native Memory）
分配方式	`ByteBuffer.allocate(capacity)`	`ByteBuffer.allocateDirect(capacity)`
访问速度	较慢（需通过 JVM 内存拷贝到内核）	较快（可直接通过内核操作）
GC 管理	垃圾回收器自动管理	由操作系统管理，需要显式或延迟释放
分配开销	小	较大
适用场景	小数据量或频繁分配释放	大数据量、高性能 IO（文件、网络）

141. PermGen 与 Metaspace 区别？

对比项	PermGen（永久代）	Metaspace（元空间）
出现版本	JDK 7 及之前	JDK 8 及之后
所在内存区域	JVM 堆内	本地内存（Native Memory）
存储内容	类的元数据、静态变量、常量池等	同样是类元数据、静态变量、常量池等
是否自动扩展	否（固定大小）	是（受系统可用内存限制）
参数设置	`-XX:PermSize`、`-XX:MaxPermSize`	`-XX:MetaspaceSize`、`-XX:MaxMetaspaceSize`
常见异常	`OutOfMemoryError: PermGen space`	`OutOfMemoryError: Metaspace`
被移除原因	容量固定、难以调优	改用本地内存更灵活、易管理

Java 类加载机制？
双亲委派模型作用？
ClassLoader 的类型？
如何自定义 ClassLoader？
类加载器导致的内存泄漏原因？
Java 静态变量对内存的影响？
JVM 内存模型和线程安全的关系？
Java 中逃逸分析如何优化对象分配？
JVM 调优常用参数及实践？

5. Java IO 与网络（151-200）

Java 中 IO 流分类？
InputStream 和 Reader 区别？
OutputStream 和 Writer 区别？
字节流和字符流区别？
Java 中 BufferedReader、BufferedWriter 用法？
Java 中 FileInputStream、FileOutputStream 用法？
Java 中 FileReader、FileWriter 用法？
Java NIO 与传统 IO 区别？
ByteBuffer、CharBuffer 用法？
Channel、Selector、Buffer 关系？
Java 中 RandomAccessFile 用法？
Java 中对象序列化（Serializable）原理？
transient 关键字与序列化的关系？
Externalizable 接口作用？
Java 中序列化与反序列化安全问题？
Java 中 Socket 与 ServerSocket 用法？
TCP 与 UDP 区别？
Java 中 URL 与 HttpURLConnection 用法？
Java 中 DatagramSocket、DatagramPacket 用法？
NIO 的非阻塞 IO 原理？
Selector 的作用？
Java 中 Pipe 用法？
Java 中文件锁（FileLock）用法？
Java 中 WatchService 文件监控？
Java 中 BufferedInputStream 和 BufferedReader 区别？
Java 中 PrintWriter 和 BufferedWriter 区别？
Java IO 异常处理注意事项？
Java 中 Charset 编码与解码？
Java NIO 与多线程结合使用注意事项？
Java 中 Memory Mapped File 用法？
Java 中 Scanner 与 BufferedReader 区别？
Java 中 ObjectInputStream 和 ObjectOutputStream 用法？
Java 网络 IO 中阻塞与非阻塞区别？
Java NIO Selector 多路复用机制原理？
Java 中 SocketChannel、ServerSocketChannel 用法？
Java 中 DatagramChannel 用法？
Java 网络编程中 TCP 粘包和拆包问题？
Java 中管道流（PipedInputStream/PipedOutputStream）用法？
Java NIO 的 ByteBuffer flip()、clear()、rewind() 方法作用？
Java 中 Socket 超时设置方法？
Java 中异步 IO（AsynchronousChannel）用法？
Java 中 HttpClient 与 HttpURLConnection 区别？
Java 中 BIO、NIO、AIO 区别？
Java 中 URLClassLoader 与网络资源加载？
Java 中 DatagramSocket 广播实现？
Java 网络编程中心跳机制如何实现？
Java 网络 IO 性能优化方法？
Java 中 TCP 长连接和短连接区别？
Java 中 SSL/TLS 在网络通信中作用？
Java 网络异常处理注意事项？

6. Java 设计模式（201-250）

什么是设计模式？
设计模式分类？
单例模式实现方式？
懒汉式单例和饿汉式单例区别？
双重检查锁单例实现原理？
枚举实现单例原理？
工厂模式（Factory）作用？
简单工厂模式与工厂方法模式区别？
抽象工厂模式用法？
观察者模式（Observer）作用？
Java 中 Observer 与 Observable 区别？
代理模式（Proxy）作用？
静态代理与动态代理区别？
JDK 动态代理与 CGLIB 动态代理区别？
装饰器模式（Decorator）作用？
适配器模式（Adapter）作用？
组合模式（Composite）作用？
策略模式（Strategy）作用？
状态模式（State）作用？
模板方法模式（Template Method）作用？
职责链模式（Chain of Responsibility）作用？
命令模式（Command）作用？
迭代器模式（Iterator）作用？
中介者模式（Mediator）作用？
备忘录模式（Memento）作用？
原型模式（Prototype）作用？
享元模式（Flyweight）作用？
桥接模式（Bridge）作用？
建造者模式（Builder）作用？
单例模式在多线程下如何保证安全？
工厂模式在 Spring 中应用场景？
代理模式在 AOP 中应用？
装饰器模式在 IO 流中的应用？
观察者模式在事件驱动中的应用？
模板方法模式在 JDBC 编程中的应用？
策略模式在排序或算法选择中的应用？
状态模式在状态机中的应用？
职责链模式在日志处理中的应用？
命令模式在任务队列中的应用？
迭代器模式在集合遍历中的应用？
中介者模式在 GUI 系统中的应用？
备忘录模式在撤销操作中的应用？
原型模式在对象克隆中的应用？
享元模式在缓存或池化对象中的应用？
桥接模式在数据库操作中的应用？
建造者模式在复杂对象创建中的应用？
单例模式常见反射和序列化攻击？
工厂模式如何结合 Spring IoC 使用？
设计模式如何提高代码可维护性？
设计模式如何提高系统可扩展性？

9. 微服务与分布式（351-400）

什么是微服务架构？
微服务与单体架构区别？
微服务的优缺点？
微服务拆分的原则？
服务注册与发现原理？
Eureka、Consul、Zookeeper 区别？
微服务负载均衡方式？好的，我们接下来整理 Java 面试题 251-350，覆盖 Spring 框架（251-300） 和 数据库与 ORM（301-350）。

7. Spring 框架（251-300）

Spring 框架的核心模块有哪些？
Spring IOC（依赖注入）原理？
Spring AOP（面向切面编程）原理？
BeanFactory 与 ApplicationContext 区别？
Spring 中 Bean 的作用域有哪些？
单例（singleton）与原型（prototype）区别？
Spring 中如何实现依赖注入？
@Autowired 注解作用？
@Resource 注解作用？
@Inject 注解作用？
构造器注入和 Setter 注入区别？
Spring 生命周期回调方法？
BeanPostProcessor 用法？
InitializingBean 和 DisposableBean 接口作用？
@PostConstruct 与 @PreDestroy 注解作用？
Spring 中懒加载（lazy-init）原理？
Spring 中 FactoryBean 用法？
Spring 中 Scope 自定义作用域？
Spring 中的事件机制如何使用？
Spring 中事务管理方式有哪些？
编程式事务与声明式事务区别？
@Transactional 注解作用？
Spring AOP 实现原理？
Spring 中 JDK 动态代理与 CGLIB 区别？
Spring 中切面表达式（Pointcut）用法？
Spring 中环绕通知（Around Advice）作用？
Spring Boot 的作用？
Spring Boot 与 Spring 区别？
Spring Boot 自动配置原理？
@SpringBootApplication 注解作用？
Spring Boot Starter 作用？
Spring Boot 配置文件 application.yml 与 application.properties 区别？
Spring Boot Profile 用法？
Spring Boot Actuator 作用？
Spring Boot 与 Spring MVC 结合使用？
Spring Security 基本原理？
Spring 中如何实现 Bean 循环依赖？
Spring 中懒加载与提前加载区别？
Spring 中如何使用自定义注解？

290. Spring 中 Aware 接口作用？

实例化 Bean → 调用构造器
依赖注入 → 填充普通属性
Aware 回调 → Spring 容器自动调用实现接口的方法
BeanPostProcessor 前置处理
初始化方法（@PostConstruct / afterPropertiesSet / init-method）
BeanPostProcessor 后置处理
Bean 可用

Spring MVC 与 RESTful 区别？
DispatcherServlet 工作原理？
HandlerMapping 作用？
HandlerAdapter 作用？
ViewResolver 作用？
Spring MVC 参数绑定机制？
Spring MVC 异常处理方式？
Spring 中拦截器（Interceptor）与 Filter 区别？
Spring Boot 日志配置方法？
Spring 框架如何提高系统可维护性和可扩展性？

8. 数据库与 ORM（301-350）

Java 中 JDBC 基本操作流程？
JDBC 中 Connection、Statement、PreparedStatement 区别？
ResultSet 用法与类型？
JDBC 事务管理方式？
JDBC 自动提交与手动提交区别？
SQL 注入是什么？如何防止？
PreparedStatement 如何防止 SQL 注入？
JDBC 批处理操作（batch）用法？
数据库连接池（Connection Pool）作用？
DBCP、HikariCP 区别？
ORM（对象关系映射）概念？
Hibernate 框架作用？
JPA（Java Persistence API）作用？
EntityManager 与 Session 区别？
Hibernate 映射配置方式？
Hibernate 中一级缓存与二级缓存区别？
JPA 中持久化上下文（Persistence Context）作用？
Hibernate 延迟加载（Lazy Loading）与立即加载（Eager Loading）区别？
Hibernate 乐观锁与悲观锁区别？
JPA 中 @OneToOne、@OneToMany、@ManyToOne、@ManyToMany 用法？
Hibernate HQL 与 SQL 区别？
Hibernate Criteria 查询用法？
Spring Data JPA 用法？
Spring Data JPA 方法命名规则？
ORM 框架如何处理 N+1 查询问题？
Hibernate 中 Session 与 Transaction 关系？
JPA 中 flush() 方法作用？
Hibernate 中 save() 与 persist() 区别？
Hibernate merge() 与 update() 区别？
Hibernate delete() 与 remove() 区别？
ORM 框架缓存机制作用？
ORM 框架优化性能的方式？
JDBC 与 ORM 框架优缺点？
Hibernate 查询缓存（Query Cache）用法？
JPA 原生 SQL 与 JPQL 区别？
Hibernate 对象状态（瞬时、持久、脱管）？
ORM 框架如何处理事务？
Hibernate 与 Spring 事务结合方式？
数据库乐观锁实现方式？
数据库悲观锁实现方式？
ORM 框架的延迟加载陷阱？
Hibernate @Cacheable 注解作用？
Spring Data JPA @Query 注解用法？
ORM 框架批量插入优化方式？
ORM 框架分页查询方式？
ORM 框架动态查询实现方式？
Hibernate Validator 校验机制？
JPA 中 EntityListener 作用？
ORM 框架在微服务中应用注意事项？
ORM 框架如何提高系统性能和可维护性？
Ribbon 与 Nginx 负载均衡区别？
微服务中的 API 网关作用？
Zuul、Spring Cloud Gateway 区别？
微服务通信方式：同步与异步？
REST 与 gRPC 区别？
微服务中如何保证事务一致性？
分布式事务解决方案有哪些？
TCC 模式原理？
可靠消息服务（RMQ）模式原理？
Saga 模式原理？
微服务限流（Rate Limiting）策略？
微服务熔断（Circuit Breaker）原理？
Hystrix 与 Resilience4j 区别？
微服务降级策略？
服务监控与链路追踪（Spring Cloud Sleuth/Zipkin）？
分布式缓存使用场景？
Redis 与 Memcached 区别？
分布式锁实现方式？
Redis 分布式锁原理与问题？
Zookeeper 实现分布式锁原理？
微服务中幂等性问题如何解决？
微服务中的配置中心作用？
Spring Cloud Config 与 Nacos 配置中心区别？
微服务的安全性方案？
OAuth2 与 JWT 原理及区别？
微服务灰度发布实现方式？
微服务版本管理策略？
微服务的服务降级与熔断配置？
微服务如何实现服务间调用链路追踪？
微服务如何处理高并发？
分布式 ID 生成方案？
Snowflake 算法原理？
分布式消息队列作用？
Kafka、RabbitMQ、RocketMQ 区别？
消息的幂等性如何保证？
消息顺序消费如何实现？
微服务如何处理数据一致性问题？
数据库分库分表策略？
分布式事务与最终一致性区别？
微服务如何实现服务降级？
微服务如何实现服务注册失败处理？
微服务高可用设计原则？
微服务如何保证系统可扩展性和可维护性？

posted @ 2025-10-20 11:16 不报异常的空指针阅读(11) 评论(0) 收藏举报

刷新页面返回顶部

jiangweiwang

java 面试题 400 道题

1. Java 基础语法（50 道）

2. Java 集合框架（50 道）

3. Java 多线程与并发（51-100）

4. JVM 与内存管理（101-150）

101. JVM 组成部分？

102. JVM 内存结构？

103. 堆（Heap）和栈（Stack）区别？

106. 新生代（Young Generation）组成？

107. Eden、Survivor 区作用？

109. Minor GC 和 Major GC 区别？

111. Serial、Parallel、CMS、G1 区别？

1. 静态集合（Static Collections）的滥用

2. 未注销的监听器和回调（Listeners and Callbacks）

3. `ThreadLocal` 的不当使用

4. 未关闭的资源（Unclosed Resources）

5. `equals()` 和 `hashCode()` 方法实现不当

6. 内部类持有外部类引用

138. 常见的对象过度创建问题？

139. JVM 堆外内存（Direct Memory）作用？

140. Java NIO 的 ByteBuffer 与堆内存区别？

141. PermGen 与 Metaspace 区别？

5. Java IO 与网络（151-200）

6. Java 设计模式（201-250）

9. 微服务与分布式（351-400）

7. Spring 框架（251-300）

290. Spring 中 Aware 接口作用？

8. 数据库与 ORM（301-350）

公告

jiangweiwang

java 面试题 400 道题

1. Java 基础语法（50 道）

2. Java 集合框架（50 道）

3. Java 多线程与并发（51-100）

4. JVM 与内存管理（101-150）

101. JVM 组成部分？

102. JVM 内存结构？

103. 堆（Heap）和栈（Stack）区别？

106. 新生代（Young Generation）组成？

107. Eden、Survivor 区作用？

109. Minor GC 和 Major GC 区别？

111. Serial、Parallel、CMS、G1 区别？

1. 静态集合（Static Collections）的滥用

2. 未注销的监听器和回调（Listeners and Callbacks）

3. ThreadLocal 的不当使用

4. 未关闭的资源（Unclosed Resources）

5. equals() 和 hashCode() 方法实现不当

6. 内部类持有外部类引用

138. 常见的对象过度创建问题？

139. JVM 堆外内存（Direct Memory）作用？

140. Java NIO 的 ByteBuffer 与堆内存区别？

141. PermGen 与 Metaspace 区别？

5. Java IO 与网络（151-200）

6. Java 设计模式（201-250）

9. 微服务与分布式（351-400）

7. Spring 框架（251-300）

290. Spring 中 Aware 接口作用？

8. 数据库与 ORM（301-350）

公告

3. `ThreadLocal` 的不当使用

5. `equals()` 和 `hashCode()` 方法实现不当