最新 Java 基础知识总结及技术应用详解

原创

啦啦啦191

发布于 2025-06-12 12:19:04

2390

文章被收录于专栏：Java开发Java开发

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<String, Map<String, Double>> avgSalaryByDeptAndPosition = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.groupingBy(
            Employee::getPosition,
            Collectors.averagingDouble(Employee::getSalary)
        )
    ));

3. 函数式接口与Lambda表达式

自定义函数式接口

@FunctionalInterface
interface TriFunction<T, U, V, R> {
    R apply(T t, U u, V v);
}

// 使用示例
TriFunction<Integer, Integer, Integer, Integer> sum = (a, b, c) -> a + b + c;
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<User> userFuture = scope.fork(() -> getUserById(userId));
    Future<Order> orderFuture = scope.fork(() -> getOrderById(orderId));
    
    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> createUser(@RequestBody CreateUserRequest request) {
    UserDTO user = userService.createUser(request);
    return ResponseEntity.status(HttpStatus.CREATED).body(user);
}

3. Spring Data JPA 与 Stream API 结合

// 仓库接口定义
public interface UserRepository extends JpaRepository<User, Long> {
    // 返回Stream，处理大数据集时更高效
    @Query("SELECT u FROM User u WHERE u.status = :status")
    Stream<User> findAllByStatus(@Param("status") UserStatus status);
}

// 服务层使用Stream处理数据
public List<UserDTO> findActiveUsers() {
    try (Stream<User> users = userRepository.findAllByStatus(ACTIVE)) {
        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<UserDTO> getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @GetMapping("/users")
    public Flux<UserDTO> getAllUsers() {
        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构建容器镜像

<!-- Maven配置Jib插件 -->
<plugin>
    <groupId>com.google.cloud.tools</groupId>
    <artifactId>jib-maven-plugin</artifactId>
    <version>3.3.1</version>
    <configuration>
        <from>
            <image>gcr.io/distroless/java17-debian11</image>
        </from>
        <to>
            <image>gcr.io/my-project/my-app</image>
        </to>
    </configuration>
</plugin>

命令：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<UserDTO> getUserAsync(Long id) {
    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 基

代码获取方式

https://pan.quark.cn/s/14fcf913bae6

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java