官网:www.xservx.com|蜀ICP备2026035467号-3

java基本教程

一、java基本教程:从零构建系统化知识体系

1.1 为什么选择Java?——企业级开发的首选语言

Java自1995年Sun公司发布以来,已发展成为全球最主流的编程语言之一。根据TIOBE指数2024年12月数据,Java长期稳居前三,尤其在企业级应用、Android开发、大数据处理等领域占据绝对优势。其“一次编写,到处运行”的跨平台特性,得益于JVM(Java虚拟机)的字节码中间层设计,使开发者无需为不同操作系统重写代码。

Java生态的完整性体现在:
• JDK(Java Development Kit)提供编译、调试、运行一站式工具链
• JRE(Java Runtime Environment)保障运行时环境完整性
• 三大技术体系:Java SE(标准版)、Java EE(企业版)、Java ME(微型版)覆盖全场景
• 开源框架矩阵:Spring家族(Spring Boot/Spring Cloud)、Hibernate、Dubbo、MyBatis等形成工业级解决方案

1.2 学习路径建议:四阶段渐进式成长

第一阶段:基础语法(1-2个月)
掌握变量、数据类型、运算符、流程控制(if/switch、for/while)、数组、字符串处理、方法重载与递归。此阶段需通过50+小型练习巩固逻辑思维,例如:九九乘法表、猜数字游戏、简易计算器。

第二阶段:面向对象(2-3周)
理解类与对象、封装、继承、多态三大特性,重点掌握this关键字、构造方法、static与final修饰符、抽象类与接口的区别。建议通过“图形面积计算”项目实践:定义Shape抽象类,派生Circle、Rectangle等子类,体现多态性。

第三阶段:核心库(1-2个月)
深入学习集合框架(List/Map/Set体系)、异常处理机制、IO/NIO流、正则表达式、日期时间API(java.time包)。需重点掌握ArrayList与LinkedList适用场景对比,HashMap红黑树优化原理,以及try-with-resources自动资源管理。

第四阶段:高阶进阶(持续深化)
包括多线程并发编程、JVM内存模型与调优、设计模式应用、网络编程(Socket/HTTP)、数据库连接(JDBC/MyBatis)。建议结合《Java并发编程实战》进行实战演练,例如实现生产者-消费者模型、线程池动态调整。

1.3 开发环境搭建:从JDK到IDE的完整配置

步骤1:安装JDK
推荐使用LTS版本:JDK 8(兼容性最佳)、JDK 11(当前主流)、JDK 17(最新长期支持)。下载地址:Eclipse Temurin或Oracle JDK。

验证安装:

java -version
javac -version
预期输出应显示版本号(如:openjdk version "17.0.9" 2022-10-18)。

步骤2:配置环境变量
• Windows:系统属性→高级→环境变量→新建JAVA_HOME指向JDK安装路径,PATH添加%JAVA_HOME%\bin
• macOS/Linux:编辑~/.bashrc或~/.zshrc,添加:

export JAVA_HOME=/Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH

步骤3:选择IDE
• IntelliJ IDEA(推荐):社区版免费,专业版含Spring工具链
• Eclipse:老牌IDE,插件丰富但界面稍旧
• VS Code:轻量级选择,需安装Java Extension Pack

二、Java语法核心:从基础到高级特性

基础语法
字符串处理
异常机制

2.1 基础语法规范

1. 标识符命名规则
• 由字母、数字、下划线(_)、美元符号($)组成
• 不能以数字开头
• 区分大小写(Java是大小写敏感语言)
• 关键字不能作为标识符(如class、public、static)

2. 数据类型分类

类型字节数取值范围示例
byte1-128 ~ 127byte b = 100;
short2-32,768 ~ 32,767short s = 30000;
int4-2³¹ ~ 2³¹-1int age = 25;
long8-2⁶³ ~ 2⁶³-1long population = 1400000000L;
float4±3.402823e+38float price = 99.9f;
double8±1.797693e+308double pi = 3.1415926;
boolean1位true/falseboolean isVip = true;
char2Unicode字符char grade = 'A';

注意:整数默认int类型,浮点默认double类型;强制类型转换需注意精度丢失。

2.2 字符串与正则表达式

1. String特性
• 不可变性(immutable):每次修改生成新对象
• 常量池优化:相同字符串字面量共享对象
• 常用方法:
- length():字符串长度
- charAt(int index):获取指定位置字符
- substring(int beginIndex, int endIndex):截取子串
- trim():去除首尾空格
- equalsIgnoreCase(String other):忽略大小写比较
- split(String regex):按正则分割

2. StringBuilder与StringBuffer

特性StringBuilderStringBuffer
线程安全否是(synchronized)
性能高中
适用场景单线程多线程

示例:高效拼接日志

StringBuilder sb = new StringBuilder();
for (String s : list) {
    sb.append(s).append(" | ");
}
String result = sb.toString().trim().replaceLast(" \\| $", "");

3. 正则表达式应用
• 常用元字符:.(任意单字符)、\d(数字)、\w(字母数字下划线)、+(1次以上)、*(0次以上)、?(0或1次)
• 实用场景:
- 邮箱验证:^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
- 手机号验证:^1[3-9]\d{9}$
- 提取数字:Pattern.compile("\\d+").matcher(str)

2.3 异常处理机制

1. 异常体系结构

Throwable
├── Error(系统级错误,如OutOfMemoryError)
└── Exception
    ├── RuntimeException(运行时异常,如NullPointerException)
    └── IOException等受检异常(需显式处理)

2. 处理方式
• try-catch-finally:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.err.println("除零错误:" + e.getMessage());
} finally {
    System.out.println("资源清理操作");
}
• throws声明:方法签名后声明可能抛出的异常
• try-with-resources(JDK7+):
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    return br.readLine();
} catch (IOException e) {
    e.printStackTrace();
}

3. 自定义异常

public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}
使用场景:用户输入年龄为负数时抛出

2.4 语法进阶:Lambda与流式API(JDK8+)

1. Lambda表达式基础
语法:(参数) -> {方法体}
示例:排序比较器简化

// JDK8前
Collections.sort(list, new Comparator() {
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});
// JDK8后
list.sort(String::compareTo); // 或 list.sort((a,b) -> a.compareTo(b));

2. 函数式接口
仅含一个抽象方法的接口(@FunctionalInterface)
• Runnable、Callable、Comparator、Predicate(返回boolean)
• Function(输入T输出R)、Consumer(消费型)、Supplier(供给型)

3. Stream API核心操作

list.stream()
    .filter(s -> s.length() > 3)  // 过滤长度>3的字符串
    .map(String::toUpperCase)      // 转大写
    .sorted()                      // 排序
    .forEach(System.out::println); // 终止操作
常见终止操作:collect()(收集为集合)、count()(计数)、findFirst()(取首个)
中间操作:distinct()(去重)、limit(n)(截取前n个)、skip(n)(跳过n个)

三、面向对象编程:Java的基石

3.1 封装、继承、多态详解

1. 封装(Encapsulation)
• 通过private修饰符隐藏内部实现
• 提供public getter/setter方法控制访问
• 示例:

public class Person {
    private String name;
    private int age;
    public String getName() { return name; }
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
    public int getAge() { return age; }
    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        }
    }
}

2. 继承(Inheritance)
• 使用extends关键字
• 单继承限制(避免菱形继承问题)
• super关键字调用父类构造器
• 注意:子类不能继承父类的private成员,但可通过protected/公共方法访问

3. 多态(Polymorphism)
• 编译时多态:方法重载(overload)
• 运行时多态:方法重写(override)
• 三要素:继承、重写、父类引用指向子类对象
• 示例:

Animal a = new Dog(); // 父类引用
a.sound(); // 调用Dog类重写的sound()方法

抽象类与接口
设计模式应用

3.2 抽象类 vs 接口

抽象类(abstract class)
• 可包含抽象方法(无方法体)和具体方法
• 有构造方法(供子类调用)
• 单继承限制
• 适用场景:有共同行为但实现细节不同的类族
示例:

public abstract class Vehicle {
    protected String brand;
    public Vehicle(String brand) { this.brand = brand; }
    public abstract void start(); // 抽象方法
    public void showBrand() { System.out.println(brand); } // 具体方法
}

接口(interface)
• JDK8前:仅含抽象方法、常量
• JDK8+:可含default方法、static方法
• JDK9+:可含private方法
• 支持多实现
• 适用场景:定义规范、解耦设计
示例:

public interface Flyable {
    void fly();
    default void land() { System.out.println("自动降落"); } // 默认实现
    static void info() { System.out.println("飞行器接口"); } // 静态方法
}

对比表

特性抽象类接口
构造方法有无
成员变量任意类型public static final
方法类型抽象/具体JDK8前仅抽象
继承/实现单继承多实现
设计目的代码复用行为规范

3.3 5大常用设计模式实战

1. 单例模式(Singleton)
确保一个类只有一个实例,并提供全局访问点
• 饿汉式(类加载即创建):

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() { return INSTANCE; }
}
• 懒汉式(线程安全版):
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;
    }
}

2. 工厂模式(Factory)
定义创建对象的接口,但由子类决定实例化哪个类
示例:数据库连接工厂

public interface DataSource {
    Connection getConnection();
}
public class MySQLDataSource implements DataSource {
    public Connection getConnection() { return DriverManager.getConnection(...); }
}
public class DataSourceFactory {
    public static DataSource getDataSource(String type) {
        if ("mysql".equals(type)) return new MySQLDataSource();
        throw new IllegalArgumentException("未知类型");
    }
}

3. 代理模式(Proxy)
为其他对象提供一种代理以控制对这个对象的访问
• 静态代理:代理类手动编写
• 动态代理:JDK Proxy / CGLIB
示例(JDK动态代理):

InvocationHandler handler = (proxy, method, args) -> {
    System.out.println("方法执行前:" + method.getName());
    Object result = method.invoke(target, args);
    System.out.println("方法执行后");
    return result;
};
Object proxy = Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(),
    handler
);

4. 观察者模式(Observer)
定义对象间一对多依赖,当一对象状态改变,所有依赖者通知
Java内置支持:java.util.Observer和java.util.Observable(已废弃)
推荐使用:PropertyChangeListener或第三方库RxJava
示例:天气站通知订阅者

Subject weatherStation = new WeatherStation();
Observer subscriber = new NewsChannel();
weatherStation.addObserver(subscriber);
weatherStation.setWeatherData(new WeatherData(25, 0.8, 1013));

5. 策略模式(Strategy)
定义一系列算法,将每个算法封装起来,并使它们可互换
示例:支付方式选择

public interface PaymentStrategy {
    void pay(double amount);
}
public class CreditCardPayment implements PaymentStrategy {
    public void pay(double amount) { System.out.println("信用卡支付:" + amount); }
}
public class PayPalPayment implements PaymentStrategy {
    public void pay(double amount) { System.out.println("PayPal支付:" + amount); }
}
public class ShoppingCart {
    private PaymentStrategy strategy;
    public void setPaymentStrategy(PaymentStrategy strategy) { this.strategy = strategy; }
    public void checkout(double amount) { strategy.pay(amount); }
}

四、Java核心库:集合、IO、并发工具

4.1 集合框架深度解析

1. Collection体系
• List(有序可重复):
- ArrayList:基于动态数组,随机访问快(O(1)),增删慢(O(n))
- LinkedList:基于双向链表,增删快(O(1)),随机访问慢(O(n))
- Vector:线程安全(synchronized),已过时(推荐使用Collections.synchronizedList)
• Set(无序不可重复):
- HashSet:基于HashMap实现,存取快,无序
- LinkedHashSet:保持插入顺序
- TreeSet:基于红黑树,自然排序或定制排序
• Queue(队列):
- LinkedList(双端队列)
- PriorityQueue(优先级队列)
- BlockingQueue(并发队列,如ArrayBlockingQueue)

2. Map体系
• HashMap:
- JDK7:数组+链表
- JDK8:数组+链表/红黑树(链表>8且数组>64时转红黑树)
- 线程不安全,允许null键值
• LinkedHashMap:保持插入顺序(用双向链表维护)
• TreeMap:基于红黑树,键排序
• ConcurrentHashMap:
- JDK7:Segment分段锁
- JDK8:CAS+synchronized(锁桶)
- 线程安全,高性能

3. 集合选择指南

需求推荐实现原因
频繁随机访问ArrayList数组结构,O(1)访问
频繁增删LinkedList链表结构,O(1)插入
需要排序TreeSet/TreeMap红黑树保证有序
高并发MapConcurrentHashMap分段锁优化
保持插入顺序LinkedHashMap双向链表维护顺序

4.2 IO/NIO模型对比

1. 传统IO(java.io)
• 阻塞式:read()会阻塞直到数据到达
• 基于流(Stream):字节流(InputStream/OutputStream)、字符流(Reader/Writer)
• 示例:文件复制

try (FileInputStream fis = new FileInputStream("src.txt");
     FileOutputStream fos = new FileOutputStream("dest.txt")) {
    byte[] buffer = new byte[8192];
    int len;
    while ((len = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, len);
    }
}

2. NIO(java.nio)
• 非阻塞式:支持选择器(Selector)
• 基于通道(Channel)和缓冲区(Buffer)
• 示例:服务器端NIO

Selector selector = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() > 0) {
    Iterator it = selector.selectedKeys().iterator();
    while (it.hasNext()) {
        SelectionKey key = it.next();
        if (key.isAcceptable()) {
            SocketChannel sc = ssc.accept();
            sc.configureBlocking(false);
            sc.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            SocketChannel sc = (SocketChannel)key.channel();
            ByteBuffer buf = ByteBuffer.allocate(1024);
            sc.read(buf);
            buf.flip();
            sc.write(buf);
        }
        it.remove();
    }
}

3. Files工具类(JDK7+)
简化文件操作:
• Files.readAllLines(Path):读取文件为List
• Files.write(Path, Iterable):写入字符串列表
• Files.copy(Path, Path, CopyOption...):复制文件
• Files.walk(Path):递归遍历目录

4.3 日期时间API(java.time)

JDK8前问题:Date可变、线程不安全、时区处理复杂
JDK8解决方案:不可变类+线程安全

类用途示例
LocalDate仅日期(无时分秒)LocalDate.now()
LocalTime仅时间(无日期)LocalTime.of(14, 30)
LocalDateTime日期+时间LocalDateTime.now().plusDays(1)
ZonedDateTime带时区ZonedDateTime.of(LocalDateTime.now(), ZoneId.of("Asia/Shanghai"))
Duration/Period时间差Duration.between(t1, t2).toSeconds()

格式化与解析:

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime dt = LocalDateTime.parse("2023-12-25 18:30:00", formatter);
String formatted = dt.format(formatter);

五、多线程编程:并发处理的核心

5.1 线程创建与生命周期

1. 创建方式
• 继承Thread类(不推荐:单继承限制)
• 实现Runnable接口(推荐:解耦)
• 实现Callable接口(支持返回值)
• 使用线程池(最佳实践)

2. 线程状态

NEW → RUNNABLE → TERMINATED
       ↑________|
       |
       v
BLOCKED(等待锁)
       ↑
       |
WAITING(无限等待)
       ↑
       |
TIMED_WAITING(超时等待)

3. 关键方法
• start():启动线程(调用run())
• sleep(long millis):暂停当前线程
• join():等待其他线程终止
• yield():谦让当前线程(建议调度器切换)
• interrupt():中断线程(设置中断标志)

同步机制
线程池

5.2 同步与锁机制

1. synchronized
• 修饰方法:锁当前对象实例
• 修饰代码块:锁指定对象
• 静态方法:锁Class对象
示例:

public synchronized void increment() { count++; } // 实例方法锁this
public static synchronized void reset() { count = 0; } // 静态方法锁Class

2. 显式锁(java.util.concurrent.locks)
• ReentrantLock:可重入锁,支持公平/非公平
• ReadWriteLock:读写分离锁(读读不互斥)
• StampedLock:优化版读写锁(支持乐观读)
示例:

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区
} finally {
    lock.unlock();
}

3. volatile
• 保证可见性(线程间立即可见)
• 禁止指令重排序
• 不保证原子性(需配合Atomic类)
适用场景:状态标记、双重检查锁

5.3 线程池与Executor框架

1. 线程池优势
• 降低资源消耗(复用线程)
• 提高响应速度(任务到达即执行)
• 统一管理(控制最大并发数)

2. 创建方式
• Executors.newFixedThreadPool(n):固定大小线程池
• Executors.newCachedThreadPool():可缓存线程池(空闲线程回收)
• Executors.newSingleThreadExecutor():单线程池
• ThreadPoolExecutor(推荐):自定义参数
示例:

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, 10, 60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),
    new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

3. 关键参数

参数说明
corePoolSize核心线程数
maximumPoolSize最大线程数
keepAliveTime空闲线程存活时间
workQueue任务队列(ArrayBlockingQueue等)
threadFactory线程创建工厂
handler拒绝策略(AbortPolicy等)

4. 提交任务
• execute(Runnable):无返回值
• submit(Callable):返回Future
• invokeAll(Collection):批量执行
示例:

Future future = executor.submit(() -> {
    return 10 + 20;
});
Integer result = future.get(); // 阻塞等待结果

5.4 并发工具类

1. CountDownLatch
倒计时器:等待多个线程完成
示例:主线程等待3个子线程加载数据

CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        // 加载数据
        latch.countDown();
    }).start();
}
latch.await(); // 等待所有线程完成

2. CyclicBarrier
循环栅栏:线程到达屏障等待,全部到达后继续
示例:赛马比赛,所有马到达终点才开始统计

CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有马到达终点,开始统计!");
});
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        // 赛跑
        barrier.await();
    }).start();
}

3. Semaphore
信号量:控制同时访问特定资源的线程数
示例:数据库连接池(最多10个连接)

Semaphore semaphore = new Semaphore(10);
semaphore.acquire(); // 获取信号量
try {
    // 使用资源
} finally {
    semaphore.release(); // 释放信号量
}

4. StampedLock
JDK8新增,支持三种模式:
• 写锁(排他)
• 悲观读锁(阻塞写锁)
• 乐观读锁(不阻塞写锁)
示例:

StampedLock sl = new StampedLock();
long stamp = sl.tryOptimisticRead();
if (!sl.validate(stamp)) {
    stamp = sl.readLock();
    try {
        // 读操作
    } finally {
        sl.unlockRead(stamp);
    }
}

六、JVM原理:深入理解Java运行时

6.1 JVM内存模型

1. 运行时数据区域

线程私有:
├── 程序计数器(PC Register):当前线程执行的字节码行号
├── 虚拟机栈(VM Stack):方法执行内存模型(栈帧)
└── 本地方法栈(Native Method Stack):Native方法服务
线程共享:
├── 堆(Heap):对象实例分配区域
├── 方法区(Method Area):类信息、常量、静态变量
└── 运行时常量池(Runtime Constant Pool):编译期常量

2. 对象创建过程
1. 类加载检查(是否已加载)
2. 分配内存(指针碰撞/空闲列表)
3. 初始化零值
4. 设置对象头(哈希码、GC分代年龄等)
5. 执行init方法

3. 内存溢出场景
• Java heap space:堆内存不足(对象过多)
• GC overhead limit exceeded:GC时间过长(>98%时间用于GC)
• Metaspace(JDK8+):方法区内存不足
• StackOverflowError:栈深度过大(递归过深)
• Direct buffer memory:NIO直接内存不足

6.2 垃圾回收机制

1. 判断对象存活
• 引用计数法:循环引用问题
• 可达性分析:从GC Roots出发(虚拟机栈引用、静态属性引用等)

2. 垃圾回收算法
• 标记-清除:产生内存碎片
• 复制:内存利用率低(HotSpot默认Eden:Survivor=8:1)
• 标记-整理:老年代使用,避免碎片

3. 分代收集理论
• 新生代:Minor GC频繁(Eden区满触发)
• 老年代:Major GC/Full GC(老年代满触发)
• 永久代→元空间(JDK8+):元空间使用本地内存

4. 常用垃圾回收器

回收器适用场景特点
Serial单核/CPU少单线程,STW暂停
ParNew多核服务器Serial的多线程版
Parallel Scavenge高吞吐量关注吞吐量(用户代码/总时间)
CMS低延迟并发清除,浮动垃圾问题
G1大内存/低停顿区域化,可预测停顿
ZGC超低延迟(JDK11+)停顿<10ms,支持TB级堆

6.3 性能调优实战

1. 常用诊断工具
• jps:查看Java进程
• jstat:监控GC情况
• jmap:生成堆转储
• jstack:线程堆栈
• jconsole/jvisualvm:图形化监控

2. 调优方向
• 内存调优:
- -Xms/-Xmx:堆初始/最大值(建议相等)
- -Xmn:新生代大小
- -XX:MetaspaceSize:元空间初始大小
• GC调优:
- 优先使用G1/ZGC
- 分析GC日志(-Xlog:gc*)
- 目标:STW时间<100ms
• 代码调优:
- 避免隐式对象创建(如字符串拼接)
- 合理使用对象池
- 减少锁竞争

3. 典型案例
• 内存泄漏:集合未清理导致对象无法回收
• 死锁:两个线程互相等待对方释放锁
• 高GC频率:堆过小或对象创建过多
• Full GC频繁:老年代内存不足或大对象直接进入老年代

七、JDK新特性:从JDK8到JDK21

JDK8(2014)

核心特性:Lambda表达式、Stream API、Date Time API、Optional类
示例:

// Optional避免空指针
Optional user = Optional.ofNullable(findUser(id));
user.ifPresent(u -> System.out.println(u.getName()));

JDK9(2017)

核心特性:模块化(JPMS)、私有接口方法、Diamond操作符增强
模块示例:

module com.example.app {
    requires java.sql;
    exports com.example.app.service;
}

JDK11(2018)

核心特性:ZGC、HTTP Client API、String新增方法
新API:

// 字符串操作增强
"Hello".strip();      // 去除首尾空白
"Hello".isBlank();    // 判断是否为空白
"Hello".repeat(3);    // 重复3次

JDK17(2021)

核心特性:ZGC生产级、Pattern Matching、Sealed Classes
模式匹配:

if (obj instanceof String s) {
    System.out.println(s.toLowerCase());
}

JDK21(2023)

核心特性:虚拟线程(Project Loom)、Structured Concurrency
虚拟线程示例:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 1000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}

7.1 未来趋势:云原生与Java

随着云原生技术发展,Java正通过以下方向优化:
• GraalVM:原生镜像(Native Image)启动快、内存低
• Spring Native:构建原生镜像
• 虚拟线程:高并发场景下替代传统线程
• 响应式编程:Project Reactor支持非阻塞I/O
示例:响应式WebFlux

@RestController
public class UserController {
    @GetMapping("/users/{id}")
    public Mono getUser(@PathVariable String id) {
        return userService.findById(id);
    }
}

八、高频面试题精讲

8.1 基础题

Q1:== 与 equals() 的区别?
• ==:基本类型比较值,引用类型比较内存地址
• equals():默认比较地址,String等类重写为比较内容
补充:重写equals()必须重写hashCode()!

Q2:final、finally、finalize()?
• final:修饰类(不可继承)、方法(不可重写)、变量(不可变)
• finally:异常处理的finally块
• finalize():对象被GC前调用(已废弃,不推荐使用)

Q3:重载(Overload)与重写(Override)?

特性重载重写
作用范围同一类子类
参数列表必须不同必须相同
返回类型可不同子类可更窄
访问修饰符可更宽不能更严

8.2 进阶题

Q1:HashMap的红黑树优化原理?
• JDK8后,当链表长度>8且数组长度>64时转红黑树
• 目的:避免哈希冲突导致性能退化为O(n)
• 红黑树特性:近似平衡,查询/插入/删除O(log n)

Q2:线程池的拒绝策略有哪些?
• AbortPolicy:抛出RejectedExecutionException
• CallerRunsPolicy:由调用线程执行任务
• DiscardPolicy:直接丢弃任务
• DiscardOldestPolicy:丢弃队列中最旧任务

Q3:JVM如何判断对象可回收?
• 可达性分析:从GC Roots出发,不可达则可回收
• GC Roots包括:虚拟机栈引用、静态属性引用、常量引用等

8.3 场景题

Q:高并发下如何保证数据库连接池不被打垮?
方案:
1. 设置合理连接数(根据CPU核心数×2)
2. 使用连接池(HikariCP推荐)
3. 实现连接泄漏检测
4. 超时机制(连接获取超时、查询超时)
5. 异步处理(CompletableFuture)
示例配置:

HikariConfig config = new HikariConfig();
config.setMaximumPoolSize(10);
config.setConnectionTimeout(3000);
config.setIdleTimeout(600000);
config.setLeakDetectionThreshold(2000);