Java基础知识总结（最新技术应用）
一、Java 17+ 新特性应用
1. 模式匹配（Pattern Matching）
实例应用：简化类型检查与转换
// Java 17 前的写法
if (obj instanceof String) {
String str = (String) obj;
System.out.println(str.length());
}
// Java 17+ 的写法（模式匹配）
if (obj instanceof String str) {
System.out.println(str.length());
}
扩展应用：在switch表达式中使用模式匹配
// 处理不同类型的形状计算面积
double area = switch (shape) {
case Circle c -> Math.PI * c.radius() * c.radius();
case Rectangle r -> r.length() * r.width();
default -> throw new IllegalArgumentException("Unknown shape");
};
2. 密封类（Sealed Classes）
应用场景：限制类的继承关系
// 定义密封接口，只允许指定的类实现
public sealed interface PaymentMethod
permits CreditCard, PayPal, BankTransfer {
// 接口方法
}
// 实现类必须声明为final或sealed
public final class CreditCard implements PaymentMethod {
// 实现细节
}
优势：增强类型安全性，适用于枚举式类层次结构。
3. 文本块（Text Blocks）
应用场景：处理复杂字符串（JSON、SQL等）
// Java 17 前的JSON字符串
String json = "{\n" +
" \"name\": \"John\",\n" +
" \"age\": 30\n" +
"}";
// Java 17+ 的文本块
String json = """
{
"name": "John",
"age": 30
}
""";
二、函数式编程与Stream API高级应用
1. 并行流（Parallel Streams）
应用场景：大数据集并行处理
// 计算1到10000的平方和（并行处理）
long sum = LongStream.rangeClosed(1, 10000)
.parallel()
.map(n -> n * n)
.sum();
注意事项：并行流会引入线程调度开销，适用于计算密集型且数据集较大的场景。
2. 收集器（Collectors）高级用法
多级分组与聚合
// 按部门和职位分组统计员工平均薪资
Map
.collect(Collectors.groupingBy(
Employee::getDepartment,
Collectors.groupingBy(
Employee::getPosition,
Collectors.averagingDouble(Employee::getSalary)
)
));
3. 函数式接口与Lambda表达式
自定义函数式接口
@FunctionalInterface
interface TriFunction
R apply(T t, U u, V v);
}
// 使用示例
TriFunction
int result = sum.apply(1, 2, 3); // 结果: 6
三、并发编程新特性
1. Virtual Threads（JDK 21+）
轻量级线程：显著提升并发性能
// 使用虚拟线程处理大量并发请求
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
IntStream.range(0, 10_000).forEach(i -> {
executor.submit(() -> {
// 模拟IO操作
Thread.sleep(Duration.ofMillis(100));
return i;
});
});
} // 自动关闭executor
优势：减少线程上下文切换开销，提高资源利用率。
2. 结构化并发（Structured Concurrency）
简化异步编程：JDK 21 预览特性
// 同时获取用户信息和订单信息
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Future
Future
scope.join(); // 等待所有任务完成
scope.throwIfFailed(); // 任一任务失败则抛出异常
User user = userFuture.resultNow();
Order order = orderFuture.resultNow();
return new UserOrder(user, order);
}
四、模块化系统（JPMS）应用
1. 创建模块化应用
模块声明（module-info.java）
// 模块声明文件
module com.example.app {
requires java.sql; // 依赖Java标准模块
requires org.slf4j; // 依赖第三方模块
exports com.example.app.api; // 导出API包供其他模块使用
uses com.example.app.Service; // 使用服务
provides com.example.app.Service // 提供服务实现
with com.example.app.impl.DefaultService;
}
2. 模块化优势
强封装性：限制包的可见性，避免类路径污染
依赖明确性：通过requires显式声明依赖
性能优化：JVM可只加载必要模块
五、记录类（Records）与模式匹配结合
1. 记录类简化数据模型
// 传统类定义
public class Point {
private final int x;
private final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
// getter、equals、hashCode、toString方法
}
// 使用记录类简化
public record Point(int x, int y) {
} // 自动生成所有必要方法
2. 记录类与模式匹配组合使用
// 匹配不同形状计算面积
double calculateArea(Shape shape) {
return switch (shape) {
case Circle(var radius) -> Math.PI * radius * radius;
case Rectangle(var width, var height) -> width * height;
default -> throw new IllegalArgumentException("Unknown shape");
};
}
六、应用实例：Spring Boot 3 + Java 17 微服务示例
1. 项目结构
src/main/java/
├── com/example/demo/
│ ├── DemoApplication.java // 应用入口
│ ├── config/ // 配置类
│ ├── controller/ // REST控制器
│ ├── service/ // 业务逻辑
│ ├── repository/ // 数据访问
│ └── model/ // 数据模型
│ ├── dto/ // 数据传输对象（记录类）
│ └── entity/ // 实体类
2. 记录类与DTO设计
// 使用记录类定义DTO
public record UserDTO(
Long id,
String username,
String email,
LocalDate createdDate
) {
}
// 控制器使用记录类接收请求参数
@PostMapping("/users")
public ResponseEntity
UserDTO user = userService.createUser(request);
return ResponseEntity.status(HttpStatus.CREATED).body(user);
}
3. Spring Data JPA 与 Stream API 结合
// 仓库接口定义
public interface UserRepository extends JpaRepository
// 返回Stream，处理大数据集时更高效
@Query("SELECT u FROM User u WHERE u.status = :status")
Stream
}
// 服务层使用Stream处理数据
public List
try (Stream
return users
.map(this::convertToDto)
.collect(Collectors.toList());
} // 自动关闭Stream
}
4. 响应式编程与WebFlux
// WebFlux响应式控制器
@RestController
@RequestMapping("/api/reactive")
public class ReactiveUserController {
private final ReactiveUserService userService;
@GetMapping("/users/{id}")
public Mono
return userService.findById(id);
}
@GetMapping("/users")
public Flux
return userService.findAll();
}
}
七、测试技术升级
1. JUnit 5 + AssertJ
// 使用JUnit 5和AssertJ进行测试
@Test
void testUserCreation() {
// 准备数据
CreateUserRequest request = new CreateUserRequest("testuser", "test@example.com");
// 执行测试
UserDTO result = userService.createUser(request);
// 断言验证
assertThat(result.id()).isNotNull();
assertThat(result.username()).isEqualTo("testuser");
assertThat(result.email()).isEqualTo("test@example.com");
assertThat(result.createdDate()).isEqualTo(LocalDate.now());
}
2. Mockito 4 新特性
// 使用Mockito 4的静态导入和新API
@Test
void testUserService() {
// 模拟依赖
UserRepository repository = mock(UserRepository.class);
UserService service = new UserServiceImpl(repository);
// 设置模拟行为
when(repository.findById(1L)).thenReturn(Optional.of(new User(1L, "user1")));
// 执行测试
UserDTO result = service.getUserById(1L);
// 验证结果
assertThat(result.id()).isEqualTo(1L);
assertThat(result.username()).isEqualTo("user1");
// 验证交互
verify(repository).findById(1L);
}
八、容器化与云原生集成
1. 使用Jib构建容器镜像
命令：mvn jib:build（无需Docker环境）
2. 优化JVM容器化配置
# Dockerfile中的JVM参数优化
ENTRYPOINT ["java", \
"-XX:+UseContainerSupport", \
"-XX:MaxRAMPercentage=80.0", \
"-XX:+HeapDumpOnOutOfMemoryError", \
"-Dspring.profiles.active=prod", \
"-jar", "/app.jar"]
九、性能调优与监控
1. 使用JFR（Java Flight Recorder）
# 启动应用时启用JFR
java -XX:StartFlightRecording=filename=recording.jfr,duration=60s -jar app.jar
分析工具：JDK Mission Control（可视化分析JFR数据）
2. 异步编程优化
// 使用CompletableFuture实现异步处理
public CompletableFuture
return CompletableFuture.supplyAsync(() -> {
// 耗时操作（如数据库查询）
return userRepository.findById(id)
.map(this::convertToDto)
.orElseThrow(() -> new UserNotFoundException(id));
}, asyncExecutor);
}
十、现代Java开发工具链
1. 使用SDKMAN管理JDK版本
# 安装SDKMAN
curl -s "https://get.sdkman.io" | bash
# 安装特定版本JDK
sdk install java 17.0.7-tem
2. Gradle Kotlin DSL 构建脚本
// build.gradle.kts
plugins {
id("org.springframework.boot") version "3.1.5"
id("io.spring.dependency-management") version "1.1.3"
kotlin("jvm") version "1.9.20"
kotlin("plugin.spring") version "1.9.20"
}
group = "com.example"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_17
repositories {
mavenCentral()
}
dependencies {
implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.springframework.boot:spring-boot-starter-data-jpa")
implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
runtimeOnly("com.h2database:h2")
testImplementation("org.springframework.boot:spring-boot-starter-test")
}
总结
现代Java开发已全面转向更简洁、更高效的编程范式，通过记录类、模式匹配、密封类等特性大幅简化代码，同时通过虚拟线程、结构化并发等提升性能。结合Spring Boot 3、响应式编程、容器化等技术，Java在微服务、云原生领域依然保持强大竞争力。建议开发者逐步迁移至Java 17+，充分利用这些新特性提升开发效率和应用质量。
Java 基础知识，2025 年，最新技术，人工智能，云原生，微服务，大数据，量子计
代码获取方式https://pan.quark.cn/s/14fcf913bae6