第二阶段：Java新特性与工具链

#### **1. Java 8+新特性**
- **知识点**：
- Lambda表达式。
- Stream API。
- `Optional`类。

 

### 1. Lambda 表达式

#### 说明
Lambda 表达式是 Java 8 引入的一个重要特性，它允许把函数作为一个方法的参数传递，或者说将代码像数据一样传递。Lambda 表达式本质上是一个匿名函数，它可以简化代码，使代码更加简洁和易读。Lambda 表达式的语法结构为 `(参数列表) -> { 方法体 }`，如果方法体只有一条语句，大括号和 `return` 关键字可以省略。

#### 示例
```java
import java.util.ArrayList;
import java.util.List;

// 定义一个函数式接口
@FunctionalInterface
interface MyFunction {
int operate(int a, int b);
}

public class LambdaExample {
public static void main(String[] args) {
// 1. 基本 Lambda 表达式示例
MyFunction add = (a, b) -> a + b;
int result = add.operate(3, 5);
System.out.println("3 + 5 = " + result);

// 2. 在集合遍历中使用 Lambda 表达式
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

// 使用 Lambda 表达式遍历集合
names.forEach(name -> System.out.println(name));
}
}
```
#### 代码解释
- 定义了一个函数式接口 `MyFunction`，其中只有一个抽象方法 `operate`。
- 使用 Lambda 表达式 `(a, b) -> a + b` 实现了 `MyFunction` 接口，将其赋值给 `add` 变量，然后调用 `operate` 方法进行加法运算。
- 在集合遍历中，使用 `forEach` 方法结合 Lambda 表达式 `name -> System.out.println(name)` 来遍历 `names` 列表并打印每个元素。

### 2. Stream API

#### 说明
Stream API 也是 Java 8 引入的新特性，它提供了一种高效且易于使用的处理集合数据的方式。Stream 不是一个数据结构，而是对数据源（如集合、数组等）进行一系列流水线式的中间操作和终端操作的抽象。中间操作会返回一个新的 Stream，允许进行链式调用；终端操作会触发实际的计算并产生结果。

#### 示例
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamAPIExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 1. 过滤和映射操作
List<Integer> evenSquares = numbers.stream()
.filter(n -> n % 2 == 0) // 过滤出偶数
.map(n -> n * n) // 对每个偶数进行平方操作
.collect(Collectors.toList()); // 收集结果到列表
System.out.println("偶数的平方: " + evenSquares);

// 2. 聚合操作
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b); // 对所有元素求和
System.out.println("所有元素的和: " + sum);
}
}
```
#### 代码解释
- 使用 `stream()` 方法将 `numbers` 列表转换为 Stream。
- 在第一个示例中，使用 `filter` 中间操作过滤出偶数，使用 `map` 中间操作对每个偶数进行平方操作，最后使用 `collect` 终端操作将结果收集到一个新的列表中。
- 在第二个示例中，使用 `reduce` 终端操作对 Stream 中的所有元素进行求和。

### 3. `Optional` 类

#### 说明
`Optional` 类是 Java 8 引入的一个容器类，用于表示一个值可能存在也可能不存在的情况。它可以帮助我们避免 `NullPointerException`，使代码更加健壮。`Optional` 类提供了一些方法来处理值是否存在的情况，如 `isPresent()` 用于判断值是否存在，`ifPresent()` 用于在值存在时执行操作，`orElse()` 用于在值不存在时提供一个默认值等。

#### 示例
```java
import java.util.Optional;

class Person {
private String name;

public Person(String name) {
this.name = name;
}

public Optional<String> getName() {
return Optional.ofNullable(name);
}
}

public class OptionalExample {
public static void main(String[] args) {
Person person1 = new Person("Alice");
Person person2 = new Person(null);

// 1. 使用 ifPresent 方法
person1.getName().ifPresent(name -> System.out.println("Person 1 的名字是: " + name));
person2.getName().ifPresent(name -> System.out.println("Person 2 的名字是: " + name));

// 2. 使用 orElse 方法
String name1 = person1.getName().orElse("未知");
String name2 = person2.getName().orElse("未知");
System.out.println("Person 1 的名字: " + name1);
System.out.println("Person 2 的名字: " + name2);
}
}
```
#### 代码解释
- 在 `Person` 类中，`getName` 方法返回一个 `Optional<String>` 对象，使用 `Optional.ofNullable` 方法可以安全地处理 `name` 可能为 `null` 的情况。
- 在 `main` 方法中，使用 `ifPresent` 方法在值存在时打印名字。
- 使用 `orElse` 方法在值不存在时提供一个默认值 `未知`。

#### **2. Java模块化**
- **知识点**：
- 模块化概念（`module-info.java`）。
- 模块化带来的变化。

### 1. 模块化概念（`module-info.java`）

#### 概念解释
Java 9 引入了模块化系统（Jigsaw 项目），旨在解决大型 Java 应用程序在开发和部署过程中面临的一些问题，如类路径管理复杂、依赖关系不明确等。模块化系统允许将代码组织成多个模块，每个模块都有自己的名称、依赖关系和导出的包。

`module-info.java` 是 Java 模块化系统中的核心文件，用于定义模块的元数据。它位于模块的根目录下，包含了模块的名称、依赖的其他模块以及导出的包等信息。

#### 语法结构
```java
module 模块名 {
// 声明依赖的其他模块
requires 依赖模块名;
// 声明导出的包，其他模块可以访问这些包中的公共类
exports 包名;
// 可选：声明使用的服务
uses 服务接口名;
// 可选：声明提供的服务实现
provides 服务接口名 with 服务实现类名;
}
```

#### 示例
假设有两个模块：`com.example.util` 和 `com.example.app`。

**`com.example.util` 模块**：
- 创建目录结构：`com.example.util` 模块的根目录下创建 `module-info.java` 文件和 `com/example/util` 包。
- `module-info.java` 文件内容：
```java
module com.example.util {
// 导出 com.example.util 包，其他模块可以访问该包中的公共类
exports com.example.util;
}
```
- 在 `com/example/util` 包下创建一个工具类 `StringUtils.java`：
```java
package com.example.util;

public class StringUtils {
public static String reverse(String str) {
return new StringBuilder(str).reverse().toString();
}
}
```

**`com.example.app` 模块**：
- 创建目录结构：`com.example.app` 模块的根目录下创建 `module-info.java` 文件和 `com/example/app` 包。
- `module-info.java` 文件内容：
```java
module com.example.app {
// 声明依赖 com.example.util 模块
requires com.example.util;
}
```
- 在 `com/example/app` 包下创建主类 `Main.java`：
```java
package com.example.app;

import com.example.util.StringUtils;

public class Main {
public static void main(String[] args) {
String input = "Hello";
String reversed = StringUtils.reverse(input);
System.out.println("反转后的字符串: " + reversed);
}
}
```

### 2. 模块化带来的变化

#### 更清晰的依赖管理
在模块化之前，依赖关系通过类路径管理，很难明确一个项目到底依赖哪些库，以及这些库之间的版本兼容性问题。引入模块化后，模块之间的依赖关系在 `module-info.java` 中明确声明，使得依赖关系更加清晰和可维护。

例如，在上述示例中，`com.example.app` 模块在 `module-info.java` 中明确声明了依赖 `com.example.util` 模块，开发人员可以一目了然地知道该模块的依赖情况。

#### 增强的封装性
模块化系统允许模块控制哪些包可以被其他模块访问。通过 `exports` 关键字，模块可以精确地指定哪些包是对外公开的，其他未导出的包对于外部模块是不可见的，从而增强了代码的封装性。

例如，在 `com.example.util` 模块中，只有 `com.example.util` 包被导出，其他包（如果存在）对于 `com.example.app` 模块是不可访问的，这样可以避免外部模块直接访问模块内部的实现细节。

#### 更好的可维护性和可扩展性
模块化使得代码的组织更加清晰，每个模块可以独立开发、测试和部署。当项目规模增大时，开发人员可以更容易地管理和维护代码。同时，模块化也便于添加新的模块，提高了系统的可扩展性。

例如，如果需要添加一个新的工具模块 `com.example.math`，只需要创建相应的 `module-info.java` 文件和实现代码，并在需要依赖该模块的其他模块中声明依赖即可。

#### 减少类路径问题
在传统的 Java 开发中，类路径管理是一个复杂的问题，容易出现类冲突和版本不一致的情况。模块化系统通过明确的依赖关系和封装性，减少了类路径带来的问题，使得项目的构建和运行更加稳定。

总之，Java 模块化系统通过 `module-info.java` 文件和一系列的模块化机制，为 Java 开发带来了更清晰的依赖管理、增强的封装性、更好的可维护性和可扩展性，以及减少类路径问题等诸多好处。

 

#### **3. 常用工具链**
- **知识点**：
- Maven/Gradle构建工具。
- JUnit 5单元测试。
- Lombok简化代码。

 

### 1. Maven/Gradle 构建工具

#### Maven
Maven 是一个项目管理和构建自动化工具，使用 `pom.xml`（Project Object Model）文件来管理项目的依赖、构建生命周期等信息。

**示例：创建一个简单的 Maven Java 项目**
以下是一个简单的 `pom.xml` 文件示例：
```xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.example</groupId>
<artifactId>my-maven-project</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>
<!-- 添加 JUnit 5 依赖 -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M5</version>
</plugin>
</plugins>
</build>
</project>
```
在上述 `pom.xml` 中：
- `groupId`、`artifactId` 和 `version` 定义了项目的坐标。
- `dependencies` 部分添加了 JUnit 5 的依赖，用于后续的单元测试。
- `build` 部分配置了编译器插件和测试运行插件。

#### Gradle
Gradle 是一个基于 Groovy 或 Kotlin DSL 的构建自动化工具，使用 `build.gradle` 文件来配置项目。

**示例：创建一个简单的 Gradle Java 项目**
以下是一个简单的 `build.gradle` 文件示例：
```groovy
plugins {
id 'java'
}

group 'com.example'
version '1.0-SNAPSHOT'

repositories {
mavenCentral()
}

dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
}

test {
useJUnitPlatform()
}
```
在上述 `build.gradle` 中：
- `plugins` 部分应用了 Java 插件。
- `group` 和 `version` 定义了项目的坐标。
- `repositories` 指定了依赖库的仓库，这里使用 Maven 中央仓库。
- `dependencies` 部分添加了 JUnit 5 的依赖。
- `test` 部分配置了使用 JUnit 5 作为测试框架。

### 2. JUnit 5 单元测试
JUnit 5 是 Java 生态系统中广泛使用的单元测试框架，支持参数化测试、动态测试等多种测试方式。

**示例：编写一个简单的 JUnit 5 测试类**
```java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

// 待测试的类
class Calculator {
public int add(int a, int b) {
return a + b;
}
}

// 测试类
public class CalculatorTest {
@Test
public void testAdd() {
Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
assertEquals(5, result);
}
}
```
在上述代码中：
- `Calculator` 类是一个简单的计算器类，包含一个 `add` 方法用于两个整数相加。
- `CalculatorTest` 类是测试类，使用 `@Test` 注解标记测试方法 `testAdd`，在该方法中创建 `Calculator` 对象并调用 `add` 方法，使用 `assertEquals` 断言方法验证结果是否符合预期。

### 3. Lombok 简化代码
Lombok 是一个 Java 库，通过注解的方式可以自动生成 getter、setter、构造函数等样板代码，减少代码的冗余。

**示例：使用 Lombok 简化 Java 类**
首先，需要在项目中添加 Lombok 依赖。

#### Maven 依赖
```xml
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
<scope>provided</scope>
</dependency>
```

#### Gradle 依赖
```groovy
compileOnly 'org.projectlombok:lombok:1.18.22'
annotationProcessor 'org.projectlombok:lombok:1.18.22'
```

然后，使用 Lombok 注解简化代码：
```java
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
class Person {
private String name;
private int age;
}
```
在上述代码中：
- `@Data` 注解会自动生成 `getter`、`setter`、`toString`、`equals` 和 `hashCode` 方法。
- `@NoArgsConstructor` 注解会自动生成无参构造函数。
- `@AllArgsConstructor` 注解会自动生成包含所有参数的构造函数。

这样，我们就可以使用 Lombok 大大简化 Java 类的代码编写，提高开发效率。