Java 核心面试题与实战解析：从基础到 JVM | 极客日志

Javajava算法

Java 核心面试题与实战解析：从基础到 JVM

Java 面试考察范围广泛，涵盖基础语法、集合、并发、JVM 及 Spring 框架等核心模块。本文整理了高频考点，详解 HashMap 底层结构、线程池参数调优、类加载双亲委派模型及 Spring AOP 原理，配合代码示例剖析易错点，助力开发者夯实基础，从容应对技术挑战。

花里胡哨发布于 2026/3/26更新于 2026/4/251 浏览

Java 核心面试题与实战解析

一、Java 基础语法与核心特性

1. Java 的核心特性有哪些？

解析：

跨平台性：通过 JVM 实现，字节码文件可在任意支持 JVM 的操作系统运行（Write Once, Run Anywhere）。
面向对象：封装、继承、多态三大核心特性。
安全性：支持沙箱机制、字节码校验、权限控制（如文件 IO 权限）。
健壮性：自动垃圾回收（GC）避免内存泄漏，强类型检查、异常处理机制减少运行时错误。
分布式：支持 RMI、HTTP 协议，便于开发分布式应用。
多线程：内置多线程 API，支持并发编程。

2. 基本数据类型与包装类的区别？

维度	基本数据类型（如 int、float）	包装类（如 Integer、Float）
本质	原始值，无对象属性	引用类型，继承 Object 类
默认值	有（如 int 默认 0，boolean 默认 false）	无，默认 null
适用场景	简单运算、局部变量，效率高	集合框架（如 List）、泛型、需要 null 值的场景
缓存机制	无	部分包装类（Integer[-128~127]、Byte、Short 等）有常量池缓存

关键考点：

自动装箱/拆箱：Java 5+ 特性，编译器自动完成基本类型与包装类的转换。
缓存陷阱：Integer a = 127; Integer b = 127; → a == b为 true（复用缓存）；Integer c = 128; Integer d = 128; → c == d为 false（新建对象），需用 equals() 比较值。

3. String、StringBuffer、StringBuilder 的区别？

解析： 核心差异在于可变性和线程安全：

String：不可变（底层是 final 修饰的 char 数组/JDK9+ byte 数组），每次修改都会创建新对象，效率低。
StringBuffer：可变，线程安全（方法加 synchronized 锁），适用于多线程环境的字符串拼接。
StringBuilder：可变，线程不安全，效率高于 StringBuffer，适用于单线程环境的字符串拼接。

底层原理： String 的不可变性源于 private final char value[]（JDK8）。StringBuffer 和 StringBuilder 继承 AbstractStringBuilder，底层是可变 char 数组，扩容机制为：默认初始容量 16，当长度超过容量时，新容量=原容量×2+2，不足则直接扩容到所需长度。

4. final 关键字的三种用法？

修饰类：类不可被继承（如 String、Math），子类无法扩展其功能。

维度	接口（Interface）	抽象类（Abstract Class）
继承方式	多实现（一个类可实现多个接口）	单继承（一个类只能继承一个抽象类）
成员变量	只能是 public static final 常量	可包含普通变量、静态变量、常量
成员方法	JDK8 前：只能是抽象方法；JDK8+：支持 default/static 方法；JDK9+：支持 private 方法	可包含抽象方法、普通方法、静态方法
构造方法	无	有（不能实例化，供子类调用）
设计目的	定义行为规范，解耦（如 List 接口）	定义类的模板，复用代码（如 HttpServlet）

维度	ArrayList（数组实现）	LinkedList（双向链表实现）
底层结构	动态数组（Object[]）	双向链表（每个节点存储 prev、next、value）
访问效率	随机访问快（O(1)）	随机访问慢（O(n)），需遍历链表
增删效率	尾部增删快（O(1)），中间增删慢（O(n)）	中间增删快（O(1)），尾部增删需遍历（O(n)）
内存占用	连续内存，占用少	非连续内存，每个节点有额外指针开销
线程安全	不安全	不安全

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}
// 启动
new MyThread().start();

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}
// 启动
new Thread(new MyRunnable()).start();

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
}
// 启动
FutureTask<String> future = new FutureTask<>(new MyCallable());
new Thread(future).start();
String result = future.get(); // 获取返回值

维度	synchronized（内置锁）	Lock（显式锁，如 ReentrantLock）
锁实现	JVM 层面实现（C++ 代码）	JDK 层面实现（Java 代码）
锁获取与释放	自动获取、自动释放	手动获取（lock()）、手动释放（unlock()）
锁类型	可重入锁、非公平锁（默认）	可重入锁，支持公平锁/非公平锁
功能扩展	无	支持中断锁、超时锁、条件变量
性能	JDK6+ 优化后，性能接近 Lock	高并发场景下性能更优，灵活度高

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public ThreadPoolExecutor(
    int corePoolSize,      // 核心线程数
    int maximumPoolSize,   // 最大线程数
    long keepAliveTime,    // 临时线程空闲时间
    TimeUnit unit,         // 时间单位
    BlockingQueue<Runnable> workQueue, // 任务阻塞队列
    ThreadFactory threadFactory,       // 线程创建工厂
    RejectedExecutionHandler handler   // 拒绝策略
)

@Aspect
@Component
public class LogAspect {
    @Pointcut("execution(public * com.example.service..*(..))")
    public void servicePointcut() {}

    @Around("servicePointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("方法调用前");
        Object result = joinPoint.proceed();
        System.out.println("方法调用后");
        return result;
    }
}