Java 8-21 新特性

Java 8-21 新特性有哪些？

Java8：

· Lambda 表达式：把函数当参数传。
· 函数式接口：如 Function、Consumer、Supplier。
· Stream API：集合流式处理，filter/map/collect。
· 方法引用：String::length。
· 接口默认方法/静态方法：接口可以写 default 方法。
· 新增Optional类：使用该类可以减少空指针判断。
· 新日期时间 API：LocalDate、LocalDateTime。
· CompletableFuture：异步编程。
· Metaspace 替代永久代。

Java 9

· 模块化系统 JPMS：module-info.java。
· JShell：Java 交互式命令行。
· 集合工厂方法：List.of()、Set.of()、Map.of()。
· 接口私有方法。
· Optional/Stream 增强。

Java 10

· var 局部变量类型推断：var list = new ArrayList();。

Java 11 LTS

· HTTP Client 标准化。
· String 新方法：isBlank()、lines()、strip()、repeat()。
· Files 读写字符串：Files.readString()、writeString()。
· 单文件源码直接运行：java Hello.java。
· ZGC 实验性垃圾回收器。
· 移除 Java EE、CORBA 等。

Java 12-16

· Java 12：switch 表达式预览、Shenandoah GC。
注意：switch 支持字符串是 Java 7 引入的；Java 12 预览的是 switch 表达式，Java 14 转正。
· Java 13：文本块预览 """。
· Java 14：switch 表达式标准、record 预览、instanceof 模式匹配预览、NPE 友好提示。
· Java 15：文本块标准、密封类预览、隐藏类、ZGC/Shenandoah 转正。
· Java 16：record 标准、instanceof 模式匹配标准、Stream.toList()、jpackage 标准。

Java 17 LTS

· 密封类 sealed 标准：限制哪些类能继承。
· switch 模式匹配预览， jdk17开始，switch表达式支持模式匹配
· 强封装 JDK 内部 API。
· 弃用 Security Manager，计划未来移除。
· 伪随机数增强。

Java 18-20

· Java 18：UTF-8 成为默认字符集、简单 Web 服务器。
· Java 19：虚拟线程预览、结构化并发孵化、record 模式预览。
· Java 20：虚拟线程二次预览、结构化并发二次孵化、Scoped Values 孵化。

Java 21 LTS

· 虚拟线程标准：高并发、轻量级线程。
· record 模式标准。
· switch 模式匹配标准。
· 顺序集合 SequencedCollection：统一首尾操作。
· 分代 ZGC。
· 结构化并发、Scoped Values 预览。
· 未命名类、实例 main 方法预览。
· 字符串模板预览。

一句话总结：

Java 8 函数式 + Stream，Java 9 模块化，Java 10 var，Java 11 HTTP Client，Java 17 密封类，Java 21 虚拟线程。

Stream是什么？

Stream 是Java8引入的流式Api，用来对集合、数组等数据做链式、声明式、函数式处理。

特点：

不是集合，不存数据；只是对数据源做一系列操作（中间操作+终止操作），不修改原集合

中间操作：返回新stream，可以链式调用，懒加载（filter、map、sorted、distinct），不执行。

终止操作：触发计算并产生结果，消费掉流，之后不能再用。

惰性求值：没有终端操作，中间操作不会执行。

只能消费一次：终端操作后，这个 Stream 就不能再用了。

通常不修改原数据源。

作用：

主要用于集合数据的过滤、转换、排序、聚合、分组、统计、并行处理。

过滤：filter
转换：map、flatMap
排序去重：sorted、distinct
截断：limit、skip
聚合：count、max、min、reduce；原始类型流可用 sum、average、summaryStatistics。
分组统计：Collectors.groupingBy
分区：Collectors.partitioningBy
匹配：anyMatch、allMatch、noneMatch
查找：findFirst、findAny
并行处理：parallelStream
替代大量 for 循环 + if 判断的样板代码

典型好处：少写 for 循环和临时变量，代码更简洁、可组合。

优点：
1. 声明式、可读性好
  更关注“做什么”，而不是“怎么循环”。
2. 链式调用，易组合
  filter().map().sorted().collect() 很直观。
3. 惰性求值、可短路
  如 findFirst、anyMatch、limit 可以提前结束。
4. 容易并行
  parallelStream() 可以较方便利用多核。
5. 不修改原集合
  通常生成新结果，函数式风格更安全。
  
  缺点：
  1. 调试相对困难
    Lambda 和链式调用堆栈不如普通循环直观。
  2. 性能不一定更好
    小数据量、简单循环时，Stream 可能更慢，有装箱、Lambda、管道开销。
  3. 只能消费一次
    用过后不能重复使用。
  4. 受检异常处理麻烦
    Lambda 里抛 IOException 等受检异常不方便。
  5. 并行流有坑
    共享可变状态、线程安全、阻塞 IO、公共 ForkJoinPool 都可能出问题。
  6. 不适合复杂控制流
    如 break、continue、索引操作、原地修改，普通循环更合适。
    
    常见坑
    1. Stream 只能消费一次
      
      java
```
Stream<String> s = list.stream();
s.count();
s.count(); // 报错：stream has already been operated upon or closed
```
    2. 惰性求值
      
      java
```
list.stream().filter(s -> {
    System.out.println(s);
    return true;
});
// 没有终端操作，不会打印
```
    3. 不要在 Lambda 中修改外部可变变量
      
      java
```
int sum = 0;
list.forEach(s -> sum += s.length()); // 编译错误
```
      应使用 reduce 或 mapToInt().sum()。
    4. 并行流不要修改共享状态
      
      java
```
List<String> result = new ArrayList<>();
list.parallelStream().forEach(result::add); // 线程不安全
```
      应使用 collect。
    5. 小数据量优先普通循环，性能和可读性可能更好。
    Java SE 中的 Stream ：
    - 不存储数据
    - 不修改原数据源
    - 惰性求值
    - 只能消费一次
    - 分中间操作和终端操作
    适合：集合数据处理、函数式风格、并行计算。
    不适合：复杂控制流、小数据量简单循环、阻塞 IO、共享可变状态并行。
    
    一句话：Java SE Stream 是集合的声明式数据处理管道，不是 IO 流。
    
    Stream 主要方法
    
    Stream 操作分为：创建流、中间操作、终止操作
    
    创建流（得到 Stream 对象）：
    - stream()：集合获取串行流
    - parallelStream()：集合获取并行流
    - Stream.of(T... values)：数组 / 多个元素创建流（Stream.of(T... values) 适合对象类型；基本类型数组用 Arrays.stream() 或 IntStream.of()。）
    - Arrays.stream(数组)：数组转流
      
      中间操作（懒加载，返回 Stream，不会执行）：
      - filter()：过滤，保留满足条件元素
      - map()：转换，元素类型映射（最常用）
      - flatMap()：扁平化映射，把集合里面的集合拆开
      - sorted()：排序，可传比较器
      - distinct()：去重（依赖 equals）
      - limit(n)：取前 n 个元素
      - skip(n)：跳过前 n 个元素
      - peek()：查看元素，调试打印（不改变元素）
      记忆：filter 筛、map 转、flatMap 拆、sorted 排序、distinct 去重、limit 截取、skip 跳
      
      终止操作（触发执行，关闭流，返回结果 /void）
      
      返回集合
      - collect(Collectors.toList()) 转 List
      - collect(Collectors.toSet()) 转 Set
      - collect(Collectors.toMap()) 转 Map
      - collect(Collectors.groupingBy()) 分组
      - collect(Collectors.partitioningBy()) 分区（true/false 两组）
      返回数值
      - count()：统计元素数量
      - max()：取最大值
      - min()：取最小值
      - reduce()：归约，聚合计算（累加、拼接）
      遍历 / 判断
      - forEach()：遍历元素
      - anyMatch()：任意一个满足条件返回 true
      - allMatch()：全部满足返回 true
      - noneMatch()：全部不满足返回 true
      - findFirst()：获取第一个元素（返回 Optional）
      - findAny()：获取任意一个（并行流随机）
        
        1.创建流：stream()、parallelStream()、Stream.of()。
        
        2.中间操作是懒加载，返回新 Stream，常用：filter 过滤、map 转换、flatMap 扁平化、sorted 排序、distinct 去重、limit、skip。
        
        3.终止操作触发计算，流只能用一次。常用：collect 收集集合 / 分组、count 计数、max/min 最值、reduce 归约、forEach 遍历；还有 anyMatch/allMatch 判断，findFirst 查找。
      中间操作不会执行，只有调用终止操作的时候，所有中间操作才会一次性执行（懒加载）

posted @ 2026-09-28 09:31 浅笑安然- 阅读(2) 评论(0) 收藏举报

刷新页面返回顶部

浅笑安然-