以下是百度校招Java开发岗和Java架构师的部分面试题及答案：
Java开发岗
- Hashmap如何变线程安全，每种方式的优缺点？
- 使用Collections.synchronizedMap()：优点是实现简单，直接调用工具方法即可。缺点是效率相对较低，因为其内部是通过 synchronized 关键字实现同步，整个Map的操作都被锁控制，并发度不高。
- 使用ConcurrentHashMap：优点是性能高，采用分段锁机制，允许多个线程同时访问不同的分段，并发性能好。缺点是相比HashMap实现更复杂，占用内存可能稍多。
- 服务器如何负载均衡，有哪些算法，哪个比较好？一致性哈希原理是什么，怎么避免DDOS攻击请求打到少数机器？
- 负载均衡算法：常见的有轮询算法、加权轮询算法、随机算法、最少连接数算法等。轮询算法简单公平，但未考虑服务器性能差异；加权轮询可根据服务器性能分配请求，更合理；随机算法具有随机性；最少连接数算法将请求分配给连接数最少的服务器，能更好地利用服务器资源。
- 一致性哈希原理：将服务器节点映射到一个0 - 2^32的哈希环上，请求根据其键值哈希后也映射到环上，然后按顺时针方向找到离它最近的服务器节点处理请求。
- 避免DDOS攻击：可通过部署防火墙、设置访问频率限制、使用CDN（内容分发网络）等方式，CDN可将请求分散到多个节点，防火墙和访问频率限制能过滤掉异常高频请求，减少目标服务器压力。
- Redis的持久化怎么做，aof和rdb有什么区别，各自优缺点是什么？
- RDB：优点是生成的快照文件紧凑，占用空间小，恢复数据速度快。缺点是可能会丢失最后一次快照之后到故障发生期间的数据，且生成快照时可能会阻塞主线程。
- AOF：优点是数据安全性高，能记录每一个写操作，最多只丢失一个命令的数据。缺点是文件体积较大，恢复数据时需要重放所有写命令，速度相对较慢，且可能存在日志文件过大需要定期重写的情况。
Java架构师
- JMM（主内存、工作内存、happens - before）是什么？
- JMM即Java内存模型，定义了线程和主内存之间的交互规则。主内存是所有线程共享的内存区域，存储了对象实例等数据。工作内存是每个线程私有的，线程对变量的操作先在工作内存中进行，然后再同步到主内存。happens - before是JMM中的一个重要概念，用于定义操作之间的先后顺序，保证内存可见性和有序性，若A happens - before B，则A操作的结果对B可见，且A的操作顺序排在B之前。
- 有哪些无锁数据结构？无锁实现的原理是什么？
- 无锁数据结构：常见的有ConcurrentHashMap（部分操作无锁）、乐观锁实现的容器等。
- 原理：主要基于CAS（Compare - And - Swap）操作，它是一种原子操作，通过比较内存中的值和预期值，如果相等则进行更新，无需加锁就能实现多线程对数据的并发访问，提高了并发性能。
- MySQL怎么优化table scan？
- 添加合适索引：分析查询语句，对经常用于条件过滤、连接条件的列添加索引，但要避免过多索引导致更新性能下降。
- 优化查询语句：尽量明确查询条件，避免使用SELECT *，只查询需要的列，减少数据扫描量。
- 分区表：如果表数据量很大，可根据某些规则（如时间、地域等）将表分区，查询时只扫描相关分区，减少扫描范围。
- 优化表结构：合理设计字段类型，避免使用过大的字段类型，减少数据存储量，从而降低扫描成本。
其他面试题答案如下：
- 红黑树的插入时间复杂度：红黑树是一种自平衡的二叉查找树，插入一个新节点后，可能会破坏红黑树的性质，需通过旋转和重新着色来恢复平衡，插入的时间复杂度为O(logn)。
- 解决哈希冲突的方式：常见的有链地址法（HashMap采用）、开放定址法（包括线性探测、二次探测等）、再哈希法、建立公共溢出区等。
- G1什么时候引发Full GC：堆内存不足、晋升失败（新生代对象晋升到老年代时，老年代空间不足）、元空间不足等情况可能会引发G1的Full GC。
- TCP握手挥手过程及其状态转换：三次握手过程为客户端发送SYN包进入SYN_SENT状态，服务器接收后回复SYN + ACK包进入SYN_RCVD状态，客户端再发送ACK包进入ESTABLISHED状态，服务器也进入ESTABLISHED状态。四次挥手过程为客户端发送FIN包进入FIN_WAIT_1状态，服务器接收后回复ACK包进入CLOSE_WAIT状态，客户端收到ACK后进入FIN_WAIT_2状态，服务器发送FIN包进入LAST_ACK状态，客户端接收FIN后回复ACK并进入TIME_WAIT状态，服务器收到ACK后进入CLOSED状态，客户端等待2MSL后也进入CLOSED状态。
百度校招Java开发岗历年经典面试题汇总（实操篇）
一、Java基础
1.1 JDK和JRE的区别
实操场景：验证JDK和JRE的安装与区别
# 检查JDK版本
java -version
javac -version
# 查看JDK安装路径
which java
which javac
# 验证JRE是否包含编译器
# 尝试在仅安装JRE的环境中执行javac命令，会提示"command not found"
1.2 ==和equals的区别
代码示例：
public class EqualsDemo {
public static void main(String[] args) {
// 基本类型比较
int a = 10;
int b = 10;
System.out.println("基本类型比较: " + (a == b)); // true
// 引用类型比较
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println("引用地址比较: " + (str1 == str2)); // false
System.out.println("值比较: " + str1.equals(str2)); // true
// 字符串常量池比较
String str3 = "world";
String str4 = "world";
System.out.println("常量池引用比较: " + (str3 == str4)); // true
}
}
1.3 final的作用
代码示例：
// 1. final类不能被继承
final class FinalClass {
public void print() {
System.out.println("Final Class");
}
}
// 2. final方法不能被重写
class Parent {
public final void finalMethod() {
System.out.println("Final Method");
}
}
class Child extends Parent {
// 以下代码会编译错误，无法重写final方法
// public void finalMethod() {}
}
// 3. final变量必须初始化且不可修改
class FinalVariableDemo {
final int MAX_COUNT = 100;
final String NAME;
public FinalVariableDemo(String name) {
this.NAME = name; // 必须在构造函数中初始化
}
public void test() {
// MAX_COUNT = 200; // 编译错误，无法修改final变量
}
}
1.4 String相关问题
实操场景：性能对比测试（String vs StringBuilder）
public class StringPerformanceTest {
public static void main(String[] args) {
int loopCount = 10000;
// 使用String拼接
long startTime = System.currentTimeMillis();
String str = "";
for (int i = 0; i < loopCount; i++) {
str += i;
}
long endTime = System.currentTimeMillis();
System.out.println("String拼接耗时: " + (endTime - startTime) + "ms");
// 使用StringBuilder拼接
startTime = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < loopCount; i++) {
sb.append(i);
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder拼接耗时: " + (endTime - startTime) + "ms");
}
}
1.5 抽象类与接口
代码示例：实现多继承特性
// 接口定义
interface Flyable {
void fly();
}
interface Swimmable {
void swim();
}
// 抽象类定义
abstract class Animal {
abstract void eat();
}
// 实现类
class Duck extends Animal implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("鸭子会飞");
}
@Override
public void swim() {
System.out.println("鸭子会游泳");
}
@Override
void eat() {
System.out.println("鸭子吃水草");
}
}
1.6 Java中IO流
实操场景：文件复制工具实现
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
public class FileCopyDemo {
public static void main(String[] args) {
String sourceFile = "source.txt";
String targetFile = "target.txt";
// 1. 使用传统字节流
try (InputStream is = new FileInputStream(sourceFile);
OutputStream os = new FileOutputStream(targetFile)) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
}
System.out.println("传统字节流复制完成");
} catch (IOException e) {
e.printStackTrace();
}
// 2. 使用NIO.2 Files工具类
try {
Path sourcePath = Paths.get(sourceFile);
Path targetPath = Paths.get(targetFile);
Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
System.out.println("NIO.2复制完成");
} catch (IOException e) {
e.printStackTrace();
}
}
}
1.7 Files的常用方法
代码示例：文件操作工具类
import java.io.IOException;
import java.nio.file.*;
import java.util.List;
public class FileUtils {
// 检查文件是否存在
public static boolean checkFileExists(String filePath) {
Path path = Paths.get(filePath);
return Files.exists(path);
}
// 创建新文件
public static void createFile(String filePath) throws IOException {
Path path = Paths.get(filePath);
Files.createFile(path);
}
// 创建目录
public static void createDirectory(String dirPath) throws IOException {
Path path = Paths.get(dirPath);
Files.createDirectories(path);
}
// 删除文件或目录
public static void delete(String path) throws IOException {
Files.deleteIfExists(Paths.get(path));
}
// 复制文件
public static void copy(String source, String target) throws IOException {
Path sourcePath = Paths.get(source);
Path targetPath = Paths.get(target);
Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
}
// 移动文件
public static void move(String source, String target) throws IOException {
Path sourcePath = Paths.get(source);
Path targetPath = Paths.get(target);
Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
}
// 读取文件内容
public static List<String> readAllLines(String filePath) throws IOException {
Path path = Paths.get(filePath);
return Files.readAllLines(path);
}
// 写入文件内容
public static void writeLines(String filePath, List<String> lines) throws IOException {
Path path = Paths.get(filePath);
Files.write(path, lines);
}
}
二、容器
2.1 Java容器有哪些
实操场景：容器性能对比测试
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class ContainerPerformanceTest {
public static void main(String[] args) {
int loopCount = 100000;
// 测试ArrayList
testList(new ArrayList<>(), loopCount);
// 测试LinkedList
testList(new LinkedList<>(), loopCount);
// 测试HashMap
testMap(new HashMap<>(), loopCount);
// 测试ConcurrentHashMap
testMap(new ConcurrentHashMap<>(), loopCount);
}
private static void testList(List<Integer> list, int count) {
long startTime = System.currentTimeMillis();
// 添加元素
for (int i = 0; i < count; i++) {
list.add(i);
}
// 随机访问元素
for (int i = 0; i < count; i++) {
list.get(i);
}
long endTime = System.currentTimeMillis();
System.out.println(list.getClass().getSimpleName() + "耗时: " + (endTime - startTime) + "ms");
}
private static void testMap(Map<Integer, Integer> map, int count) {
long startTime = System.currentTimeMillis();
// 添加元素
for (int i = 0; i < count; i++) {
map.put(i, i);
}
// 随机访问元素
for (int i = 0; i < count; i++) {
map.get(i);
}
long endTime = System.currentTimeMillis();
System.out.println(map.getClass().getSimpleName() + "耗时: " + (endTime - startTime) + "ms");
}
}
2.2 HashMap相关问题
实操场景：自定义HashMap实现
import java.util.LinkedList;
public class CustomHashMap<K, V> {
private static final int DEFAULT_CAPACITY = 16;
private LinkedList<Entry<K, V>>[] table;
public CustomHashMap() {
table = new LinkedList[DEFAULT_CAPACITY];
for (int i = 0; i < DEFAULT_CAPACITY; i++) {
table[i] = new LinkedList<>();
}
}
public void put(K key, V value) {
int index = getIndex(key);
LinkedList<Entry<K, V>> bucket = table[index];
// 检查是否已存在相同key
for (Entry<K, V> entry : bucket) {
if (entry.key.equals(key)) {
entry.value = value;
return;
}
}
// 添加新元素
bucket.add(new Entry<>(key, value));
}
public V get(K key) {
int index = getIndex(key);
LinkedList<Entry<K, V>> bucket = table[index];
for (Entry<K, V> entry : bucket) {
if (entry.key.equals(key)) {
return entry.value;
}
}
return null;
}
private int getIndex(K key) {
return Math.abs(key.hashCode()) % DEFAULT_CAPACITY;
}
static class Entry<K, V> {
K key;
V value;
public Entry(K key, V value) {
this.key = key;
this.value = value;
}
}
}
2.3 ConcurrentHashMap相关问题
实操场景：多线程环境下的并发操作
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class ConcurrentHashMapDemo {
private static final int THREAD_COUNT = 10;
private static final int LOOP_COUNT = 1000;
public static void main(String[] args) throws InterruptedException {
ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>();
ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
// 多线程并发写入
for (int i = 0; i < THREAD_COUNT; i++) {
final int threadId = i;
executor.submit(() -> {
for (int j = 0; j < LOOP_COUNT; j++) {
map.put(threadId * LOOP_COUNT + j, j);
}
});
}
executor.shutdown();
executor.awaitTermination(1, TimeUnit.MINUTES);
// 验证结果
System.out.println("Map size: " + map.size());
System.out.println("Expected size: " + (THREAD_COUNT * LOOP_COUNT));
}
}
2.4 LinkedList适合用什么排序
代码示例：实现归并排序对LinkedList排序
import java.util.LinkedList;
public class LinkedListMergeSort {
public static <T extends Comparable<T>> LinkedList<T> sort(LinkedList<T> list) {
if (list == null || list.size() <= 1) {
return list;
}
// 分割链表
LinkedList<T> left = new LinkedList<>();
LinkedList<T> right = new LinkedList<>();
int mid = list.size() / 2;
for (int i = 0; i < mid; i++) {
left.add(list.removeFirst());
}
right.addAll(list);
// 递归排序左右两部分
left = sort(left);
right = sort(right);
// 合并已排序的链表
return merge(left, right);
}
private static <T extends Comparable<T>> LinkedList<T> merge(LinkedList<T> left, LinkedList<T> right) {
LinkedList<T> result = new LinkedList<>();
while (!left.isEmpty() && !right.isEmpty()) {
if (left.peek().compareTo(right.peek()) <= 0) {
result.add(left.removeFirst());
} else {
result.add(right.removeFirst());
}
}
// 添加剩余元素
result.addAll(left);
result.addAll(right);
return result;
}
}
三、多线程
3.1 创建线程的方式
代码示例：三种创建线程的方式
// 1. 继承Thread类
class MyThread extends Thread {
@Override
public void run() {
System.out.println("继承Thread类创建的线程: " + Thread.currentThread().getName());
}
}
// 2. 实现Runnable接口
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("实现Runnable接口创建的线程: " + Thread.currentThread().getName());
}
}
// 3. 实现Callable接口
import java.util.concurrent.*;
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return "实现Callable接口创建的线程: " + Thread.currentThread().getName();
}
}
public class ThreadCreationDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 方式1: 继承Thread类
MyThread thread1 = new MyThread();
thread1.start();
// 方式2: 实现Runnable接口
Thread thread2 = new Thread(new MyRunnable());
thread2.start();
// 方式3: 实现Callable接口
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new MyCallable());
System.out.println(future.get());
executor.shutdown();
}
}
3.2 线程池相关问题
实操场景：自定义线程池配置
import java.util.concurrent.*;
public class ThreadPoolDemo {
public static void main(String[] args) {
// 创建自定义线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // 核心线程数
10, // 最大线程数
60, // 空闲线程存活时间
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100), // 任务队列
Executors.defaultThreadFactory(), // 线程工厂
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);
// 提交任务
for (int i = 0; i < 20; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " completed");
});
}
// 关闭线程池
executor.shutdown();
}
}
3.3 线程安全问题
代码示例：使用synchronized和Lock实现线程安全
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
// 1. 使用synchronized关键字
class SynchronizedCounter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
// 2. 使用Lock接口
class LockCounter {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}
// 3. 使用原子类
import java.util.concurrent.atomic.AtomicInteger;
class AtomicCounter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
}
3.4 AQS相关问题
代码示例：自定义锁实现
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
class CustomLock {
private static class Sync extends AbstractQueuedSynchronizer {
@Override
protected boolean tryAcquire(int arg) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
@Override
protected boolean tryRelease(int arg) {
if (getState() == 0) {
throw new IllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
@Override
protected boolean isHeldExclusively() {
return getState() == 1;
}
}
private final Sync sync = new Sync();
public void lock() {
sync.acquire(1);
}
public void unlock() {
sync.release(1);
}
public boolean tryLock() {
return sync.tryAcquire(1);
}
}
四、JVM
4.1 JVM内存区域划分
实操场景：内存溢出测试
import java.util.ArrayList;
import java.util.List;
public class OutOfMemoryDemo {
public static void main(String[] args) {
// 堆内存溢出
heapOutOfMemory();
// 栈内存溢出
// stackOverflow();
}
private static void heapOutOfMemory() {
List<byte[]> list = new ArrayList<>();
while (true) {
list.add(new byte[1024 * 1024]); // 每次添加1MB数据
}
}
private static void stackOverflow() {
stackOverflow(); // 递归调用导致栈溢出
}
}
4.2 垃圾回收机制
实操场景：GC日志分析
# 运行程序时开启GC日志
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xms256m -Xmx256m OutOfMemoryDemo
# 典型GC日志分析
2025-06-26T10:30:45.123+0800: 0.234: [GC (Allocation Failure) [PSYoungGen: 65536K->256K(76288K)] 65536K->65536K(251392K), 0.0012345 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
# 日志解读:
# 1. GC发生时间: 2025-06-26T10:30:45.123+0800
# 2. GC类型: 新生代GC (Allocation Failure表示内存分配失败触发GC)
# 3. 新生代内存变化: 65536K->256K(76288K)
# 4. 堆内存变化: 65536K->65536K(251392K)
# 5. GC耗时: 0.0012345秒
4.3 类加载机制
代码示例：自定义类加载器
import java.io.*;
public class CustomClassLoader extends ClassLoader {
private String classPath;
public CustomClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] classData = loadClassData(name);
if (classData == null) {
throw new ClassNotFoundException();
}
return defineClass(name, classData, 0, classData.length);
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
}
private byte[] loadClassData(String name) throws IOException {
String path = classPath + File.separatorChar +
name.replace('.', File.separatorChar) + ".class";
try (InputStream is = new FileInputStream(path);
ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
bos.write(buffer, 0, bytesRead);
}
return bos.toByteArray();
}
}
public static void main(String[] args) throws Exception {
CustomClassLoader loader = new CustomClassLoader("/path/to/classes");
Class<?> clazz = loader.loadClass("com.example.MyClass");
Object obj = clazz.getDeclaredConstructor().newInstance();
System.out.println(obj.getClass().getClassLoader());
}
}
4.4 JVM性能调优
实操场景：JVM参数配置
# 典型的JVM性能调优参数配置示例
java -Xms512m -Xmx512m -Xmn256m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=256m \
-XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/var/log/java_heapdump.hprof \
-jar myapplication.jar
# 参数说明:
# -Xms512m: 初始堆大小512MB
# -Xmx512m: 最大堆大小512MB
# -Xmn256m: 新生代大小256MB
# -XX:MetaspaceSize=128m: 元空间初始大小128MB
# -XX:MaxMetaspaceSize=256m: 元空间最大大小256MB
# -XX:+UseG1GC: 使用G1垃圾收集器
# -XX:MaxGCPauseMillis=200: 最大GC停顿时间200毫秒
# -XX:+HeapDumpOnOutOfMemoryError: 发生OOM时生成堆转储文件
# -XX:HeapDumpPath=/var/log/java_heapdump.hprof: 堆转储文件路径
五、数据库
5.1 MySQL索引优化
实操场景：索引优化测试
-- 创建测试表
CREATE TABLE user (
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(50),
age INT,
gender VARCHAR(10),
email VARCHAR(100),
create_time DATETIME
);
-- 添加测试数据
INSERT INTO user (name, age, gender, email, create_time)
VALUES ('张三', 25, '男', 'zhangsan@example.com', NOW()),
('李四', 30, '男', 'lisi@example.com', NOW()),
('王五', 28, '女', 'wangwu@example.com', NOW());
-- 创建复合索引
CREATE INDEX idx_name_age_gender ON user (name, age, gender);
-- 执行计划分析
EXPLAIN SELECT * FROM user WHERE name = '张三' AND age = 25 AND gender = '男';
-- 索引覆盖测试
EXPLAIN SELECT name, age, gender FROM user WHERE name = '张三';
5.2 数据库事务隔离级别
实操场景：演示脏读、不可重复读和幻读
-- 设置事务隔离级别为读未提交（会出现脏读）
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-- 会话1: 开启事务
START TRANSACTION;
UPDATE user SET age = 31 WHERE name = '李四';
-- 会话2: 查询（会读到未提交的数据，出现脏读）
SELECT * FROM user WHERE name = '李四';
-- 会话1: 回滚事务
ROLLBACK;
-- 设置事务隔离级别为可重复读（MySQL默认级别，解决不可重复读，但可能出现幻读）
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
-- 会话1: 开启事务并查询
START TRANSACTION;
SELECT * FROM user WHERE age > 25;
-- 会话2: 插入新记录
INSERT INTO user (name, age, gender) VALUES ('赵六', 35, '男');
COMMIT;
-- 会话1: 再次查询（两次查询结果一致，解决不可重复读）
SELECT * FROM user WHERE age > 25;
-- 会话1: 插入相同条件的记录（会出现Duplicate key错误，说明出现幻读）
INSERT INTO user (name, age, gender) VALUES ('赵六', 35, '男');
5.3 MySQL主从复制
实操场景：配置MySQL主从复制
# 主库配置 (my.cnf)
[mysqld]
server-id=1
log-bin=mysql-bin
binlog-do-db=test_db
# 从库配置 (my.cnf)
[mysqld]
server-id=2
relay-log=mysql-relay-bin
log-bin=mysql-bin
# 主库操作
CREATE USER 'repl_user'@'%' IDENTIFIED BY 'password';
GRANT REPLICATION SLAVE ON *.* TO 'repl_user'@'%';
FLUSH PRIVILEGES;
SHOW MASTER STATUS;
# 从库操作
CHANGE MASTER TO
MASTER_HOST='主库IP',
MASTER_USER='repl_user',
MASTER_PASSWORD='password',
MASTER_LOG_FILE='mysql-bin.xxxxxx',
MASTER_LOG_POS=xxxxxx;
START SLAVE;
SHOW SLAVE STATUS\G
六、算法
6.1 排序算法
代码示例：实现快速排序
public class QuickSort {
public static void sort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
quickSort(arr, 0, arr.length - 1);
}
private static void quickSort(int[] arr, int left, int right) {
if (left < right) {
int pivotIndex = partition(arr, left, right);
quickSort(arr, left, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, right);
}
}
private static int partition(int[] arr, int left, int right) {
int pivot = arr[right];
int i = left - 1;
for (int j = left; j < right; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, right);
return i + 1;
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
6.2 查找算法
代码示例：实现二分查找
public class BinarySearch {
public static int search(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1; // 未找到
}
}
6.3 递归与动态规划
代码示例：斐波那契数列（动态规划优化）
public class Fibonacci {
// 递归实现（效率低）
public static int fibRecursive(int n) {
if (n <= 1) {
return n;
}
return fibRecursive(n - 1) + fibRecursive(n - 2);
}
// 动态规划实现（高效）
public static int fibDynamic(int n) {
if (n <= 1) {
return n;
}
int[] dp = new int[n + 1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
// 优化空间复杂度的动态规划
public static int fibOptimized(int n) {
if (n <= 1) {
return n;
}
int a = 0;
int b = 1;
int result = 0;
for (int i = 2; i <= n; i++) {
result = a + b;
a = b;
b = result;
}
return result;
}
}
6.4 链表操作
代码示例：反转链表
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x; }
}
public class ReverseLinkedList {
// 迭代方法
public static ListNode reverseList(ListNode head) {
ListNode prev = null;
ListNode curr = head;
while (curr != null) {
ListNode nextTemp = curr.next;
curr.next = prev;
prev = curr;
curr = nextTemp;
}
return prev;
}
// 递归方法
public static ListNode reverseListRecursive(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode newHead = reverseListRecursive(head.next);
head.next.next = head;
head.next = null;
return newHead;
}
}
以上代码示例和实操场景展示了Java开发中的核心技术点和面试高频考点。通过实际动手操作这些示例，你可以更深入地理解相关概念和技术，为面试做好充分准备。
Java 开发岗，Java 架构师，百度校招，面试题，历年经典，Java 基础，数据结构，算法，并发编程，JVM,Spring 框架，MySQL, 分布式，微服务，设计模式
代码获取方式
https://pan.quark.cn/s/14fcf913bae6
