Java 常见面试题及答案汇总 | 极客日志

Javajava算法

Java 常见面试题及答案汇总

Java 面试核心覆盖基础语法、集合框架、多线程并发、JVM 内存模型、Spring 原理及数据库优化。内容深入解析了 String 不可变性、HashMap 哈希冲突解决、线程池参数配置、GC 收集器选择及 Spring AOP 动态代理机制。结合代码示例演示了单例模式实现、事务失效排查及 MyBatis 缓存策略，旨在帮助开发者系统掌握高频考点与底层逻辑，提升实战能力。

KernelLab发布于 2026/3/20更新于 2026/4/242 浏览

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

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

跨平台性：通过 JVM（Java 虚拟机）实现，字节码文件可在任意支持 JVM 的操作系统运行；
面向对象：封装、继承、多态三大核心特性；
安全性：支持沙箱机制、字节码校验、权限控制（如文件 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+ 特性，编译器自动完成基本类型与包装类的转换（如 int i = new Integer(10)→拆箱，Integer j = 10→装箱）；
缓存陷阱：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），final 修饰数组引用不可变，且数组无暴露修改接口；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)，可通过 last 指针优化）
内存占用	连续内存，占用少（无额外指针开销）	非连续内存，每个节点有额外指针开销
线程安全	不安全	不安全

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()，需在 finally 中执行）
锁类型	可重入锁、非公平锁（默认），JDK6+ 支持偏向锁/轻量级锁/重量级锁升级	可重入锁，支持公平锁/非公平锁（构造函数指定）
功能扩展	无（仅支持基础同步）	支持中断锁（lockInterruptibly()）、超时锁（tryLock(ms)）、条件变量（Condition）、读写锁（ReentrantReadWriteLock）
性能	JDK6+ 优化后，性能接近 Lock	高并发场景下性能更优，灵活度高

public class Singleton {
    // volatile 禁止指令重排，防止 instance 未初始化完成就被其他线程获取
    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,              // keepAliveTime 的时间单位
    BlockingQueue<Runnable> workQueue, // 任务阻塞队列（核心线程满时，任务入队）
    ThreadFactory threadFactory,      // 线程创建工厂（自定义线程名称、优先级等）
    RejectedExecutionHandler handler  // 拒绝策略（队列和最大线程数都满时，处理新任务）
)

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
}

@Service
public class UserService {
    private UserDao userDao;
    
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

@Service
public class UserService {
    private final UserDao userDao;
    
    // 构造方法注入（@Autowired 可省略，Spring 4.3+ 支持）
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

// 切面类
@Aspect
@Component
public class LogAspect {
    // 切入点：所有 com.example.service 包下的 public 方法
    @Pointcut("execution(public * com.example.service..*(..))")
    public void servicePointcut() {}
    
    // 环绕通知
    @Around("servicePointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 目标方法执行前：打印请求参数
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("方法" + methodName + "调用，参数：" + Arrays.toString(args));
        
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed(); // 执行目标方法
        
        // 目标方法执行后：打印返回值和执行时间
        long cost = System.currentTimeMillis() - start;
        System.out.println("方法" + methodName + "返回值：" + result + "，执行时间：" + cost + "ms");
        
        return result;
    }
}

public void queryUser() {
    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    try {
        // 1. 加载驱动（MySQL 8.0+ 驱动类：com.mysql.cj.jdbc.Driver）
        Class.forName("com.mysql.cj.jdbc.Driver");
        
        // 2. 建立连接
        String url = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
        conn = DriverManager.getConnection(url, "root", "123456");
        
        // 3. 创建 PreparedStatement（预编译 SQL，防止 SQL 注入）
        String sql = "SELECT id, name FROM user WHERE id = ?";
        pstmt = conn.prepareStatement(sql);
        pstmt.setInt(1, 1); // 设置参数
        
        // 4. 执行查询
        rs = pstmt.executeQuery();
        
        // 5. 处理结果集
        while (rs.next()) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            System.out.println("id: " + id + ", name: " + name);
        }
    } catch (ClassNotFoundException | SQLException e) {
        e.printStackTrace();
    } finally {
        // 6. 关闭资源（逆序关闭）
        try {
            if (rs != null) rs.close();
            if (pstmt != null) pstmt.close();
            if (conn != null) conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

<configuration>
    <!-- 环境配置（数据源、事务管理器） -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 事务管理类型：JDBC/MANAGED -->
            <dataSource type="POOLED">
                <!-- 数据源类型：POOLED（连接池）/UNPOOLED/JNDI -->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 注册 Mapper.xml -->
    <mappers>
        <mapper resource="com/example/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 结果集映射（数据库字段→Java 对象属性） -->
    <resultMap id="UserResultMap" type="com.example.entity.User">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
    </resultMap>
    <!-- 查询用户 -->
    <select id="selectUserById" parameterType="int" resultMap="UserResultMap">
        SELECT id, name, age FROM user WHERE id = #{id}
    </select>
    <!-- 新增用户 -->
    <insert id="insertUser" parameterType="com.example.entity.User">
        INSERT INTO user (name, age) VALUES (#{name}, #{age})
    </insert>
</mapper>

public class Singleton {
    // 类加载时初始化实例（饿汉式）
    private static final Singleton instance = new Singleton();
    
    // 私有构造方法，禁止外部实例化
    private Singleton() {}
    
    // 提供全局访问方法
    public static Singleton getInstance() {
        return instance;
    }
}

public class Singleton {
    // volatile 禁止指令重排
    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 class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    // 线程不安全：多线程同时进入 if 条件，创建多个实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Singleton {
    private Singleton() {}
    
    // 静态内部类，类加载时不初始化
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
    
    // 调用 getInstance() 时，才加载 SingletonHolder，初始化实例
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

public enum Singleton {
    INSTANCE;
    
    // 枚举类的方法
    public void doSomething() {
        System.out.println("Singleton enum");
    }
}