一、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. 数据类型分类
| 类型 | 字节数 | 取值范围 | 示例 |
|---|---|---|---|
| byte | 1 | -128 ~ 127 | byte b = 100; |
| short | 2 | -32,768 ~ 32,767 | short s = 30000; |
| int | 4 | -2³¹ ~ 2³¹-1 | int age = 25; |
| long | 8 | -2⁶³ ~ 2⁶³-1 | long population = 1400000000L; |
| float | 4 | ±3.402823e+38 | float price = 99.9f; |
| double | 8 | ±1.797693e+308 | double pi = 3.1415926; |
| boolean | 1位 | true/false | boolean isVip = true; |
| char | 2 | Unicode字符 | 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
| 特性 | StringBuilder | StringBuffer |
|---|---|---|
| 线程安全 | 否 | 是(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
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 | 红黑树保证有序 |
| 高并发Map | ConcurrentHashMap | 分段锁优化 |
| 保持插入顺序 | 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);