JAVA新特性

Java 8（2014，LTS）

里程碑版本，引入函数式编程核心。

1. Lambda 表达式

   简化匿名内部类，支持函数作为参数：

   // 线程任务示例
   new Thread(() -> System.out.println("Lambda执行线程任务")).start();
   

2. Stream API

   集合高效处理（过滤、映射、聚合）：

   List<String> words = Arrays.asList("apple", "cat", "banana", "dog");
   // 筛选长度>3的单词并转为大写
   List<String> result = words.stream()
       .filter(w -> w.length() > 3)
       .map(String::toUpperCase)
       .toList();
   System.out.println(result); // [APPLE, BANANA]
   

3. Optional

   优雅处理null，避免空指针：

   Optional<String> value = Optional.ofNullable(getNullableValue());
   String safeValue = value.orElse("默认值"); // 若为null则返回默认值
   

4. 新日期时间 API（java.time）

   线程安全的日期处理：

   LocalDate birthday = LocalDate.of(1990, 5, 15);
   LocalDate now = LocalDate.now();
   long age = ChronoUnit.YEARS.between(birthday, now); // 计算年龄
   

5. 接口默认方法

   接口可包含实现，兼容旧版本：

   interface MyInterface {
       default void hello() { System.out.println("接口默认方法"); }
   }
   class MyClass implements MyInterface {}
   new MyClass().hello(); // 输出：接口默认方法
   

Java 9（2017）

模块化与 API 增强。

1. 模块系统（JPMS）

   通过module-info.java管理依赖：

   // module-info.java
   module com.example.app {
       requires java.base; // 依赖基础模块
       exports com.example.service; // 暴露可访问的包
   }
   

2. 不可变集合工厂方法

   快速创建不可修改集合：

   List<Integer> nums = List.of(1, 2, 3);
   Set<String> fruits = Set.of("apple", "orange");
   Map<String, Integer> scores = Map.of("Math", 90, "Chinese", 85);
   

3. Stream 增强（takeWhile/dropWhile）

   按条件截取流：

   List<Integer> list = List.of(1, 3, 5, 2, 4);
   // 取连续奇数（遇到2停止）
   list.stream().takeWhile(n -> n % 2 != 0).forEach(System.out::print); // 135
   

Java 10（2018）

1. 局部变量类型推断（var）

   编译器自动推断局部变量类型：

   var list = new ArrayList<String>(); // 推断为ArrayList<String>
   var map = Map.of("a", 1, "b", 2); // 推断为Map<String, Integer>
   

Java 11（2018，LTS）

实用 API 整合。

1. String 新增方法

   String str = "  \nHello\nWorld  ";
   System.out.println(str.isBlank()); // false（非纯空白）
   System.out.println(str.strip()); // "Hello\nWorld"（去除首尾空白）
   str.lines().forEach(System.out::println); // 分行打印：Hello、World
   

2. HttpClient 正式引入

   替代旧版HttpURLConnection：

   HttpClient client = HttpClient.newHttpClient();
   HttpRequest request = HttpRequest.newBuilder()
       .uri(URI.create("https://example.com"))
       .build();
   // 异步请求
   client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
       .thenApply(HttpResponse::body)
       .thenAccept(System.out::println)
       .join();
   

Java 12 - 16（非 LTS，特性逐步转正）

1. Java 14：Switch 表达式正式

   支持箭头语法和返回值：

   int day = 6;
   String type = switch (day) {
       case 1,2,3,4,5 -> "工作日";
       case 6,7 -> "周末";
       default -> throw new IllegalArgumentException("无效日期");
   };
   

2. Java 15：Records（不可变数据类）

   自动生成equals/hashCode/toString：

   record Person(String name, int age) {} // 自动生成getter
   Person p = new Person("张三", 25);
   System.out.println(p.name()); // 张三
   

3. Java 15：文本块（多行字符串）

   用"""定义，保留格式：

   String sql = """
       SELECT id, name 
       FROM user 
       WHERE age > 18
   """;
   

4. Java 16：instanceof 模式匹配

   简化类型转换：

   Object obj = "Java 16";
   if (obj instanceof String s) { // 直接绑定变量s
       System.out.println(s.length()); // 6
   }
   

5. Java 16：密封类（Sealed Classes）

   限制继承范围：

   sealed class Shape permits Circle, Rectangle {} // 仅允许指定子类继承
   final class Circle extends Shape {}
   

Java 17（2021，LTS）

整合前期稳定特性，新增功能。

1. 增强伪随机数生成器

   统一接口 RandomGenerator:

   RandomGenerator rng = RandomGeneratorFactory.of("L128X256MixRandom").create();
   System.out.println(rng.nextInt(100)); // 生成0-99随机数
   

Java 18（2022）

1. UTF-8 作为默认字符集

   跨平台统一编码，无需显式指定：

   // 读写文件默认使用UTF-8
   Files.writeString(Paths.get("test.txt"), "你好，Java 18");
   

Java 19（2022）

1. 虚拟线程（预览，Java 21 正式）

   轻量级线程，支持高并发：

   // 启动虚拟线程（成本远低于平台线程）
   Runnable task = () -> System.out.println("虚拟线程：" + Thread.currentThread().getName());
   Thread.startVirtualThread(task);
   

Java 20（2023）

1. 结构化并发（预览，Java 22 正式）

   简化并发管理：

   // 结构化并发：子任务完成后主线程才继续
   try (var scope = new StructuredTaskScope<Object>()) {
       Future<String> f1 = scope.fork(() -> "任务1");
       Future<String> f2 = scope.fork(() -> "任务2");
       scope.join(); // 等待所有子任务
       System.out.println(f1.result() + " " + f2.result());
   }
   

Java 21（2023，LTS）

当前最新 LTS，正式化核心特性。

1. 虚拟线程（正式）

   // 批量启动虚拟线程
   IntStream.range(0, 1000).forEach(i -> 
       Thread.ofVirtual().start(() -> {
           System.out.println("虚拟线程" + i);
       })
   );
   

2. Record 模式（正式）

   嵌套解构 Record：

   record Point(int x, int y) {}
   record Circle(Point center, double radius) {}
   
   Object obj = new Circle(new Point(5, 10), 3.0);
   if (obj instanceof Circle(Point(int x, int y), double r)) {
       System.out.printf("圆心(%d,%d), 半径%.1f%n", x, y, r); // 圆心(5,10), 半径3.0
   }
   

3. Switch 模式匹配增强

   支持类型判断：

   Object value = 3.14;
   String desc = switch (value) {
       case Integer i -> "整数：" + i;
       case Double d -> "浮点数：" + d;
       default -> "未知类型";
   };
   

Java 22（2024）

1. 结构化并发（正式）

   安全管理多线程任务：

   try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
       Future<Integer> f1 = scope.fork(() -> 10);
       Future<Integer> f2 = scope.fork(() -> 20);
       scope.join(); // 等待所有任务完成
       int sum = f1.result() + f2.result(); // 30
   }
   

Java 23（2024）

1. 字符串模板（正式，JEP 463）

   简化字符串拼接：

   String name = "Java";
   int version = 23;
   String info = STR."版本：\{name} \{version}"; // 版本：Java 23
   

Java 24（2025）

1. 集合增强（toImmutableList 等）

   直接收集为不可变集合：

   List<String> immutable = List.of("a", "b").stream()
       .map(String::toUpperCase)
       .toImmutableList(); // 不可修改的列表 [A, B]
   

持续更新…

---