侦探大挑战
128.12M · 2026-04-22
答案：
答案：
| 维度 | 基本数据类型（如int、float） | 包装类（如Integer、Float） |
|---|---|---|
| 本质 | 原始值，无对象属性 | 引用类型，继承Object类 |
| 默认值 | 有（如int默认0，boolean默认false） | 无，默认null |
| 适用场景 | 简单运算、局部变量，效率高 | 集合框架（如List）、泛型、需要null值的场景 |
| 缓存机制 | 无 | 部分包装类（Integer[-128~127]、Byte、Short等）有常量池缓存 |
关键考点：
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()比较值。答案：
核心差异在于可变性和线程安全：
底层原理：
String的不可变性源于private final char value[]（JDK8），final修饰数组引用不可变，且数组无暴露修改接口；StringBuffer和StringBuilder继承AbstractStringBuilder，底层是可变char数组，扩容机制为：默认初始容量16，当长度超过容量时，新容量=原容量×2+2，不足则直接扩容到所需长度。
答案：
易错点：
final int[] arr = {1,2,3}; arr[0] = 4; 合法（数组内容可变）；arr = new int[5]; 非法（引用地址不可变）。
答案：
| 维度 | 接口（Interface） | 抽象类（Abstract Class） |
|---|---|---|
| 继承方式 | 多实现（一个类可实现多个接口） | 单继承（一个类只能继承一个抽象类） |
| 成员变量 | 只能是public static final常量 | 可包含普通变量、静态变量、常量 |
| 成员方法 | JDK8前：只能是抽象方法；JDK8+：支持default/static方法；JDK9+：支持private方法 | 可包含抽象方法、普通方法、静态方法 |
| 构造方法 | 无 | 有（不能实例化，供子类调用） |
| 设计目的 | 定义行为规范，解耦（如List接口） | 定义类的模板，复用代码（如HttpServlet） |
应用场景：
Runnable接口）；AbstractList封装List的公共方法）。需要全套面试笔记及答案【扫一扫】 即可免费获取**
答案：
顶层父类：Throwable，包含两个核心子类：
Error：严重错误（如OutOfMemoryError、StackOverflowError），程序无法恢复，无需捕获；
Exception：可处理的异常，分为：
RuntimeException，无需强制捕获。异常处理关键字：
try：包裹可能抛出异常的代码；catch：捕获并处理异常（可多个catch，按异常子类→父类顺序）；finally：无论是否抛出异常，都会执行（常用于关闭资源，如流、数据库连接）；throw：手动抛出异常（如throw new IllegalArgumentException("参数非法")）；throws：声明方法可能抛出的异常，告知调用者。最佳实践：
Throwable（包含Error，无法处理）；AutoCloseable接口的类）。答案：
Java集合框架核心分为两大体系（均位于java.util包）：
单列集合（Collection）：存储单个元素，核心子接口：
List：有序、可重复（如ArrayList、LinkedList、Vector）；Set：无序、不可重复（如HashSet、TreeSet、LinkedHashSet）；双列集合（Map）：存储键值对（key-value），核心实现类：HashMap、TreeMap、LinkedHashMap、ConcurrentHashMap。
关键特性：
List：支持索引访问，可通过get(int index)获取元素；Set：基于equals()和hashCode()保证元素唯一性；Map：key不可重复（重复会覆盖value），value可重复；JDK8+中Map提供forEach()、computeIfAbsent()等便捷方法。答案：
| 维度 | ArrayList（数组实现） | LinkedList（双向链表实现） |
|---|---|---|
| 底层结构 | 动态数组（Object[]） | 双向链表（每个节点存储prev、next、value） |
| 访问效率 | 随机访问快（O(1)），通过索引直接定位 | 随机访问慢（O(n)），需遍历链表 |
| 增删效率 | 尾部增删快（O(1)），中间增删慢（需移动数组元素，O(n)） | 中间增删快（O(1)，只需修改节点指针），尾部增删需遍历到末尾（O(n)，可通过last指针优化） |
| 内存占用 | 连续内存，占用少（无额外指针开销） | 非连续内存，每个节点有额外指针开销 |
| 线程安全 | 不安全 | 不安全 |
应用场景：
答案：
HashMap是基于“哈希表”的Map实现，核心是“数组+链表/红黑树”的结构，目的是平衡查询和增删效率。
底层：数组（Entry[]）+ 单向链表；
存储流程：
hashCode() ^ (hashCode() >>> 16)）得到哈希值；底层：数组（Node[]）+ 单向链表 + 红黑树（链表长度≥8且数组长度≥64时，链表转为红黑树；链表长度≤6时，红黑树转回链表）；
存储流程：哈希扰动逻辑不变，哈希冲突时采用“尾插法”插入链表（避免JDK1.7头插法导致的链表循环问题）；
其他优化：
哈希冲突解决：
线程安全问题：
HashMap线程不安全，多线程环境下可能出现：
ConcurrentHashMap或Collections.synchronizedMap(new HashMap<>())。答案：
ConcurrentHashMap是HashMap的线程安全版本，核心差异在于锁机制：
底层：Node数组 + 链表 + 红黑树（与HashMap结构一致）；
锁机制：放弃分段锁，采用“CAS + synchronized”实现线程安全：
其他优化：支持computeIfAbsent()、forEach()等原子操作，性能优于JDK1.7。
答案：
HashSet底层依赖HashMap实现，核心逻辑：
add(E e) → 调用HashMap的put(e, PRESENT)，其中PRESENT是一个静态空Object（仅占位，不存储实际值）；equals()和hashCode()判断）；关键考点：
自定义对象作为HashSet元素时，必须重写equals()和hashCode()，否则无法保证唯一性（默认使用Object类的方法，比较对象地址）。重写原则：
equals()返回true → hashCode()必须相等；hashCode()相等 → equals()不一定返回true（哈希冲突）。答案：
方式1：继承Thread类，重写run()方法（线程执行逻辑），调用start()方法启动线程（底层调用start0() native方法创建操作系统线程）；
class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread running");
}
}
// 启动
new MyThread().start();
AI写代码java
运行
12345678
方式2：实现Runnable接口，重写run()方法，将实例传入Thread类启动；
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable running");
}
}
// 启动
new Thread(new MyRunnable()).start();
AI写代码java
运行
12345678
方式3：实现Callable接口，重写call()方法（支持返回值和抛出异常），通过FutureTask包装后传入Thread启动；
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(); // 获取返回值（阻塞直到线程完成）
AI写代码java
运行
12345678910
对比：
答案：
Java线程有6种状态（定义在Thread.State枚举中），状态转换如下：
NEW：线程创建后未启动（未调用start()）；RUNNABLE：线程启动后，处于可运行状态（包含操作系统的“运行中”和“就绪”）；BLOCKED：线程等待同步锁（如synchronized未获取锁时）；WAITING：线程无限期等待（如调用Object.wait()、Thread.join()、LockSupport.park()，需其他线程唤醒）；TIMED_WAITING：线程限时等待（如调用Thread.sleep(ms)、Object.wait(ms)、Thread.join(ms)，超时自动唤醒）；TERMINATED：线程执行完成或异常终止。核心转换路径：
NEW → RUNNABLE（start()） → TERMINATED（执行完成）；
RUNNABLE → BLOCKED（竞争锁失败） → RUNNABLE（获取锁）；
RUNNABLE → WAITING/TIMED_WAITING（调用等待方法） → RUNNABLE（被唤醒/超时）。
需要全套面试笔记及答案【扫一扫】 即可免费获取**
答案：
| 维度 | synchronized（内置锁） | Lock（显式锁，如ReentrantLock） |
|---|---|---|
| 锁实现 | JVM层面实现（C++代码） | JDK层面实现（Java代码） |
| 锁获取与释放 | 自动获取（进入同步块）、自动释放（退出同步块/异常） | 手动获取（lock()）、手动释放（unlock()，需在finally中执行） |
| 锁类型 | 可重入锁、非公平锁（默认），JDK6+支持偏向锁/轻量级锁/重量级锁升级 | 可重入锁，支持公平锁/非公平锁（构造函数指定） |
| 功能扩展 | 无（仅支持基础同步） | 支持中断锁（lockInterruptibly()）、超时锁（tryLock(ms)）、条件变量（Condition）、读写锁（ReentrantReadWriteLock） |
| 性能 | JDK6+优化后，性能接近Lock | 高并发场景下性能更优，灵活度高 |
应用场景：
答案：
volatile是Java提供的轻量级同步机制，核心作用有两个：
局限性：
volatile int i = 0; i++; 非原子操作（包含读取、加1、写入三步），多线程下可能出现计数错误，需配合synchronized或AtomicInteger使用；volatile boolean flag = false; 控制线程启停）。经典应用：双重校验锁（DCL）单例模式：
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;
}
}
AI写代码java
运行
1234567891011121314151617
答案：
Java线程池核心类是ThreadPoolExecutor，基于“池化思想”减少线程创建/销毁开销，提高并发效率。
public ThreadPoolExecutor(
int corePoolSize, // 核心线程数（常驻线程，即使空闲也不销毁）
int maximumPoolSize, // 最大线程数（核心线程+临时线程的总上限）
long keepAliveTime, // 临时线程空闲时间（超过则销毁）
TimeUnit unit, // keepAliveTime的时间单位
BlockingQueue<Runnable> workQueue, // 任务阻塞队列（核心线程满时，任务入队）
ThreadFactory threadFactory, // 线程创建工厂（自定义线程名称、优先级等）
RejectedExecutionHandler handler // 拒绝策略（队列和最大线程数都满时，处理新任务）
)
AI写代码java
运行
123456789
AbortPolicy（默认）：直接抛出RejectedExecutionException；CallerRunsPolicy：由提交任务的线程（调用者）执行任务；DiscardPolicy：直接丢弃新任务，无异常；DiscardOldestPolicy：丢弃队列中最旧的任务，加入新任务。Executors.newFixedThreadPool(n)：固定核心线程数和最大线程数（n），队列无界（LinkedBlockingQueue）；Executors.newCachedThreadPool()：核心线程数0，最大线程数Integer.MAX_VALUE，临时线程空闲60秒销毁，队列同步移交（SynchronousQueue）；Executors.newSingleThreadExecutor()：核心线程数1，最大线程数1，队列无界，保证任务串行执行；Executors.newScheduledThreadPool(n)：核心线程数n，支持定时/延迟执行任务（ScheduledFutureTask）。注意：阿里巴巴Java开发手册禁止使用Executors创建线程池，原因是：
newFixedThreadPool/newSingleThreadExecutor：队列无界，可能导致OOM；newCachedThreadPool：最大线程数无界，可能创建大量线程导致CPU/内存耗尽。ThreadPoolExecutor构造方法，指定合理参数（如核心线程数=CPU核心数±1，队列使用有界队列）。答案：
ThreadLocal是线程本地存储工具，允许每个线程拥有独立的变量副本，避免多线程共享变量的并发问题。
底层结构：每个Thread对象持有一个ThreadLocalMap（ThreadLocal的内部类），ThreadLocalMap的key是ThreadLocal实例（弱引用），value是线程本地变量副本；
核心方法：
set(T value)：获取当前线程的ThreadLocalMap，将（当前ThreadLocal实例，value）存入；get()：获取当前线程的ThreadLocalMap，根据当前ThreadLocal实例获取value，无则调用initialValue()初始化；remove()：删除当前线程的ThreadLocalMap中对应的键值对。原因：ThreadLocalMap的key是弱引用（WeakReference<ThreadLocal<?>>），当ThreadLocal实例被回收（如外部引用置null），key会变成null，而value是强引用，若线程未结束（如线程池核心线程），value无法被GC回收，导致内存泄漏；
解决方案：
remove()方法删除value；应用场景：
RequestContextHolder底层使用ThreadLocal存储HttpServletRequest）。答案：
JVM运行时数据区分为5个部分（基于JDK8）：
StackOverflowError（如递归调用无终止）；栈扩展时内存不足→OutOfMemoryError。StackOverflowError和OutOfMemoryError。作用：存储对象实例和数组，是JVM内存最大的区域，也是GC的主要区域；
特点：线程共享，可通过-Xms（初始堆大小）、-Xmx（最大堆大小）配置；
分区（逻辑划分）：
-XX:MetaspaceSize、-XX:MaxMetaspaceSize配置）。异常：堆内存不足→OutOfMemoryError: Java heap space；元空间不足→OutOfMemoryError: Metaspace。
答案：
GC是JVM自动回收堆中无用对象（无引用的对象）的过程，核心目标是释放内存，避免内存泄漏。
引用计数法：给对象添加引用计数器，引用+1，引用失效-1，计数器为0则判定为垃圾；缺点：无法解决循环引用（如A引用B，B引用A，计数器均为1，无法回收）；
可达性分析算法（JVM采用）：以“GC Roots”为起点，遍历对象引用链，不可达的对象判定为垃圾；
标记-清除算法（Mark-Sweep）：
复制算法（Copying）：
标记-整理算法（Mark-Compact）：
分代收集算法（JVM采用）：
答案：
类加载是将.class字节码文件加载到JVM内存，生成Class对象的过程，核心分为5个阶段：
<clinit>()方法（静态变量赋值+静态代码块执行），初始化顺序：父类→子类，静态变量→静态代码块。rt.jar），无父加载器；jre/lib/ext目录下的类库；ClassLoader类，重写findClass()方法，用于加载自定义路径的类（如热部署、加密类）。核心规则：类加载器加载类时，先委托父加载器加载，父加载器无法加载（找不到类）时，才由自身加载；
流程：应用程序类加载器→扩展类加载器→启动类加载器（顶层），若启动类加载器无法加载，反向逐级尝试加载；
作用：
java.lang.String仅由启动类加载器加载一次）；java.lang.String类替换核心类）。破坏双亲委派模型的场景：
答案：
IoC（Inversion of Control，控制反转）是Spring的核心思想，指将对象的创建、依赖注入（DI）的控制权从应用程序转移到Spring容器，实现解耦。
ApplicationContext、BeanFactory），负责管理Bean的生命周期（创建、初始化、销毁）和依赖关系；new对象）。构造方法注入：通过Bean的构造方法传入依赖，推荐使用（强制依赖，避免空指针）；
@Service
public class UserService {
private final UserDao userDao;
// 构造方法注入（@Autowired可省略，Spring 4.3+支持）
public UserService(UserDao userDao) {
this.userDao = userDao;
}
}
AI写代码java
运行
12345678
Setter方法注入：通过Setter方法注入依赖，适用于可选依赖；
@Service
public class UserService {
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
AI写代码java
运行
12345678
字段注入：直接在字段上添加@Autowired注解，代码简洁，但不推荐（无法通过构造方法校验依赖，不利于单元测试）；
@Service
public class UserService {
@Autowired
private UserDao userDao;
}
AI写代码java
运行
12345
@Configuration）；@Component、@Service、@Repository），注册到BeanDefinitionRegistry；@PostConstruct注解方法、InitializingBean接口的afterPropertiesSet()方法、自定义init-method；@PreDestroy注解方法、DisposableBean接口的destroy()方法、自定义destroy-method。答案：
AOP（Aspect-Oriented Programming，面向切面编程）是Spring的核心特性，通过“横切”机制，将日志、事务、权限等通用功能（切面）与业务逻辑解耦，实现代码复用。
切面（Aspect）：封装通用功能的类（如日志切面、事务切面），包含通知和切入点；
通知（Advice）：切面的具体逻辑（如日志打印、事务提交），分为5种类型：
@Before：目标方法执行前执行；@After：目标方法执行后执行（无论是否异常）；@AfterReturning：目标方法正常返回后执行；@AfterThrowing：目标方法抛出异常后执行；@Around：环绕目标方法执行（可控制目标方法的执行与否，如事务的开始和提交）；切入点（Pointcut）：定义切面作用的目标方法（如“所有Service层的方法”），通过表达式（如execution表达式）指定；
连接点（JoinPoint）：目标方法的执行点（如方法调用、异常抛出），是切入点的具体实例；
织入（Weaving）：将切面逻辑融入目标方法的过程，Spring AOP默认采用动态代理织入。
Spring AOP基于动态代理实现，分为两种代理方式：
java.lang.reflect.Proxy类动态生成代理类，代理类实现目标接口，并重写目标方法，在方法中织入切面逻辑；// 切面类
@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;
}
}
AI写代码java
运行
1234567891011121314151617181920212223242526
答案：
Spring事务管理核心是“声明式事务”（基于AOP）和“编程式事务”（手动编码），其中声明式事务是主流用法。
DEFAULT：默认隔离级别（依赖数据库，如MySQL默认REPEATABLE READ）；READ_UNCOMMITTED：读未提交，最低隔离级别，可能出现脏读、不可重复读、幻读；READ_COMMITTED：读已提交，避免脏读，可能出现不可重复读、幻读（如Oracle默认）；REPEATABLE_READ：可重复读，避免脏读、不可重复读，可能出现幻读（如MySQL默认）；SERIALIZABLE：串行化，最高隔离级别，避免所有并发问题，性能最低。Spring定义了7种传播行为，常用的有：
REQUIRED（默认）：如果当前存在事务，加入事务；如果没有事务，创建新事务；REQUIRES_NEW：无论当前是否存在事务，都创建新事务（新事务与原事务相互独立，原事务暂停）；SUPPORTS：如果当前存在事务，加入事务；如果没有事务，以非事务方式执行；NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，暂停原事务；NEVER：以非事务方式执行，如果当前存在事务，抛出异常。配置方式：通过@EnableTransactionManagement注解启用事务管理（Spring Boot自动启用）；
核心注解：@Transactional（标注在类或方法上，类级别的注解对所有方法生效）；
原理：
@Transactional注解被解析为切面，切入点是标注该注解的方法；PlatformTransactionManager接口适配不同数据库（如DataSourceTransactionManager适配JDBC，HibernateTransactionManager适配Hibernate）。@Transactional仅对public方法生效）；@Transactional失效，因为未经过代理类）；RuntimeException和Error， checked异常需通过rollbackFor指定）；try-catch异常但未throw，事务无法感知异常，不会回滚）；NOT_SUPPORTED、NEVER）；PlatformTransactionManager未被Spring管理）。答案：
JDBC（Java Database Connectivity）是Java访问数据库的标准API，核心步骤如下：
DriverManager.getConnection(url, username, password)）；executeQuery()查询，executeUpdate()增删改）；示例代码：
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();
}
}
}
AI写代码java
运行
1234567891011121314151617181920212223242526272829303132333435
关键考点：
SELECT * FROM user WHERE name = '" + name + "'"，若name传入' OR '1'='1，则SQL变为SELECT * FROM user WHERE name = '' OR '1'='1'，查询所有用户；PreparedStatement通过参数绑定避免该问题。
