目录
前言
Java9
1.Java平台模块系统（模块化）
2.接口中的私有方法
3.集合类的of方法
4.StreamAPI增强 & 钻石表达式扩展至匿名内部类
5.String底层数据结构的改动
Java10
Java11
1.String API增强
2.低延迟垃圾回收器
前言
大家好，好久都没有在CSDN上和大家分享技术了，最近在家闲来无事，就顺手看了一下关于Java9到Java11的内容，那么在这篇文章中就和大家分享一下这其中的一些新特性吧（并不是所有的新特性，我这里只挑选了常用的、可能在开发中接触到的新特性）
Java9
1.Java平台模块系统（模块化）
这个其实就是Java8到Java9最大、最核心的改动了，引入了 module 的概念，用于定义代码的封装和依赖关系，通过在项目中创建 module-info.java 文件来声明 模块名称、导出的包以及所依赖的模块。案例如下：⬇️⬇️⬇️
一个 OrderService 订单业务类，然后通过 module Module.Test.One 将其所在的 package 包导出，然后在 OrderTest 订单测试类中，借助 module Java_9_New_Feature 将需要的模块引入，这样就可以调用 OrderService 类中的方法了。
package com.alibaba.service; public class OrderService { public void success() { System.out.println("订单已支付成功！！！"); } }module Module.Test.One { exports com.alibaba.service; }module Java_9_New_Feature { requires Module.Test.One; }package com.alibaba.one; import com.alibaba.service.OrderService; public class OrderTest { public static void main(String[] args) { OrderService orderService = new OrderService(); orderService.success(); } } // 订单已支付成功！！！2.接口中的私有方法
在Java8的时候，接口中只能定义抽象方法、静态方法、默认方法；
那么来到了Java9，接口中又可以定义私有方法了。案例如下：⬇️⬇️⬇️
package com.alibaba.two; public interface MyInterface { // 抽象方法 String createOrder(); // 静态方法 static void methodOne() { commonAction(); System.out.println("methodOne"); } // 默认方法 default void methodTwo() { commonAction(); System.out.println("methodTwo"); } // 私有方法 private static void commonAction() { System.out.println("common action..."); } }package com.alibaba.two; public class MyInterFaceImpl implements MyInterface { @Override public String createOrder() { String orderNo = "order_no_20260418110422"; System.out.println("订单已创建成功，订单号：" + orderNo); return orderNo; } public static void main(String[] args) { // 调用静态方法，内部调用私有方法 MyInterface.methodOne(); MyInterface mi = new MyInterFaceImpl(); // 调用默认方法，内部调用私有方法 mi.methodTwo(); // 调用抽象方法 mi.createOrder(); } } /* common action... methodOne common action... methodTwo 订单已创建成功，订单号：order_no_20260418110422 */3.集合类的of方法
Java9提供了针对 List、Set、Map 这些集合的静态方法 of、copyOf 用来在现有集合的基础上创建不可变的新集合，好处就是代码更简洁，创建的新集合是不可变的、线程安全的。案例如下：⬇️⬇️⬇️
package com.alibaba.four; import java.util.List; import java.util.Map; import java.util.Set; public class UnModifiableCollectionTest { public static void main(String[] args) { try { List<String> list = List.of("Java", "C", "Python"); list.add("Golang"); } catch (UnsupportedOperationException ex) { ex.printStackTrace(); } try { Set<String> set = Set.of("Java", "C", "Python"); set.add("Golang"); } catch (UnsupportedOperationException ex) { ex.printStackTrace(); } try { Map<Integer, String> map = Map.of(1, "Java", 2, "C", 3, "Python"); map.put(4, "Golang"); } catch (UnsupportedOperationException ex) { ex.printStackTrace(); } } } // 以上代码运行都会报异常UnsupportedOperationException ，因为of方法创建的新集合都是不可变的4.StreamAPI增强 & 钻石表达式扩展至匿名内部类
这里就针对 takeWhile、dropWhile、ofNullable 方法进行举例，注释写的很清楚了。案例如下：⬇️⬇️⬇️
package com.alibaba.five; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; public class StreamAPITest { public static void main(String[] args) { List<Integer> numbers = List.of(1, 3, 6, 2, 4); // 取所有小于5的数字，遇到大于等于5的终止，返回前面部分 List<Integer> res1 = numbers.stream().takeWhile(item -> item < 5).collect(Collectors.toList()); System.out.println(res1); // 丢弃所有小于5的数字，遇到大于等于5的终止，返回剩余部分 List<Integer> res2 = numbers.stream().dropWhile(item -> item < 5).collect(Collectors.toList()); System.out.println(res2); String fullName = "Jack"; String nickname = null; Stream.ofNullable(fullName).forEach(System.out::println); // Jack // 创建一个空流，不会输出NPE Stream<String> stream = Stream.ofNullable(nickname); System.out.println(stream.count()); // 0 // 钻石表达式扩展至匿名内部类当中，下面会报异常，只是为了说明钻石表达式增强了 numbers.sort(new Comparator<>() { @Override public int compare(Integer o1, Integer o2) { return 0; } }); } } /* [1, 3] [6, 2, 4] Jack 0 */5.String底层数据结构的改动
// Java8及以前 public final class String { private final char[] value; // 使用char类型数组存储 private int hash; // 哈希码 } // Java9及以后 public final class String { private final byte[] value; // 使用byte类型数组存储 private final byte coder; // 编码标志 (0: LATIN1 1: UTF16) private int hash; // 哈希码 }那么为什么会这样改动，原因如下：⬇️⬇️⬇️
在Java8中，无论 String 字符串中存了什么内容，都是固定的char 类型（占用2个字节去存储），但是据统计，实际开发中大量的字符串都只包含 ISO-8859-1（LATIN-1）字符集中的字符，这类字符往往仅需1个字节就可以表示，所以对于实现这类字符串来说，有50%的内存空间都被浪费了。。。
所以为了更好的节省内存，同时兼容Unicode编码，Java9及以后针对 String 引入了双重编码机制，就是通过上面的 coder 变量来指示：
- coder = 0（LATIN-1）：
- 当字符串中的所有字符都能用 LATIN-1 编码表示时，就使用这种编码，此时 byte[] value 数组中的每个元素存储一个字符（占用1个字节）。此时与Java8相比，内存空间直接省了一半。
- coder = 1（UTF-16）：
- 当字符串中包含任何 LATIN-1 无法表示的字符时，就退回到 UTF-16 编码，此时 byte[] value 数组中的每两个元素存储一个字符（占用2个字节）。此时与Java8是等效的，没有内存损失。
Java10
直接过了，大家有兴趣了话，可以去了解一下。。。
Java11
1.String API增强
- isBlank()：判断字符串是否为空白（仅包含空白字符，或长度为0）；
- strip()：去除字符串首尾的空白字符；
- stripLeading()：去除字符串开头的空白字符；
- stripTrailing()：去除字符串结尾的空白字符；
- repeat(int count)：将字符串重复 count 次拼接，count 为0时返回空字符串；
- lines()：将字符串按换行符（\n、\r）分割成 Stream 流。
package com.alibaba.three; import java.util.List; import java.util.stream.Collectors; public class StringTest { public static void main(String[] args) { // test isBlank() String s1 = " \t\n "; System.out.println(s1.length()); // 5 System.out.println(s1.isEmpty()); // false System.out.println("".equals(s1)); // false System.out.println(s1.isBlank()); // true System.out.println("---------------------------"); String s2 = ""; System.out.println(s2.length()); // 0 System.out.println(s2.isEmpty()); // true System.out.println("".equals(s2)); // true System.out.println(s2.isBlank()); // true System.out.println("---------------------------"); // test strip() stripLeading() stripTrailing() System.out.println("[" + " \t hello ".strip() + "]"); System.out.println("[" + " \t hello ".stripLeading() + "]"); System.out.println("[" + " \t hello ".stripTrailing() + "]"); System.out.println("---------------------------"); // test repeat(int count) System.out.println("java".repeat(3)); System.out.println("java".repeat(0)); System.out.println("---------------------------"); // test lines() List<String> strList = "java\nc\npython\ngo".lines().collect(Collectors.toList()); for (String str : strList) { System.out.println(str); } } }2.低延迟垃圾回收器
- Epsilon：提供一个无操作的垃圾回收器，仅负责内存分配（当 JVM 堆内存耗尽时直接退出抛出OOM），不执行任何垃圾回收动作（因此也就没有GC停顿）；它的设计初衷是性能基准测试工具和低延迟场景的对照组；此垃圾回收器体积极小。
- ZGC：对比 Epsilon 了话，ZGC 主要用于生产环境的低延迟垃圾回收器，Java团队对 ZGC 的维护和升级非常频繁，未来很有可能是 Java 又一个主流支持的垃圾回收器（目前默认是G1）。
