【Java新版本特性】【v5 - v21】
- 版权声明：本站原创文章，于2026-03-26，由 管理员 发表。
- 转载请注明： 【Java新版本特性】【v5 - v21】 | CodeGarden
# Java版本新特性全解析：从Java 5到Java 21
> Java的发展历程是一部不断演进的技术史诗。从2004年的Java 5到2023年的Java 21，每个版本都在推动着Java生态向前发展。
---
## 前言
Java自1995年诞生以来，经历了多个重要版本。本文将系统梳理从Java 5到Java 21（最新LTS版本）的所有重要新特性，帮助你全面了解Java的演进历程。
**版本分类说明**：
- **LTS（长期支持）版本**：Java 8, 11, 17, 21 - 生产环境推荐使用
- **非LTS版本**：6个月更新周期，适合尝鲜和学习
---
## Java 5（代号：Tiger）- 2004年
Java 5是Java历史上最重要的版本之一，引入了大量革命性特性。
### 核心特性
#### 1. 泛型（Generics）
```java
// 泛型集合
List names = new ArrayList();
names.add("Java");
// 泛型方法
public T findFirst(List list) {
return list.isEmpty() ? null : list.get(0);
}
// 泛型类
class Box {
private T item;
public void set(T item) { this.item = item; }
public T get() { return item; }
}
```
**意义**：编译时类型检查，避免ClassCastException
#### 2. 增强for循环（For-Each Loop）
```java
List languages = Arrays.asList("Java", "Python", "Go");
// 传统方式
for (int i = 0; i < languages.size(); i++) {
System.out.println(languages.get(i));
}
// 增强for循环
for (String lang : languages) {
System.out.println(lang);
}
```
#### 3. 自动装箱/拆箱（Autoboxing/Unboxing）
```java
// 自动装箱
Integer a = 100; // 相当于 Integer.valueOf(100)
// 自动拆箱
int b = a; // 相当于 a.intValue()
// 集合中使用
List numbers = new ArrayList<>();
numbers.add(10); // 自动装箱
int sum = numbers.get(0); // 自动拆箱
```
#### 4. 枚举（Enum）
```java
public enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
// 枚举可以包含方法和字段
private String description;
Day() {
this.description = "Day of week";
}
}
// 使用
Day today = Day.MONDAY;
switch (today) {
case MONDAY:
System.out.println("Start of week");
break;
}
```
#### 5. 可变参数（Varargs）
```java
public void printAll(String... args) {
for (String arg : args) {
System.out.println(arg);
}
}
// 使用
printAll("Hello", "World", "Java");
printAll("Single argument");
printAll(); // 空参数
```
#### 6. 静态导入（Static Import）
```java
import static java.lang.Math.*;
import static java.util.Collections.*;
public class Demo {
public void test() {
double value = sqrt(25.0); // 不需要 Math.sqrt(25.0)
List list = new ArrayList<>();
sort(list); // 不需要 Collections.sort(list)
}
}
```
#### 7. 注解（Annotations）
```java
// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
String value() default "";
int priority() default 0;
}
// 使用注解
public class Demo {
@MyAnnotation(value = "Important method", priority = 1)
public void importantMethod() {
System.out.println("This is important!");
}
}
```
#### 8. 并发包（java.util.concurrent）
```java
// 线程池
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task executed"));
executor.shutdown();
// 并发集合
ConcurrentHashMap map = new ConcurrentHashMap<>();
CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
// 原子类
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();
```
---
## Java 6（代号：Mustang）- 2006年
Java 6主要关注性能优化和API增强。
### 核心特性
#### 1. JDBC 4.0
```java
// 无需显式加载驱动
// Class.forName("com.mysql.jdbc.Driver"); // 不再需要
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydb", "user", "password"
);
```
#### 2. StAX（Streaming API for XML）
```java
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader reader = factory.createXMLStreamReader(new FileInputStream("file.xml"));
while (reader.hasNext()) {
int event = reader.next();
if (event == XMLStreamConstants.START_ELEMENT) {
System.out.println("Element: " + reader.getLocalName());
}
}
```
#### 3. 脚本引擎支持（JSR 223）
```java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("javascript");
engine.eval("print('Hello from JavaScript!')");
Object result = engine.eval("10 + 20");
System.out.println("Result: " + result);
```
#### 4. Compiler API
```java
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable compilationUnits =
fileManager.getJavaFileObjectsFromStrings(Arrays.asList("MyClass.java"));
compiler.getTask(null, fileManager, null, null, null, compilationUnits).call();
```
#### 5. 性能优化
- 改进的锁机制
- 更好的垃圾回收器
- 类数据共享（Class Data Sharing）
---
## Java 7（代号：Dolphin）- 2011年
Java 7引入了许多语法糖和实用特性。
### 核心特性
#### 1. 二进制字面量
```java
int binary = 0b10101010; // 二进制表示
int binary2 = 0B1010_1010; // 支持下划线分隔
int hex = 0x2A; // 十六进制
```
#### 2. 数字字面量中的下划线
```java
long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
double pi = 3.141_592_653_589_793d;
```
#### 3. switch语句支持String
```java
String day = "MONDAY";
switch (day) {
case "MONDAY":
System.out.println("Start of week");
break;
case "FRIDAY":
System.out.println("Almost weekend");
break;
default:
System.out.println("Mid week");
}
```
#### 4. 泛型实例化类型推断（Diamond Operator）
```java
// 旧方式
Map> map = new HashMap>();
// 新方式 - 菱形操作符
Map> map = new HashMap<>();
List list = new ArrayList<>();
```
#### 5. try-with-resources
```java
// 旧方式
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader("file.txt"));
// 读取文件
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 新方式
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
// 读取文件，资源自动关闭
} catch (IOException e) {
e.printStackTrace();
}
// 多个资源
try (FileInputStream fis = new FileInputStream("input.txt");
FileOutputStream fos = new FileOutputStream("output.txt")) {
// 自动关闭两个资源
}
```
#### 6. 捕获多个异常
```java
// 旧方式
try {
// 代码
} catch (IOException e) {
handleException(e);
} catch (SQLException e) {
handleException(e);
}
// 新方式
try {
// 代码
} catch (IOException | SQLException e) {
handleException(e);
}
```
#### 7. NIO.2（New I/O 2）
```java
// Path API
Path path = Paths.get("/home/user/documents/file.txt");
Path absolutePath = path.toAbsolutePath();
Path parent = path.getParent();
Path fileName = path.getFileName();
// 文件操作
Files.createFile(Paths.get("newfile.txt"));
Files.createDirectory(Paths.get("newdir"));
Files.copy(Paths.get("source.txt"), Paths.get("dest.txt"));
Files.delete(Paths.get("file.txt"));
// 文件遍历
Files.walk(Paths.get("/home/user"))
.filter(p -> p.toString().endsWith(".java"))
.forEach(System.out::println);
// 监控文件系统变化
WatchService watcher = FileSystems.getDefault().newWatchService();
Path dir = Paths.get("/home/user/watch");
dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE);
```
#### 8. Fork/Join框架
```java
class Fibonacci extends RecursiveTask {
private final int n;
public Fibonacci(int n) {
this.n = n;
}
@Override
protected Integer compute() {
if (n <= 1) {
return n;
}
Fibonacci f1 = new Fibonacci(n - 1);
f1.fork();
Fibonacci f2 = new Fibonacci(n - 2);
return f2.compute() + f1.join();
}
}
// 使用
ForkJoinPool pool = new ForkJoinPool();
int result = pool.invoke(new Fibonacci(10));
```
---
## Java 8（代号：Spider）- 2014年 ⭐ LTS
Java 8是Java历史上最革命性的版本，引入了函数式编程特性。
### 核心特性
#### 1. Lambda表达式
```java
// 旧方式 - 匿名内部类
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello from anonymous class");
}
};
// 新方式 - Lambda表达式
Runnable r2 = () -> System.out.println("Hello from lambda");
// Lambda表达式语法
// 参数 -> 表达式
// (参数) -> { 语句; }
// (参数1, 参数2) -> { 语句1; 语句2; }
// 函数式接口
@FunctionalInterface
interface MathOperation {
int operate(int a, int b);
}
MathOperation addition = (a, b) -> a + b;
MathOperation multiplication = (a, b) -> a * b;
System.out.println(addition.operate(5, 3)); // 8
```
#### 2. 方法引用
```java
List names = Arrays.asList("Alice", "Bob", "Charlie");
// 静态方法引用
names.forEach(System.out::println);
// 实例方法引用
names.stream()
.map(String::toLowerCase)
.forEach(System.out::println);
// 构造器引用
Supplier> listSupplier = ArrayList::new;
List newList = listSupplier.get();
// 特定对象的方法引用
String prefix = "Hello, ";
Function addPrefix = prefix::concat;
```
#### 3. Stream API
```java
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 过滤和映射
List evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.map(n -> n * 2)
.collect(Collectors.toList());
// 结果: [4, 8, 12, 16, 20]
// 求和
int sum = numbers.stream()
.reduce(0, Integer::sum);
// 分组
Map> grouped = numbers.stream()
.collect(Collectors.groupingBy(n -> n % 2 == 0));
// 查找
Optional first = numbers.stream()
.filter(n -> n > 5)
.findFirst();
// 统计
IntSummaryStatistics stats = numbers.stream()
.mapToInt(Integer::intValue)
.summaryStatistics();
System.out.println("Max: " + stats.getMax());
System.out.println("Average: " + stats.getAverage());
// 并行流
long count = numbers.parallelStream()
.filter(n -> n > 5)
.count();
```
#### 4. Optional类
```java
// 避免NullPointerException
Optional optional = Optional.of("Hello");
// 判断是否存在
if (optional.isPresent()) {
System.out.println(optional.get());
}
// orElse - 提供默认值
String value = optional.orElse("Default Value");
// orElseGet - 延迟提供默认值
String value2 = optional.orElseGet(() -> computeDefault());
// orElseThrow - 为空时抛出异常
String value3 = optional.orElseThrow(() -> new IllegalArgumentException("Value not present"));
// map转换
Optional length = optional.map(String::length);
// flatMap - 避免嵌套Optional
Optional result = optional.flatMap(s -> Optional.of(s.toUpperCase()));
// ifPresent - 存在时执行操作
optional.ifPresent(System.out::println);
// 创建Optional
Optional nonNull = Optional.of("Value");
Optional nullable = Optional.ofNullable(null); // Optional.empty
Optional empty = Optional.empty();
```
#### 5. 新的日期时间API（java.time）
```java
// LocalDate - 日期（年月日）
LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(1990, Month.JANUARY, 15);
LocalDate parsed = LocalDate.parse("2024-03-15");
// LocalTime - 时间（时分秒）
LocalTime now = LocalTime.now();
LocalTime specificTime = LocalTime.of(14, 30, 45);
LocalTime parsedTime = LocalTime.parse("14:30:45");
// LocalDateTime - 日期时间
LocalDateTime dateTime = LocalDateTime.now();
LocalDateTime specificDateTime = LocalDateTime.of(2024, 3, 15, 14, 30);
// ZonedDateTime - 带时区的时间
ZonedDateTime zonedTime = ZonedDateTime.now();
ZonedDateTime parisTime = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
// Duration - 时间段
Duration duration = Duration.between(LocalTime.NOON, LocalTime.now());
// Period - 日期段
Period period = Period.between(birthday, today);
// DateTimeFormatter - 格式化
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = dateTime.format(formatter);
// 日期计算
LocalDate nextWeek = today.plusWeeks(1);
LocalDate previousMonth = today.minusMonths(1);
LocalDate nextYear = today.plusYears(1);
// 日期比较
boolean isBefore = birthday.isBefore(today);
boolean isAfter = today.isAfter(birthday);
// 调整日期
LocalDate firstDayOfMonth = today.withDayOfMonth(1);
LocalDate lastDayOfYear = today.withDayOfYear(365);
```
#### 6. 接口默认方法和静态方法
```java
public interface Vehicle {
// 抽象方法
String start();
// 默认方法
default void stop() {
System.out.println("Vehicle stopped");
}
// 静态方法
static void info() {
System.out.println("This is a vehicle interface");
}
}
// 实现类可以选择是否覆盖默认方法
class Car implements Vehicle {
@Override
public String start() {
return "Car started";
}
// 使用默认的stop方法
}
// 使用
Car car = new Car();
car.start(); // "Car started"
car.stop(); // "Vehicle stopped" - 使用默认方法
Vehicle.info(); // "This is a vehicle interface"
```
#### 7. 重复注解
```java
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Authors {
Author[] value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Repeatable(Authors.class)
public @interface Author {
String name();
String email();
}
@Author(name = "John", email = "john@example.com")
@Author(name = "Jane", email = "jane@example.com")
public class MyBook {
// 类定义
}
// 读取重复注解
Authors authors = MyBook.class.getAnnotation(Authors.class);
for (Author author : authors.value()) {
System.out.println(author.name() + " - " + author.email());
}
```
#### 8. CompletableFuture
```java
// 异步执行
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
// 模拟耗时操作
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return "Hello";
});
// thenApply - 转换结果
CompletableFuture lengthFuture = future.thenApply(String::length);
// thenAccept - 消费结果
CompletableFuture voidFuture = future.thenAccept(System.out::println);
// thenRun - 不依赖结果的后续操作
CompletableFuture runFuture = future.thenRun(() -> System.out.println("Done!"));
// 组合多个Future
CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture future2 = CompletableFuture.supplyAsync(() -> "World");
CompletableFuture combined = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);
// 等待结果
String result = combined.get(); // "Hello World"
// 异常处理
CompletableFuture futureWithException = CompletableFuture.supplyAsync(() -> {
if (Math.random() > 0.5) {
throw new RuntimeException("Something went wrong");
}
return "Success";
}).exceptionally(ex -> {
System.err.println("Exception: " + ex.getMessage());
return "Default Value";
});
```
#### 9. Base64编码
```java
import java.util.Base64;
String original = "Hello, World!";
// 编码
String encoded = Base64.getEncoder().encodeToString(original.getBytes());
// "SGVsbG8sIFdvcmxkIQ=="
// 解码
byte[] decodedBytes = Base64.getDecoder().decode(encoded);
String decoded = new String(decodedBytes);
// "Hello, World!"
// URL编码
String urlEncoded = Base64.getUrlEncoder().withoutPadding()
.encodeToString(original.getBytes());
// MIME编码
String mimeEncoded = Base64.getMimeEncoder()
.encodeToString(original.getBytes());
```
#### 10. 并行数组排序
```java
int[] array = {5, 2, 8, 1, 9, 3};
// 串行排序
Arrays.sort(array);
// 并行排序 - 适合大数组
Arrays.parallelSort(array);
// 并行排序数组的一部分
int[] largeArray = new int[1000000];
Arrays.fill(largeArray, 1);
Arrays.parallelSort(largeArray, 0, 500000); // 只排序前50万个元素
```
---
## Java 9 - 2017年
Java 9是模块化时代的开始，引入了Jigsaw项目。
### 核心特性
#### 1. 模块化系统（Jigsaw）
```java
// 模块描述文件 module-info.java
module com.example.myapp {
requires java.base; // 默认依赖
requires java.logging; // 显式依赖
exports com.example.myapp.api; // 导出包
exports com.example.myapp.service to com.example.other; // 限定导出
uses com.example.myapp.spi.Service; // 使用服务
provides com.example.myapp.spi.Service with com.example.myapp.impl.ServiceImpl; // 提供服务
}
```
**模块化命令**：
```bash
# 编译模块
javac --module-source-path src -d out --module myapp
# 运行模块
java --module-path out --module myapp/com.example.myapp.Main
# 列出模块
java --list-modules
# 描述模块
java --describe-module java.base
```
#### 2. JShell - Java REPL
```bash
# 启动JShell
jshell
# 执行代码
jshell> int x = 10;
x ==> 10
jshell> System.out.println(x * 2);
20
jshell> List list = new ArrayList<>();
list ==> []
jshell> list.add("Java");
$3 ==> true
jshell> list
[$1 -> "Java"]
# 退出
jshell> /exit
```
#### 3. 不可变集合工厂方法
```java
// List.of() - 创建不可变List
List immutableList = List.of("Java", "Python", "Go");
immutableList.add("C++"); // UnsupportedOperationException
// Set.of() - 创建不可变Set
Set immutableSet = Set.of(1, 2, 3, 4, 5);
immutableSet.add(6); // UnsupportedOperationException
// Map.of() - 创建不可变Map（最多10个键值对）
Map map1 = Map.of("Alice", 25, "Bob", 30);
// Map.ofEntries() - 创建不可变Map（无键值对数量限制）
Map map2 = Map.ofEntries(
Map.entry("Alice", 25),
Map.entry("Bob", 30),
Map.entry("Charlie", 35)
);
// 比较旧的Collections.unmodifiableXXX()
List oldWay = Collections.unmodifiableList(new ArrayList<>(Arrays.asList("A", "B")));
List newWay = List.of("A", "B");
```
#### 4. Stream API增强
```java
// takeWhile() - 取满足条件的元素
Stream stream1 = Stream.of(1, 2, 3, 4, 5, 6);
stream1.takeWhile(n -> n < 4).forEach(System.out::println); // 1, 2, 3
// dropWhile() - 丢弃满足条件的元素
Stream stream2 = Stream.of(1, 2, 3, 4, 5, 6);
stream2.dropWhile(n -> n < 4).forEach(System.out::println); // 4, 5, 6
// ofNullable() - 避免NullPointerException
Stream stream3 = Stream.ofNullable("Hello"); // Stream
Stream stream4 = Stream.ofNullable(null); // Empty stream
// iterate() - 新的重载方法
Stream.iterate(0, n -> n < 10, n -> n + 2).forEach(System.out::println); // 0, 2, 4, 6, 8
```
#### 5. Optional类增强
```java
// ifPresentOrElse() - 存在和不存在的处理
Optional optional = Optional.of("Java");
optional.ifPresentOrElse(
value -> System.out.println("Value: " + value),
() -> System.out.println("Value not present")
);
// or() - 提供Supplier作为后备
Optional result = optional.or(() -> Optional.of("Default"));
// stream() - 转换为Stream
optional.stream().forEach(System.out::println);
```
#### 6. 响应式流（Reactive Streams）
```java
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
// 发布者
SubmissionPublisher publisher = new SubmissionPublisher<>();
// 订阅者
Flow.Subscriber subscriber = new Flow.Subscriber<>() {
private Flow.Subscription subscription;
@Override
public void onSubscribe(Flow.Subscription subscription) {
this.subscription = subscription;
subscription.request(1); // 请求一个元素
}
@Override
public void onNext(String item) {
System.out.println("Received: " + item);
subscription.request(1); // 请求下一个元素
}
@Override
public void onError(Throwable throwable) {
System.err.println("Error: " + throwable.getMessage());
}
@Override
public void onComplete() {
System.out.println("Completed");
}
};
// 订阅
publisher.subscribe(subscriber);
// 发布消息
publisher.submit("Hello");
publisher.submit("World");
publisher.close();
```
#### 7. 私有接口方法
```java
public interface MyInterface {
default void method1() {
commonMethod();
System.out.println("Method 1");
}
default void method2() {
commonMethod();
System.out.println("Method 2");
}
// 私有方法 - 只能在接口内部使用
private void commonMethod() {
System.out.println("Common logic");
}
// 私有静态方法
private static void staticHelper() {
System.out.println("Static helper");
}
}
```
#### 8. Process API
```java
// 获取当前进程
ProcessHandle currentProcess = ProcessHandle.current();
System.out.println("PID: " + currentProcess.pid());
System.out.println("Command: " + currentProcess.info().command().orElse("N/A"));
// 获取所有进程
ProcessHandle.allProcesses()
.filter(ph -> ph.info().command().map(c -> c.contains("java")).orElse(false))
.forEach(ph -> System.out.println(ph.pid()));
// 启动新进程
ProcessBuilder pb = new ProcessBuilder("notepad.exe");
Process process = pb.start();
ProcessHandle processHandle = process.toHandle();
processHandle.onExit().thenRun(() -> System.out.println("Process exited"));
```
#### 9. 变量句柄（VarHandle）
```java
import java.lang.invoke.VarHandle;
class MyClass {
private volatile int value = 0;
private static final VarHandle VALUE_HANDLE;
static {
try {
VALUE_HANDLE = MethodHandles.lookup()
.findVarHandle(MyClass.class, "value", int.class);
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
public void setValue(int newValue) {
VALUE_HANDLE.setVolatile(this, newValue);
}
public int getValue() {
return (int) VALUE_HANDLE.getVolatile(this);
}
}
```
#### 10. HTTP/2客户端
```java
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
// HTTP客户端（Java 9时还是incubator）
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/data"))
.GET()
.build();
HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```
---
## Java 10 - 2018年
Java 10是一个小版本，主要聚焦于性能改进和局部变量类型推断。
### 核心特性
#### 1. 局部变量类型推断（var）
```java
// 基本用法
var name = "Java"; // 推断为 String
var age = 25; // 推断为 int
var list = new ArrayList(); // 推断为 ArrayList
var map = Map.of("key", "value"); // 推断为 Map
// 在循环中使用
for (var item : list) {
System.out.println(item);
}
// 在try-with-resources中使用
try (var reader = new BufferedReader(new FileReader("file.txt"))) {
// reader推断为BufferedReader
}
// 在Lambda中作为返回类型
Supplier> supplier = () -> {
var result = new HashMap();
result.put("One", 1);
return result;
};
// 注意事项
var x; // 编译错误 - 必须初始化
var y = null; // 编译错误 - 不能推断为null
var z = {1, 2, 3}; // 编译错误 - 数组初始化器不能使用var
// 局部变量类型推断的限制
// 不能用于类成员变量
// 不能用于方法参数
// 不能用于catch块参数
// 不能用于方法返回类型
```
#### 2. 基于时间的版本控制
Java 10开始采用基于时间的版本号格式：
```
$FEATURE.$INTERIM.$UPDATE.$PATCH
示例：10.0.1.10
- 10：特性版本
- 0：中间版本（非LTS版本为0，LTS版本可能不为0）
- 1：更新版本（每6个月递增）
- 10：补丁版本（紧急安全修复）
```
#### 3. G1垃圾回收器并行Full GC
```java
// 在Java 10之前，G1的Full GC是单线程的
// Java 10改进为并行Full GC，显著提升性能
// 启用G1 GC（JVM参数）
java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 MyApp
```
#### 4. ThreadLocal握手
```java
// Java 10引入了Thread-Local Handshake机制
// 允许在不停止所有线程的情况下对单个线程执行操作
// 示例：在运行时获取线程的局部信息
Thread thread = Thread.currentThread();
// JVM内部可以暂停单个线程进行操作
```
#### 5. 应用程序类数据共享（AppCDS）
```java
// 应用程序类数据共享（Application Class-Data Sharing）
// 允许在多个JVM进程之间共享类元数据
// 步骤1：创建类列表
java -Xshare:dump -XX:DumpLoadedClassList=classes.lst -XX:SharedArchiveFile=app.jsa MyApp
// 步骤2：创建共享归档
java -Xshare:dump -XX:SharedClassListFile=classes.lst -XX:SharedArchiveFile=app.jsa MyApp
// 步骤3：使用共享归档启动应用
java -Xshare:on -XX:SharedArchiveFile=app.jsa MyApp
```
#### 6. Heap上的并行分配
```java
// Java 10优化了堆上的并行分配
// 提高了多线程创建对象时的性能
```
#### 7. Optional类新增方法
```java
// orElseThrow() - 无参数版本
Optional optional = Optional.ofNullable(getValue());
String value = optional.orElseThrow(); // 无参时抛出NoSuchElementException
```
#### 8. 字符串新方法
```java
String text = " Hello World ";
// strip() - 去除首尾空白（Unicode空白）
String stripped = text.strip(); // "Hello World"
// stripLeading() - 去除首部空白
String leading = text.stripLeading(); // "Hello World "
// stripTrailing() - 去除尾部空白
String trailing = text.stripTrailing(); // Hello World"
// isBlank() - 判断是否为空白字符串
boolean blank = " ".isBlank(); // true
// lines() - 按行分割
String multiline = "Line1\nLine2\nLine3";
Stream lines = multiline.lines(); // ["Line1", "Line2", "Line3"]
// repeat() - 重复字符串
String repeated = "Java".repeat(3); // "JavaJavaJava"
```
#### 9. 集合新增方法
```java
// List.copyOf() - 创建不可变副本
List original = Arrays.asList("A", "B", "C");
List copy = List.copyOf(original);
// Set.copyOf()
Set set = Set.copyOf(Arrays.asList(1, 2, 3));
// Map.copyOf()
Map map = Map.copyOf(Map.of("key", 1));
// toArray() - 新的重载方法
List list = Arrays.asList("Java", "Python", "Go");
String[] array1 = list.toArray(String[]::new); // 类型推断
// 收集器改进
List names = Stream.of("Alice", "Bob", "Charlie")
.collect(Collectors.toUnmodifiableList());
```
---
## Java 11（LTS）- 2018年 ⭐
Java 11是继Java 8之后的第二个LTS版本，提供了许多实用改进。
### 核心特性
#### 1. HTTP客户端标准化
```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
// 创建HTTP客户端
HttpClient client = HttpClient.newBuilder()
.version(HttpClient.Version.HTTP_2) // HTTP/2
.connectTimeout(Duration.ofSeconds(10))
.build();
// GET请求
HttpRequest getRequest = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/data"))
.GET()
.build();
HttpResponse getResponse = client.send(getRequest, HttpResponse.BodyHandlers.ofString());
System.out.println("Status: " + getResponse.statusCode());
System.out.println("Body: " + getResponse.body());
// POST请求 - JSON
String jsonBody = "{\"name\":\"John\",\"age\":30}";
HttpRequest postRequest = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/users"))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(jsonBody))
.build();
HttpResponse postResponse = client.send(postRequest, HttpResponse.BodyHandlers.ofString());
// 异步请求
CompletableFuture> asyncResponse = client.sendAsync(
getRequest,
HttpResponse.BodyHandlers.ofString()
);
asyncResponse.thenApply(HttpResponse::body)
.thenAccept(System.out::println)
.join();
// 上传文件
HttpRequest fileUpload = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/upload"))
.POST(HttpRequest.BodyPublishers.ofFile(Paths.get("file.txt")))
.build();
// 响应体处理器
HttpResponse fileResponse = client.send(
getRequest,
HttpResponse.BodyHandlers.ofFile(Paths.get("response.txt"))
);
// 流式响应
HttpResponse> streamResponse = client.send(
getRequest,
HttpResponse.BodyHandlers.ofLines()
);
streamResponse.body().forEach(System.out::println);
```
#### 2. 字符串新方法
```java
// isBlank() - 判断字符串是否为空白
"".isBlank(); // true
" ".isBlank(); // true
" hello ".isBlank(); // false
// strip() - 去除首尾空白
" hello ".strip(); // "hello"
"\u2000hello\u2000".strip(); // "hello" (支持Unicode空白)
// stripLeading() - 去除首部空白
" hello ".stripLeading(); // "hello "
// stripTrailing() - 去除尾部空白
" hello ".stripTrailing(); // " hello"
// lines() - 按行分割
String multiline = "Line1\nLine2\r\nLine3";
Stream lines = multiline.lines();
// ["Line1", "Line2", "Line3"]
// repeat() - 重复字符串
"Java".repeat(3); // "JavaJavaJava"
"Hi".repeat(0); // ""
// stripIndent() - 去除缩进
String indented = """
Line 1
Line 2
Line 3
""";
String unindented = indented.stripIndent();
// translateEscapes() - 转义字符处理
String escaped = "Line1\\nLine2\\tTab";
String translated = escaped.translateEscapes();
// "Line1\nLine2\tTab"
// formatted() - 字符串格式化
String name = "John";
int age = 30;
String result = "Name: %s, Age: %d".formatted(name, age);
// "Name: John, Age: 30"
```
#### 3. 局部变量类型推断增强
```java
// Lambda参数可以使用var
Consumer consumer = (var s) -> System.out.println(s);
// 多个参数都使用var
BiFunction concat = (var s1, var s2) -> s1 + s2;
// 混合使用（不推荐）
BiFunction func = (String s, var i) -> s + i;
// 在注解中使用
Consumer<@NotNull String> annotated = (var s) -> process(s);
```
#### 4. 嵌套类访问控制改进
```java
// Java 11之前，私有嵌套类之间不能互相访问私有成员
// Java 11允许私有嵌套类之间互相访问私有成员
public class Outer {
private class Inner {
private String privateMethod() {
return "Private";
}
private class InnerInner {
public void call() {
Inner inner = new Inner();
// 现在可以访问私有方法
String result = inner.privateMethod(); // Java 11允许
}
}
}
}
```
#### 5. Epsilon垃圾回收器（实验性）
```java
// Epsilon GC是一个无操作的垃圾回收器
// 用于性能测试、短生命周期应用、内存压力测试
// 启动参数
java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC MyApp
// 特点：
// - 不进行任何垃圾回收
// - 当堆满时JVM会退出
// - 适用于已经确定不会产生垃圾的应用
```
#### 6. ZGC垃圾回收器（实验性）
```java
// ZGC（Z Garbage Collector）是一个低延迟的垃圾回收器
// 目标：停顿时间不超过10ms
// 启动参数
java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC MyApp
// 特点：
// - 并发处理
// - 停顿时间极短（通常<10ms）
// - 支持TB级堆内存
// - 适用于对延迟敏感的应用
```
#### 7. Flight Recorder（JFR）
```java
// Java Flight Recorder是一个轻量级的性能分析工具
// 现在包含在OpenJDK中
// 启动应用并开启JFR
java -XX:StartFlightRecording=duration=60s,filename=recording.jfr MyApp
// 程序中控制JFR
import jdk.jfr.*;
import jdk.jfr.consumer.*;
// 创建事件
@Name("com.example.MyEvent")
@Label("My Event")
public class MyEvent extends Event {
@Label("Message")
public String message;
}
// 记录事件
MyEvent event = new MyEvent();
event.message = "Hello";
event.commit();
// 读取记录
RecordingFile recording = new RecordingFile(Paths.get("recording.jfr"));
while (recording.hasMoreEvents()) {
RecordedEvent recordedEvent = recording.readEvent();
System.out.println(recordedEvent);
}
```
#### 8. 单文件源代码程序
```java
// 可以直接运行单个Java文件，无需先编译
// 文件：HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
// 直接运行
java HelloWorld.java
// 支持命令行参数
java HelloWorld.java arg1 arg2
// 支持Shebang（Unix/Linux）
#!/usr/bin/java --source 11
public class Script {
public static void main(String[] args) {
System.out.println("Running as script");
}
}
```
#### 9. 废弃Nashorn JavaScript引擎
```java
// Nashorn JavaScript引擎被标记为废弃
// 建议使用其他JavaScript引擎或GraalVM
// 旧方式（已废弃）
ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
// 替代方案：
// 1. 使用GraalVM的JavaScript引擎
// 2. 使用外部JavaScript引擎
```
#### 10. 集合增强
```java
// Collection.toArray(IntFunction generator)
List list = Arrays.asList("A", "B", "C");
String[] array = list.toArray(String[]::new);
// Predicate.not()
List names = Arrays.asList("Alice", "Bob", "Charlie", null);
// 旧方式
List filtered = names.stream()
.filter(s -> s != null)
.collect(Collectors.toList());
// 新方式
List filtered2 = names.stream()
.filter(Objects::nonNull)
.collect(Collectors.toList());
// 使用Predicate.not()
List longNames = names.stream()
.filter(Objects::nonNull)
.filter(Predicate.not(s -> s.length() < 5))
.collect(Collectors.toList());
```
---
## Java 12 - 2019年
Java 12是一个小版本，引入了一些实用改进。
### 核心特性
#### 1. Shenandoah垃圾回收器（实验性）
```java
// Shenandoah是一个低延迟的垃圾回收器
// 与ZGC类似，但实现方式不同
// 启动参数
java -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC MyApp
// 特点：
// - 并发压缩
// - 停顿时间短（通常<10ms）
// - 支持大堆内存
```
#### 2. switch表达式（预览）
```java
// Java 12引入了switch表达式（预览特性）
// 旧方式
int day = 3;
String dayName;
switch (day) {
case 1:
dayName = "Monday";
break;
case 2:
dayName = "Tuesday";
break;
case 3:
dayName = "Wednesday";
break;
default:
dayName = "Unknown";
}
// 新方式 - switch表达式
String dayName = switch (day) {
case 1 -> "Monday";
case 2 -> "Tuesday";
case 3 -> "Wednesday";
default -> "Unknown";
};
// 多个case合并
String type = switch (day) {
case 1, 2, 3, 4, 5 -> "Weekday";
case 6, 7 -> "Weekend";
default -> "Invalid";
};
// 需要复杂逻辑时使用yield
String message = switch (day) {
case 1 -> {
System.out.println("Start of week");
yield "Monday";
}
case 2, 3, 4, 5 -> {
System.out.println("Mid week");
yield "Weekday";
}
default -> {
System.out.println("Weekend");
yield "Weekend";
}
};
```
#### 3. String新方法
```java
// indent() - 缩进处理
String text = "Hello\nWorld\nJava";
String indented = text.indent(4);
/*
Hello
World
Java
*/
String unindented = text.indent(-2);
// transform() - 字符串转换
String result = "hello".transform(String::toUpperCase); // "HELLO"
// 提取缩进
String withIndent = " Line 1\n Line 2";
String firstLineIndent = withIndent.lines()
.findFirst()
.orElse("")
.indent(0); // 返回第一个非空白行的缩进
```
#### 4. Files.mismatch()
```java
// 比较两个文件内容，返回第一个不匹配字节的位置
Path file1 = Paths.get("file1.txt");
Path file2 = Paths.get("file2.txt");
long mismatchPosition = Files.mismatch(file1, file2);
if (mismatchPosition == -1) {
System.out.println("Files are identical");
} else {
System.out.println("First mismatch at position: " + mismatchPosition);
}
```
#### 5. Compact Number Format
```java
// 紧凑数字格式化
NumberFormat compactFormat = NumberFormat.getCompactNumberInstance(
Locale.US,
NumberFormat.Style.SHORT
);
System.out.println(compactFormat.format(1000)); // "1K"
System.out.println(compactFormat.format(1000000)); // "1M"
System.out.println(compactFormat.format(1500)); // "2K"（向上取整）
// 长格式
NumberFormat longFormat = NumberFormat.getCompactNumberInstance(
Locale.US,
NumberFormat.Style.LONG
);
System.out.println(longFormat.format(1000)); // "1 thousand"
System.out.println(longFormat.format(1000000)); // "1 million"
```
#### 6. Collector.teeing()
```java
// teeing() - 两个收集器的组合
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 同时计算最小值和最大值
MinMax minMax = numbers.stream()
.collect(Collectors.teeing(
Collectors.minBy(Integer::compare),
Collectors.maxBy(Integer::compare),
(min, max) -> new MinMax(min.orElse(null), max.orElse(null))
));
class MinMax {
Integer min;
Integer max;
public MinMax(Integer min, Integer max) {
this.min = min;
this.max = max;
}
@Override
public String toString() {
return "Min: " + min + ", Max: " + max;
}
}
// 同时计算总和和数量
SumCount sumCount = numbers.stream()
.collect(Collectors.teeing(
Collectors.summingInt(Integer::intValue),
Collectors.counting(),
(sum, count) -> new SumCount(sum, count)
));
```
---
## Java 13 - 2019年
Java 13继续改进语言特性和JVM。
### 核心特性
#### 1. 文本块（预览）
```java
// 旧方式 - 字符串拼接需要大量转义
String json = "{\n" +
" \"name\": \"John\",\n" +
" \"age\": 30,\n" +
" \"city\": \"New York\"\n" +
"}";
String html = "\n" +
" \n" +
" My Page
Hello, World!
\n" + " \n" + ""; // 新方式 - 文本块（Java 13预览） String json = """ { "name": "John", "age": 30, "city": "New York" } """; String html = """Hello, World!
"""; // SQL查询 String sql = """ SELECT id, name, email FROM users WHERE status = 'active' ORDER BY name """; // 正则表达式 String regex = """ ^ # 行首 [A-Za-z]+ # 字母 \\s+ # 空白字符 \\d{3,5} # 3-5位数字 $ # 行尾 """; ``` #### 2. switch表达式增强（预览） ```java // Java 13改进了yield关键字的使用 String message = switch (day) { case 1 -> "Monday"; case 2 -> "Tuesday"; case 3 -> { System.out.println("Mid week day"); yield "Wednesday"; // 使用yield返回值 } default -> "Unknown"; }; // 多个值 String type = switch (day) { case 1, 2, 3, 4, 5 -> "Weekday"; case 6, 7 -> "Weekend"; default -> "Invalid"; }; ``` #### 3. Socket API重构 ```java // Java 13重构了底层Socket API // 从java.net.SocketImpl改为NIO实现 // 性能提升，更易于维护 // 使用方式不变 Socket socket = new Socket("example.com", 80); ServerSocket serverSocket = new ServerSocket(8080); ``` #### 4. FileSystems.newFileSystem() ```java // 简化文件系统创建 Path zipPath = Paths.get("archive.zip"); FileSystem fs = FileSystems.newFileSystem(zipPath); // 访问ZIP文件中的内容 Path fileInZip = fs.getPath("file.txt"); Files.readAllLines(fileInZip).forEach(System.out::println); ``` #### 5. 动态CDS归档 ```java // 动态类数据共享归档 // 允许在应用运行时创建CDS归档 // 步骤1：运行应用并记录类 java -Xshare:off -XX:DumpLoadedClassList=classes.lst MyApp // 步骤2：创建CDS归档 java -Xshare:dump -XX:SharedClassListFile=classes.lst -XX:SharedArchiveFile=app.jsa // 步骤3：使用CDS归档运行应用 java -Xshare:on -XX:SharedArchiveFile=app.jsa MyApp // Java 13改进：可以在运行时创建归档 java -XX:ArchiveClassesAtExit=app.jsa MyApp ``` --- ## Java 14 - 2020年 Java 14引入了记录类型和模式匹配等重要特性。 ### 核心特性 #### 1. 记录类型（Records - 预览） ```java // 记录类型 - 不可变的数据载体 public record Person(String name, int age) { // 自动生成构造方法、getter、equals、hashCode、toString } // 使用 Person person = new Person("Alice", 30); System.out.println(person.name()); // Alice System.out.println(person.age()); // 30 System.out.println(person); // Person[name=Alice, age=30] Person person2 = new Person("Alice", 30); System.out.println(person.equals(person2)); // true // 带验证的记录 public record Employee(String name, int age, double salary) { public Employee { if (age < 18) { throw new IllegalArgumentException("Age must be at least 18"); } if (salary < 0) { throw new IllegalArgumentException("Salary cannot be negative"); } } } // 带额外方法的记录 public record Product(String id, String name, double price) { public double getPriceWithTax(double taxRate) { return price * (1 + taxRate); } public String getFormattedPrice() { return String.format("$%.2f", price); } } ``` #### 2. instanceof模式匹配（预览） ```java // 旧方式 Object obj = "Hello World"; if (obj instanceof String) { String str = (String) obj; System.out.println(str.length()); } // 新方式 - 模式匹配 Object obj = "Hello World"; if (obj instanceof String str) { // 自动转换 System.out.println(str.length()); // 直接使用str，无需强转 } // 结合条件 if (obj instanceof String str && str.length() > 5) { System.out.println("Long string: " + str); } // 不支持或运算 // if (obj instanceof String str || obj instanceof Integer i) // 编译错误 ``` #### 3. 有用的NullPointerException ```java // Java 14改进了NullPointerException的错误信息 // 明确指出哪个对象为null // 代码 Person person = new Person(null, 30); System.out.println(person.name().length()); // 旧错误信息 // Exception in thread "main" java.lang.NullPointerException // 新错误信息（Java 14） // Exception in thread "main" java.lang.NullPointerException: // Cannot invoke "String.length()" because the return value of "Person.name()" is null // 链式调用 person.address().city().length(); // 详细错误信息 // Exception in thread "main" java.lang.NullPointerException: // Cannot invoke "String.length()" because "person.address().city()" is null ``` #### 4. switch表达式（正式） ```java // switch表达式在Java 14正式发布 String result = switch (day) { case 1 -> "Monday"; case 2 -> "Tuesday"; case 3 -> "Wednesday"; case 4 -> "Thursday"; case 5 -> "Friday"; case 6 -> "Saturday"; case 7 -> "Sunday"; default -> "Unknown"; }; // 需要复杂逻辑时使用yield String message = switch (day) { case 1 -> { System.out.println("Start of week"); yield "Monday"; } case 2, 3, 4, 5 -> "Weekday"; case 6, 7 -> { System.out.println("Weekend"); yield "Weekend"; } default -> throw new IllegalArgumentException("Invalid day: " + day); }; ``` #### 5. 打包工具（jpackage） ```java // jpackage工具用于打包Java应用为原生安装包 // 支持Windows、macOS、Linux // 命令行使用 jpackage --name MyApp \ --input ./build/libs \ --main-jar myapp.jar \ --main-class com.example.Main \ --type dmg // 输出类型： // Windows: exe, msi // macOS: dmg, pkg // Linux: deb, rpm // 创建可执行文件 jpackage --name MyApp \ --main-jar myapp.jar \ --main-class com.example.Main \ --type app-image // 应用程序图标 jpackage --name MyApp \ --icon myapp.ico \ --main-jar myapp.jar \ --main-class com.example.Main ``` #### 6. JFR事件流 ```java // JFR（Java Flight Recorder）支持持续的事件流 import jdk.jfr.*; import jdk.jfr.consumer.*; // 创建RecordingStream try (RecordingStream rs = new RecordingStream()) { // 监听CPU使用 rs.enable("jdk.CPUUsage").withPeriod(Duration.ofSeconds(1)); // 监听方法进入 rs.enable("jdk.MethodEnter").withPeriod(Duration.ofMillis(100)); // 处理事件 rs.onEvent("jdk.CPUUsage", event -> { System.out.println("CPU Usage: " + event.getFloat("user")); }); rs.start(); } ``` #### 7. G1 NUMA感知内存分配 ```java // G1垃圾回收器现在对NUMA（非统一内存访问）架构更友好 // 多核处理器可以更高效地访问本地内存 // 启用NUMA感知 java -XX:+UseG1GC -XX:+UseNUMA MyApp ``` --- ## Java 15 - 2020年 Java 15进一步完善了预览特性并引入了新特性。 ### 核心特性 #### 1. 文本块（正式） ```java // 文本块在Java 15正式发布 // 三个双引号"""开始和结束 // JSON String json = """ { "name": "John", "age": 30, "address": { "city": "New York", "country": "USA" } } """; // HTML String html = """