跳至主要內容

Java11新特性教程 - LTS版本完整指南

Java突击队大约 15 分钟

Java11新特性教程 - LTS版本完整指南

目录

  1. Java11简介
  2. 环境搭建
  3. HTTP Client（标准库）
  4. 局部变量类型推断增强
  5. String新增方法
  6. Files新增方法
  7. Optional新增方法
  8. Collection新增方法
  9. ZGC垃圾收集器
  10. Epsilon垃圾收集器
  11. 其他重要特性
  12. 移除和废弃的功能
  13. 实际应用案例
  14. 总结与最佳实践

点击这里👇🏻获取：100万QPS短链系统、复杂的商城微服务系统、智能翻译助手AI Agent、SaaS点餐系统、刷题吧小程序、商城系统、秒杀系统、AI项目、代码生成神器、苏三demo项目等 8 个项目的：项目源代码、开发教程和技术答疑

1. Java11简介

Java 11于2018年9月25日正式发布，是继Java 8之后的第二个长期支持（LTS）版本。Java 11带来了许多重要的新特性和改进，是Java生态系统的重要里程碑。

主要特性列表：

  • ✅ HTTP Client（标准库）：现代化的HTTP客户端API

  • ✅ 局部变量类型推断增强：支持Lambda参数类型推断

  • ✅ String新增方法：isBlank()、lines()、strip()等

  • ✅ Files新增方法：readString()、writeString()等

  • ✅ Optional新增方法：isEmpty()方法

  • ✅ Collection新增方法：toArray()改进

  • ✅ ZGC垃圾收集器：低延迟垃圾收集器（实验性）

  • ✅ Epsilon垃圾收集器：无操作垃圾收集器

  • ✅ Flight Recorder：Java Flight Recorder开源

  • ✅ TLS 1.3支持：支持最新的TLS协议

  • ✅ 移除Java EE和CORBA模块：精简JDK

  • LTS版本：长期支持版本，适合生产环境

  • 性能提升：ZGC等新特性提升应用性能

  • API增强：HTTP Client等新API提升开发效率

  • 广泛应用：Spring Boot 2.x+、Spring Framework 5.x+都基于Java11

  • 面试必备：Java11特性是面试高频考点

  • LTS含义：Long Term Support，长期支持版本

  • 支持周期：Oracle提供长期支持，适合企业级应用

  • 升级建议：从Java 8升级到Java 11是常见选择

2. 环境搭建

Windows系统

  1. 访问Oracle官网：https://www.oracle.com/java/technologies/javase/jdk11-archive-downloads.html
  2. 或访问Adoptium：https://adoptium.net/
  3. 选择Windows版本下载
  4. 运行安装程序，按照提示完成安装
  5. 记住安装路径（默认：C:\Program Files\Java\jdk-11）

macOS系统

方式1：使用Homebrew（推荐）

brew install openjdk@11

方式2：手动下载

  1. 访问Oracle或Adoptium官网下载macOS版本
  2. 安装后配置环境变量

Linux系统

# Ubuntu/Debian
sudo apt update
sudo apt install openjdk-11-jdk

# CentOS/RHEL
sudo yum install java-11-openjdk-devel

Windows

  1. 右键"此电脑" → "属性" → "高级系统设置" → "环境变量"
  2. 新建系统变量：
    • 变量名：JAVA_HOME
    • 变量值：C:\Program Files\Java\jdk-11
  3. 编辑Path变量，添加：%JAVA_HOME%\bin

macOS/Linux

编辑 ~/.zshrc 或 ~/.bash_profile：

export JAVA_HOME=$(/usr/libexec/java_home -v 11)
export PATH=$JAVA_HOME/bin:$PATH

然后执行：

source ~/.zshrc
java -version
# 应该显示：openjdk version "11" 或 java version "11.0.x"

javac -version
# 应该显示：javac 11.0.x

IntelliJ IDEA

  1. File → Project Structure → Project
  2. 设置Project SDK为JDK 11
  3. 设置Language level为11

Eclipse

  1. Window → Preferences → Java → Installed JREs
  2. 添加JDK 11
  3. 在项目属性中设置Java Build Path使用JDK 11

3. HTTP Client（标准库）

Java 11将HTTP Client从孵化模块（jdk.incubator.http）提升为标准库模块（java.net.http），提供了现代化的HTTP客户端API，替代了传统的HttpURLConnection。

  • 异步支持：支持异步HTTP请求
  • HTTP/2支持：支持HTTP/2协议
  • WebSocket支持：支持WebSocket连接
  • 响应式流：支持响应式流处理
  • 简洁API：API设计简洁易用

同步GET请求

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.io.IOException;

public class HttpClientExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 创建HttpClient
        HttpClient client = HttpClient.newHttpClient();
        
        // 创建HttpRequest
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.github.com/users/octocat"))
            .GET()
            .build();
        
        // 发送请求并获取响应
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        // 输出响应
        System.out.println("Status Code: " + response.statusCode());
        System.out.println("Response Body: " + response.body());
    }
}

异步GET请求

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.util.concurrent.CompletableFuture;

public class AsyncHttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.github.com/users/octocat"))
            .GET()
            .build();
        
        // 异步发送请求
        CompletableFuture<HttpResponse<String>> future = client.sendAsync(
            request,
            HttpResponse.BodyHandlers.ofString()
        );
        
        // 处理响应
        future.thenApply(HttpResponse::body)
              .thenAccept(System.out::println)
              .join();
    }
}

发送JSON数据

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class PostRequestExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        
        // JSON数据
        String json = """
            {
                "name": "John Doe",
                "email": "john@example.com"
            }
            """;
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/users"))
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString(json))
            .build();
        
        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println("Status Code: " + response.statusCode());
        System.out.println("Response: " + response.body());
    }
}

发送表单数据

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

String formData = "name=" + URLEncoder.encode("John Doe", StandardCharsets.UTF_8) +
                  "&email=" + URLEncoder.encode("john@example.com", StandardCharsets.UTF_8);

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Content-Type", "application/x-www-form-urlencoded")
    .POST(BodyPublishers.ofString(formData))
    .build();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .header("Authorization", "Bearer token123")
    .header("User-Agent", "MyApp/1.0")
    .header("Accept", "application/json")
    .GET()
    .build();

处理不同响应类型

// 字符串响应
HttpResponse<String> stringResponse = client.send(
    request,
    HttpResponse.BodyHandlers.ofString()
);

// 字节数组响应
HttpResponse<byte[]> bytesResponse = client.send(
    request,
    HttpResponse.BodyHandlers.ofByteArray()
);

// 文件响应
HttpResponse<Path> fileResponse = client.send(
    request,
    HttpResponse.BodyHandlers.ofFile(Path.of("response.json"))
);

// 流式响应
HttpResponse<InputStream> streamResponse = client.send(
    request,
    HttpResponse.BodyHandlers.ofInputStream()
);
HttpClient client = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(10))
    .build();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .timeout(Duration.ofSeconds(5))
    .GET()
    .build();
HttpClient client = HttpClient.newBuilder()
    .followRedirects(HttpClient.Redirect.ALWAYS) // 总是跟随重定向
    .build();
HttpClient client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_2) // 使用HTTP/2
    .build();

示例1：调用REST API

public class RestApiClient {
    private final HttpClient client;
    private final String baseUrl;
    
    public RestApiClient(String baseUrl) {
        this.client = HttpClient.newHttpClient();
        this.baseUrl = baseUrl;
    }
    
    public String get(String endpoint) throws IOException, InterruptedException {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + endpoint))
            .GET()
            .build();
        
        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );
        
        if (response.statusCode() == 200) {
            return response.body();
        } else {
            throw new IOException("HTTP Error: " + response.statusCode());
        }
    }
    
    public String post(String endpoint, String json) throws IOException, InterruptedException {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + endpoint))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();
        
        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );
        
        return response.body();
    }
}

示例2：并发请求

public class ConcurrentRequests {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        List<String> urls = List.of(
            "https://api.github.com/users/octocat",
            "https://api.github.com/users/torvalds",
            "https://api.github.com/users/gaearon"
        );
        
        List<CompletableFuture<HttpResponse<String>>> futures = urls.stream()
            .map(url -> {
                HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .GET()
                    .build();
                return client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
            })
            .toList();
        
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenRun(() -> {
                futures.forEach(future -> {
                    try {
                        HttpResponse<String> response = future.get();
                        System.out.println("Status: " + response.statusCode());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            })
            .join();
    }
}

4. 局部变量类型推断增强

Java 11增强了Java 10引入的局部变量类型推断（var关键字），现在可以在Lambda表达式的参数中使用var。

Java 10的限制

// Java 10：Lambda参数不能使用var
List<String> list = Arrays.asList("a", "b", "c");
list.forEach((String s) -> System.out.println(s)); // 必须显式声明类型

Java 11的改进

// Java 11：Lambda参数可以使用var
List<String> list = Arrays.asList("a", "b", "c");
list.forEach((var s) -> System.out.println(s)); // 可以使用var

// 多个参数时，要么都用var，要么都不用
Map<String, Integer> map = Map.of("a", 1, "b", 2);
map.forEach((var key, var value) -> System.out.println(key + "=" + value));

注解支持

// 使用var可以在Lambda参数上添加注解
list.forEach((@NonNull var s) -> System.out.println(s));

// 这在显式类型声明时也可以，但var使代码更一致
list.forEach((@NonNull String s) -> System.out.println(s));

与显式类型的一致性

// 使用var使代码风格更一致
var list = Arrays.asList("a", "b", "c");
list.forEach((var s) -> System.out.println(s)); // 都使用var

// 或者都使用显式类型
List<String> list2 = Arrays.asList("a", "b", "c");
list2.forEach((String s) -> System.out.println(s)); // 都使用显式类型
  1. 不能混合使用：要么所有参数都用var，要么都不用
  2. 类型推断：编译器仍然可以推断类型
  3. 可读性：在某些情况下，显式类型可能更清晰
// 错误：不能混合使用var和显式类型
// map.forEach((var key, String value) -> ...); // 编译错误

// 正确：要么都用var
map.forEach((var key, var value) -> ...);

// 正确：要么都用显式类型
map.forEach((String key, Integer value) -> ...);

5. String新增方法

isBlank()方法判断字符串是否为空白（空字符串或只包含空白字符）。

String str1 = "";
String str2 = "   ";
String str3 = "Hello";

System.out.println(str1.isBlank()); // true
System.out.println(str2.isBlank()); // true
System.out.println(str3.isBlank()); // false

// 与isEmpty()的区别
System.out.println(str1.isEmpty()); // true
System.out.println(str2.isEmpty()); // false（包含空格）

lines()方法将字符串按行分割，返回Stream<String>。

String text = """
    Line 1
    Line 2
    Line 3
    """;

// 使用lines()方法
text.lines().forEach(System.out::println);

// 统计行数
long lineCount = text.lines().count();
System.out.println("Line count: " + lineCount);

// 过滤空行
text.lines()
    .filter(line -> !line.isBlank())
    .forEach(System.out::println);

这些方法用于去除字符串首尾的空白字符（包括空格、制表符、换行符等Unicode空白字符）。

String str = "  Hello World  ";

// strip() - 去除首尾空白
System.out.println("'" + str.strip() + "'"); // 'Hello World'

// stripLeading() - 只去除首部空白
System.out.println("'" + str.stripLeading() + "'"); // 'Hello World  '

// stripTrailing() - 只去除尾部空白
System.out.println("'" + str.stripTrailing() + "'"); // '  Hello World'

// 与trim()的区别
String unicodeStr = "\u2000Hello\u2000"; // 包含Unicode空白字符
System.out.println("trim: '" + unicodeStr.trim() + "'"); // 可能不去除
System.out.println("strip: '" + unicodeStr.strip() + "'"); // 去除Unicode空白

repeat(int count)方法重复字符串指定次数。

String str = "Hello";

// 重复3次
String repeated = str.repeat(3);
System.out.println(repeated); // HelloHelloHello

// 重复0次返回空字符串
System.out.println(str.repeat(0)); // ""

// 实际应用：生成分隔线
String separator = "-".repeat(50);
System.out.println(separator);

示例1：文本处理

public class TextProcessor {
    public static List<String> processLines(String text) {
        return text.lines()
            .map(String::strip)
            .filter(line -> !line.isBlank())
            .toList();
    }
    
    public static void main(String[] args) {
        String text = """
            Line 1
              
            Line 2
            Line 3
            """;
        
        List<String> processed = processLines(text);
        processed.forEach(System.out::println);
    }
}

示例2：字符串验证

public class StringValidator {
    public static boolean isValidInput(String input) {
        return input != null && !input.isBlank();
    }
    
    public static String normalize(String input) {
        if (input == null) {
            return "";
        }
        return input.strip();
    }
}

6. Files新增方法

readString(Path path)方法将整个文件读取为字符串。

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public class FilesExample {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("example.txt");
        
        // 读取文件内容
        String content = Files.readString(path);
        System.out.println(content);
        
        // 指定字符编码
        String contentUtf8 = Files.readString(path, StandardCharsets.UTF_8);
        
        // 传统方式对比
        // String content = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
    }
}

writeString(Path path, CharSequence csq)方法将字符串写入文件。

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public class WriteFileExample {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("output.txt");
        String content = "Hello, World!\nThis is a test file.";
        
        // 写入文件（覆盖）
        Files.writeString(path, content);
        
        // 指定字符编码
        Files.writeString(path, content, StandardCharsets.UTF_8);
        
        // 追加模式
        Files.writeString(path, "\nAppended line", 
            StandardOpenOption.APPEND);
        
        // 传统方式对比
        // Files.write(path, content.getBytes(StandardCharsets.UTF_8));
    }
}

示例1：文件读写工具类

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileUtils {
    public static String readFile(String filePath) throws IOException {
        return Files.readString(Path.of(filePath), StandardCharsets.UTF_8);
    }
    
    public static void writeFile(String filePath, String content) throws IOException {
        Files.writeString(Path.of(filePath), content, StandardCharsets.UTF_8);
    }
    
    public static void appendFile(String filePath, String content) throws IOException {
        Files.writeString(
            Path.of(filePath), 
            content, 
            StandardCharsets.UTF_8,
            StandardOpenOption.CREATE,
            StandardOpenOption.APPEND
        );
    }
}

示例2：配置文件处理

public class ConfigReader {
    public static Properties loadConfig(String configPath) throws IOException {
        String content = Files.readString(Path.of(configPath));
        Properties props = new Properties();
        props.load(new StringReader(content));
        return props;
    }
    
    public static void saveConfig(String configPath, Properties props) throws IOException {
        StringWriter writer = new StringWriter();
        props.store(writer, null);
        Files.writeString(Path.of(configPath), writer.toString());
    }
}

7. Optional新增方法

isEmpty()方法判断Optional是否为空（与isPresent()相反）。

import java.util.Optional;

Optional<String> empty = Optional.empty();
Optional<String> present = Optional.of("Hello");

System.out.println(empty.isEmpty()); // true
System.out.println(present.isEmpty()); // false

// 与isPresent()的关系
System.out.println(empty.isPresent()); // false
System.out.println(present.isPresent()); // true

// isEmpty() == !isPresent()
public class OptionalExample {
    public static void processOptional(Optional<String> opt) {
        // 使用isEmpty()使代码更清晰
        if (opt.isEmpty()) {
            System.out.println("Value is empty");
        } else {
            System.out.println("Value: " + opt.get());
        }
        
        // 等价于
        if (!opt.isPresent()) {
            System.out.println("Value is empty");
        } else {
            System.out.println("Value: " + opt.get());
        }
    }
}

8. Collection新增方法

Collection接口的toArray()方法现在接受一个IntFunction参数，使代码更简洁。

import java.util.*;

public class CollectionExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        
        // Java 11之前
        String[] array1 = list.toArray(new String[0]);
        
        // Java 11：使用IntFunction
        String[] array2 = list.toArray(String[]::new);
        
        // 两种方式等价，但新方式更简洁
    }
}

9. ZGC垃圾收集器

ZGC（Z Garbage Collector）是Java 11引入的低延迟垃圾收集器，旨在实现：

  • 低延迟：暂停时间不超过10ms
  • 大堆内存：支持TB级别的堆内存
  • 高吞吐量：对应用吞吐量影响小
# 启用ZGC
java -XX:+UseZGC YourApplication

# 设置堆大小
java -XX:+UseZGC -Xmx4g YourApplication

# 启用GC日志
java -XX:+UseZGC -Xlog:gc YourApplication

  • 并发标记：标记阶段与应用并发执行

  • 并发重定位：重定位阶段与应用并发执行

  • NUMA感知：支持NUMA架构

  • 压缩：自动压缩堆内存

  • ✅ 低延迟要求的应用

  • ✅ 大堆内存应用

  • ✅ 实时系统

  • ❌ 小堆内存应用（可能不如G1）

# 设置并发线程数
java -XX:+UseZGC -XX:ConcGCThreads=4 YourApplication

# 设置最大暂停时间目标
java -XX:+UseZGC -XX:MaxGCPauseMillis=10 YourApplication

10. Epsilon垃圾收集器

Epsilon是一个无操作（no-op）垃圾收集器，只负责内存分配，不进行垃圾回收。主要用于：

  • 性能测试：测试应用的内存分配性能
  • 短生命周期应用：应用运行时间短于GC周期
  • GC性能测试：测试GC本身的开销
# 启用Epsilon GC
java -XX:+UseEpsilonGC YourApplication

# 设置堆大小（必须设置，因为不会回收）
java -XX:+UseEpsilonGC -Xmx1g YourApplication
  • 性能基准测试：测试应用本身性能，排除GC影响
  • 短生命周期应用：如命令行工具
  • 内存泄漏测试：快速发现内存泄漏

⚠️ 警告：Epsilon GC不会回收内存，如果应用分配的内存超过堆大小，会抛出OutOfMemoryError。

11. 其他重要特性

Java Flight Recorder（JFR）是Java 11中开源的性能监控工具。

启用JFR

# 启动时启用JFR
java -XX:+FlightRecorder YourApplication

# 记录到文件
java -XX:StartFlightRecording=duration=60s,filename=recording.jfr YourApplication

使用JFR API

import jdk.jfr.*;

@Label("Custom Event")
public class CustomEvent extends Event {
    @Label("Message")
    public String message;
    
    @Label("Value")
    public int value;
}

// 记录事件
CustomEvent event = new CustomEvent();
event.message = "Hello";
event.value = 42;
event.commit();

Java 11支持TLS 1.3协议，提供更好的安全性和性能。

// TLS 1.3是默认启用的
SSLContext context = SSLContext.getDefault();

Java 11支持Unicode 10.0标准。

Java 11改进了嵌套类的访问控制，允许嵌套类访问彼此的私有成员。

public class Outer {
    private int outerField = 10;
    
    public class Inner {
        private int innerField = 20;
        
        public void accessOuter() {
            // Java 11：可以直接访问外部类的私有成员
            System.out.println(outerField);
        }
    }
    
    public void accessInner() {
        Inner inner = new Inner();
        // Java 11：可以直接访问内部类的私有成员
        System.out.println(inner.innerField);
    }
}

12. 移除和废弃的功能

Java 11移除了以下模块（需要单独下载）：

  • Java EE模块：java.xml.ws、java.xml.bind、java.activation等
  • CORBA模块：java.corba
  • JavaFX：从JDK中移除，需要单独下载

Java EE模块替代

<!-- 使用Maven依赖替代 -->
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.1</version>
</dependency>

JavaFX替代

<dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-controls</artifactId>
    <version>11.0.2</version>
</dependency>
  • Nashorn JavaScript引擎：标记为废弃，计划在后续版本移除
  • Pack200工具：标记为废弃

13. 实际应用案例

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;

public class ApiClient {
    private final HttpClient client;
    private final String baseUrl;
    
    public ApiClient(String baseUrl) {
        this.client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        this.baseUrl = baseUrl;
    }
    
    public CompletableFuture<String> getAsync(String endpoint) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + endpoint))
            .GET()
            .build();
        
        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body);
    }
    
    public String get(String endpoint) throws Exception {
        return getAsync(endpoint).get();
    }
}
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Collectors;

public class FileProcessor {
    public static List<String> readAndFilterLines(String filePath) throws Exception {
        return Files.readString(Path.of(filePath))
            .lines()
            .map(String::strip)
            .filter(line -> !line.isBlank())
            .collect(Collectors.toList());
    }
    
    public static void writeLines(String filePath, List<String> lines) throws Exception {
        String content = String.join("\n", lines);
        Files.writeString(Path.of(filePath), content);
    }
}
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.stream.Collectors;

public class ConfigManager {
    public static Map<String, String> loadConfig(String configPath) throws Exception {
        return Files.readString(Path.of(configPath))
            .lines()
            .map(String::strip)
            .filter(line -> !line.isBlank() && !line.startsWith("#"))
            .map(line -> line.split("=", 2))
            .filter(parts -> parts.length == 2)
            .collect(Collectors.toMap(
                parts -> parts[0].strip(),
                parts -> parts[1].strip()
            ));
    }
}

14. 总结与最佳实践

  • ✅ HTTP Client：现代化的HTTP客户端API
  • ✅ String增强：isBlank()、lines()、strip()、repeat()
  • ✅ Files增强：readString()、writeString()
  • ✅ Optional增强：isEmpty()方法
  • ✅ ZGC：低延迟垃圾收集器
  • ✅ Epsilon GC：无操作垃圾收集器
  • ✅ JFR开源：性能监控工具
  1. HTTP Client：替代HttpURLConnection，使用新的HTTP Client
  2. String方法：使用isBlank()替代trim().isEmpty()
  3. Files方法：使用readString()和writeString()简化文件操作
  4. GC选择：根据应用特点选择合适的垃圾收集器
  5. 模块化：了解移除的模块，使用替代方案

从Java 8迁移到Java 11

  1. 更新依赖：更新第三方库到支持Java 11的版本
  2. 处理移除的模块：添加Java EE模块的Maven依赖
  3. 使用新API：逐步使用新的API替代旧API
  4. 测试GC：测试ZGC等新垃圾收集器
  5. 性能测试：全面测试应用性能

常见问题

Q: Java EE模块找不到？
A: 需要添加Maven依赖，如javax.xml.bind:jaxb-api

Q: 如何选择垃圾收集器？
A:

  • 低延迟应用：ZGC
  • 高吞吐量应用：G1或Parallel GC
  • 测试用途：Epsilon GC

Q: HTTP Client是异步的吗？
A: HTTP Client支持同步和异步两种方式

  1. 实践为主：多写代码练习新特性
  2. 理解原理：理解每个特性的设计思想
  3. 性能测试：测试新特性的性能影响
  4. 关注更新：关注Java新版本的发展

结语

Java 11作为LTS版本，带来了许多重要的新特性和改进。通过本教程的学习，相信你已经掌握了Java 11的核心特性。

记住：

  • 多实践：理论结合实践，多写代码
  • 理解设计：理解每个特性的设计思想
  • 性能优化：合理使用新特性提升性能
  • 持续学习：关注Java语言的发展

祝你学习愉快，编程顺利！ 🚀

本教程由Java突击队学习社区编写，如有问题欢迎反馈。

一个可以快速提升Java技术的神奇网站
Copyright © 2025 Java突击队