Java8至今所有版本新特性

Java新特性

Java 8

Lambda 表达式 (Lambda Expressions)

  • Lambda 表达式允许将函数作为方法参数传递,或者将代码块作为数据传递。
  • 它简化了匿名内部类的使用,使代码更加简洁紧凑。

Eg:

// 使用匿名内部类
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from Runnable!");
    }
};

// 使用 Lambda 表达式
Runnable r2 = () -> System.out.println("Hello from Lambda!");

函数式接口 (Functional Interfaces)

  • 函数式接口是只有一个抽象方法的接口。
  • @FunctionalInterface 注解用于声明一个接口为函数式接口,编译器会检查该接口是否符合函数式接口的定义。
  • Lambda 表达式可以赋值给函数式接口类型的变量。
  • Java 8 提供了一些内置的函数式接口,如 Predicate、Consumer、Function 和 Supplier,分别用于判断、消费、转换和提供数据。

Eg:

@FunctionalInterface
interface MyFunction {
    int apply(int x, int y);
}

MyFunction add = (x, y) -> x + y;

Stream API

  • Stream API 提供了一种处理集合数据的新方式,允许以声明式的方式对数据进行操作,例如过滤、排序、映射和归约等。
  • Stream 不是数据结构,它不存储数据,而是对数据源进行操作的管道。
  • Stream 操作可以是中间操作(返回一个新的 Stream)或终端操作(产生一个结果或副作用)。
  • Stream API 支持并行处理,可以充分利用多核 CPU 的优势。

方法引用 (Method References)

  • 方法引用提供了一种更简洁的 Lambda 表达式的写法,可以直接引用已存在的方法。
  • 有四种类型的方法引用:
    • 静态方法引用:ClassName::staticMethod
    • 实例方法引用:instanceReference::instanceMethod
    • 特定类型的任意对象的实例方法引用:ClassName::instanceMethod
    • 构造器引用:ClassName::new

默认方法 (Default Methods)

  • 默认方法允许在接口中添加带有实现的方法,而不会破坏已有的实现类。
  • 使用 default 关键字声明默认方法。
  • 这使得可以在不破坏向后兼容性的情况下向接口添加新的功能。

Eg:

interface MyInterface {
    void myMethod();

    default void defaultMethod() {
        System.out.println("Default method implementation");
    }
}

Optional 类

  • Optional 类用于解决空指针异常(NullPointerException)的问题。
  • 它是一个容器对象,可以包含或不包含一个非空值。
  • 通过使用 Optional 类,可以显式地处理可能为空的值,避免空指针异常的发生。

Eg:

Optional<String> optionalString = Optional.ofNullable("hello");

// 安全地获取 Optional 中的值
optionalString.ifPresent(System.out::println);

Date/Time API (Date/Time API)

  • Java 8 引入了新的日期和时间 API,位于 java.time 包中。
  • 新的 API 提供了更加清晰和易用的日期和时间处理方式,解决了旧的 Date 和 Calendar 类的一些问题。
  • 重要的类包括 LocalDate、LocalTime、LocalDateTime、ZonedDateTime 和 Duration。

JUC

JUC 包自 Java 5 引入以来,一直是 Java 并发编程的核心。Java 8 并没有引入全新的 JUC 组件,而是对现有组件进行了增强。

  • CompletableFuture: 这是 Java 8 中对 Future 的重大改进,它提供了更强大的异步编程能力,可以方便地进行异步任务的组合、异常处理和回调等操作。虽然 CompletableFuture 本身是 Java 8 引入的,但它仍然属于 JUC 包的范畴,是对原有并发机制的增强。

    • 创建异步任务

      CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
          // 这里执行异步任务
          System.out.println("异步任务执行中...");
          try {
              Thread.sleep(1000); // 模拟耗时操作
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("异步任务执行完毕");
      });
      
    • 异步计算结果

      CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
          // 这里执行异步计算
          System.out.println("异步计算执行中...");
          try {
              Thread.sleep(1000); // 模拟耗时操作
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          return 123; // 返回计算结果
      });
      
    • 等待异步任务完成

      CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
          // 异步任务
      });
      future.join(); // 阻塞当前线程直到异步任务完成
      
    • 异步任务完成后执行其他操作

      CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
          // 异步任务
      });
      
      future.thenRun(() -> {
          // 异步任务完成后执行的操作
          System.out.println("异步任务完成后的操作");
      });
      
    • 异步任务的结果处理

      CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
          return 123;
      });
      
      future.thenAccept(result -> {
          // 异步任务的结果处理
          System.out.println("异步任务的结果是: " + result);
      });
      
    • 异常处理

      CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
          throw new RuntimeException("出错了");
      });
      
      future.exceptionally(ex -> {
          System.out.println("捕获到异常: " + ex.getMessage());
          return -1; // 返回默认值
      });
      
    • 组合多个异步任务

      CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
          return "Hello";
      });
      
      CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
          return "World";
      });
      
      CompletableFuture<String> combined = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);
      combined.thenAccept(System.out::println); // 输出 "Hello World"
      
    • 任意一个异步任务完成

      CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
          System.out.println("任务1执行中...");
          try {
              Thread.sleep(2000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("任务1执行完毕");
      });
      
      CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
          System.out.println("任务2执行中...");
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("任务2执行完毕");
      });
      
      CompletableFuture.anyOf(future1, future2).thenRun(() -> {
          System.out.println("任意一个任务执行完毕");
      });
      
  • StampedLock: 这是 Java 8 引入的一种新的锁机制,它提供了比 ReadWriteLock 更高效的读写锁,尤其在读多写少的场景下性能更佳。StampedLock 也是 JUC 包的一部分。

    import java.util.concurrent.locks.StampedLock;
    
    public class StampedLockExample {
        private final StampedLock stampedLock = new StampedLock();
        private int value;
    
        public void increment() {
            long stamp = stampedLock.writeLock();
            try {
                value++;
            } finally {
                stampedLock.unlockWrite(stamp);
            }
        }
    
        public int getValue() {
            long stamp = stampedLock.tryOptimisticRead();
            int current = value;
            if (stampedLock.validate(stamp)) {
                return current;
            } else {
                // 验证失败,需要重新获取读锁
                stamp = stampedLock.readLock();
                try {
                    return value;
                } finally {
                    stampedLock.unlockRead(stamp);
                }
            }
        }
    
        public void updateValue(int newValue) {
            long stamp = stampedLock.writeLock();
            try {
                value = newValue;
            } finally {
                stampedLock.unlockWrite(stamp);
            }
        }
    }
    
  • 增强了 Fork/Join 框架: Java 8 对 Fork/Join 框架进行了改进,使其更好地支持 Lambda 表达式和 Stream API 的并行操作。

    Java 8 对 Fork/Join 框架的主要增强包括对 ForkJoinPool 的改进,使其更好地支持并行流(Parallel Streams)和其他并发任务。此外,还引入了一些新的类和方法来提高性能和灵活性。

    以下是 Java 8 中的一些关键增强点及其示例:

    1. 默认的 Common Pool: 在 Java 7 中,你需要显式地创建一个 ForkJoinPool 实例。而在 Java 8 中,你可以使用静态工厂方法 commonPool() 来获取一个共享的 ForkJoinPool 实例。这个公共池由 JVM 自动管理,并且其大小通常是 CPU 核心数减一。
    2. 工作窃取算法优化: Java 8 对工作窃取算法进行了优化,使得线程之间的任务分配更加高效。
    3. 更好的与 Stream API 集成: Java 8 引入了 Stream API,其中许多操作都可以通过并行流来执行。这些并行流底层依赖于 Fork/Join 框架,因此性能得到了提升。

    Eg:

    import java.util.List;
    import java.util.concurrent.ForkJoinPool;
    
    public class ForkJoinExample {
        public static void main(String[] args) {
            List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    
            // 使用并行流计算总和
            int sumUsingStream = numbers.parallelStream().mapToInt(Integer::intValue).sum();
            System.out.println("Sum using parallel stream: " + sumUsingStream);
    
            // 使用 ForkJoinPool 计算总和
            ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
            SumTask task = new SumTask(numbers);
            int sumUsingForkJoin = forkJoinPool.invoke(task);
            System.out.println("Sum using ForkJoinPool: " + sumUsingForkJoin);
        }
    
        static class SumTask extends java.util.concurrent.RecursiveTask<Integer> {
            private final List<Integer> numbers;
    
            public SumTask(List<Integer> numbers) {
                this.numbers = numbers;
            }
    
            @Override
            protected Integer compute() {
                if (numbers.size() <= 2) {
                    return numbers.stream().mapToInt(Integer::intValue).sum();
                } else {
                    int mid = numbers.size() / 2;
                    SumTask leftTask = new SumTask(numbers.subList(0, mid));
                    SumTask rightTask = new SumTask(numbers.subList(mid, numbers.size()));
    
                    leftTask.fork(); // 异步执行左子任务
                    int rightResult = rightTask.compute(); // 同步执行右子任务
                    int leftResult = leftTask.join(); // 等待左子任务完成
    
                    return leftResult + rightResult;
                }
            }
        }
    }
    

    在这个例子中:

    • 我们首先使用并行流来计算整数列表的总和。
    • 然后我们手动创建了一个继承自 RecursiveTask 的 SumTask 类,并使用 ForkJoinPool.commonPool() 来执行任务。
    • 这两个方法都会利用多核处理器的优势来加速计算过程。
  • LongAdder和DoubleAdder

    • 用于高效地累加数值,特别适用于高并发环境下的计数或统计操作。
    • 相比 AtomicLong 和 AtomicDouble,性能更优。
  • ConcurrentHashMap 改进

    • 优化了分段锁机制,减少了锁的粒度,提升了并发性能。
    • 新增了计算方法(如 computeIfAbsent、compute 和 merge)。
  • ThreadLocalRandom 增强

    • 提高了随机数生成的性能,特别是在多线程环境下。
  • 其他并发工具增强

    • 增强了 CountDownLatch、Semaphore 和 CyclicBarrier 等工具的稳定性和性能。

NIO(New Input/Output)

NIO 自 Java 1.4 引入以来,提供了一种不同于传统 I/O 的 I/O 模型。

  1. Files 类增强

    • 新增了一系列静态方法,用于方便地操作文件和目录,例如:
      • 读取和写入文件内容(Files.readAllLines()、Files.write())。
      • 文件复制、移动和删除(Files.copy()、Files.move()、Files.delete())。
      • 文件属性检查(Files.isReadable()、Files.isExecutable() 等)。
      • 遍历目录(Files.walkFileTree()、Files.list()、Files.walk())。
  2. Path 接口增强

    • 提供了更多操作路径的方法,如路径归一化(normalize)、拼接(resolve)、相对路径计算(relativize)等。

    • 与 Files 类一起,增强了对文件系统操作的便捷性。

  3. Base64 编码支持

    • 引入了新的 Base64 工具类,支持标准 Base64、URL 和 MIME 格式的编码和解码,替代了第三方库的需求。
  4. 异步文件通道(AsynchronousFileChannel)增强

    • 支持更多异步 I/O 操作,如异步读取和写入大文件。

    • 提升了性能和非阻塞操作的支持。

  5. 时间 API 的文件支持

    • 新的时间 API (java.time) 可以与文件属性(如创建时间、最后访问时间等)无缝结合。

Java 9(2017 年 9 月发布)

模块化系统(Project Jigsaw)

Java 9 引入的模块化系统(Project Jigsaw)是 Java 平台自诞生以来最重要的变化之一。它旨在解决大型 Java 应用中长期存在的代码组织和依赖管理问题,提高代码的可维护性、安全性和性能。

模块化系统要解决的问题

在 Java 9 之前,Java 应用主要通过 JAR 文件进行代码打包和分发。这种方式存在一些问题:

  • 类路径(Classpath)的脆弱性: 类路径容易出错,容易出现类冲突(Class Collision)和版本冲突(Version Conflict)。
  • 隐藏的依赖关系: JAR 文件之间没有明确的依赖关系声明,导致依赖管理困难。
  • 大型应用启动缓慢: JVM 需要加载大量的类,即使应用只用到其中一部分,也造成了资源浪费。
  • 安全隐患: 缺乏有效的封装机制,内部类和 API 容易被外部访问,存在安全隐患。
什么是模块?

模块是代码和数据的封装体。一个模块包含以下组成部分:

  • 模块声明(module-info.java): 描述模块的名称、依赖关系、导出的包等信息。
  • 一组包: 包含 Java 类和接口。
  • 资源文件: 例如图片、文本文件等。
模块声明(module-info.java)

module-info.java 文件是模块的核心,它位于模块的根目录下。它使用 module 关键字声明一个模块,并使用以下指令来定义模块的行为:

  • requires: 声明模块依赖的其他模块。
  • exports: 声明模块导出的包,允许其他模块访问这些包中的类型。
  • opens: 声明模块打开的包,允许其他模块通过反射访问这些包中的类型。
  • uses: 声明模块使用某个服务接口。
  • provides ... with: 声明模块提供某个服务接口的实现。

例如:

module com.example.mymodule {
    requires java.base; // 依赖 java.base 模块
    exports com.example.mypackage; // 导出 com.example.mypackage 包
    opens com.example.internal; // 打开 com.example.internal 包以进行反射访问
    uses com.example.MyService; // 使用 MyService 接口
    provides com.example.MyService with com.example.MyServiceImpl; // 提供 MyService 接口的实现
}
模块路径(Modulepath)

Java 9 引入了模块路径(Modulepath)的概念,用于查找模块。与类路径(Classpath)不同,模块路径可以明确地指定模块之间的依赖关系,避免类冲突和版本冲突。

模块的类型

Java 9 中定义了三种类型的模块:

  • 命名模块(Named Modules): 具有明确名称的模块,例如通过 module-info.java 文件定义的模块。
  • 自动模块(Automatic Modules): 传统的 JAR 文件,如果没有 module-info.java 文件,则会被视为自动模块。自动模块会导出其所有包,并隐式地依赖所有其他模块。
  • 未命名模块(Unnamed Module): 类路径上的类属于未命名模块。
模块化的优势
  • 更强的封装性: 模块可以明确地控制哪些包可以被外部访问,提高了代码的安全性。
  • 更清晰的依赖关系: 模块声明明确了模块之间的依赖关系,简化了依赖管理。
  • 更小的运行时 footprint: JVM 只加载应用实际需要的模块,减少了内存占用和启动时间。
  • 更好的可维护性: 模块化的代码结构更清晰,易于理解和维护。
迁移到模块化

将现有的 Java 应用迁移到模块化需要进行一些调整,主要包括:

  • 创建 module-info.java 文件: 为每个模块创建 module-info.java 文件,声明模块的名称、依赖关系等信息。
  • 解决模块之间的依赖冲突: 确保模块之间的依赖关系正确,避免循环依赖和其他冲突。
  • 使用模块路径: 使用模块路径来启动应用,而不是类路径。
总结

Java 9 的模块化系统是一项重要的改进,它改变了 Java 应用的组织和管理方式。虽然迁移到模块化需要一定的成本,但它带来的好处是显著的,尤其对于大型 Java 应用来说,模块化可以提高代码的可维护性、安全性和性能。

JShell(交互式 REPL)

提供一个交互式编程环境,可快速运行 Java 代码片段。

  1. 即时评估表达式:可以直接输入表达式并立即看到结果。

    jshell> 2 + 2
    $1 ==> 4
    
  2. 声明变量和方法:可以在不定义类的情况下声明变量和方法。

    jshell> int x = 10
    x ==> 10
    
    jshell> String greet(String name) {
       ...>     return "Hello, " + name + "!";
       ...> }
    |  created method greet(String)
    
    jshell> greet("World")
    $3 ==> "Hello, World!"
    
  3. 导入包:可以像在标准 Java 程序中一样导入所需的包。

    jshell> import java.util.ArrayList;
    
    jshell> ArrayList<String> list = new ArrayList<>();
    list ==> []
    
    jshell> list.add("Item 1");
    $6 ==> true
    
    jshell> list
    $7 ==> [Item 1]
    
  4. 查看历史记录:可以查看和重新执行之前的命令。

    jshell> /history
       1 : 2 + 2
       2 : int x = 10
       3 : String greet(String name) {
             return "Hello, " + name + "!";
           }
       4 : greet("World")
       5 : import java.util.ArrayList;
       6 : ArrayList<String> list = new ArrayList<>();
       7 : list.add("Item 1");
       8 : list
    
  5. 自动补全和提示:提供代码补全和错误提示,帮助用户更高效地编写代码。

流(Streams)增强

  • takeWhile 和 dropWhile 方法

    • takeWhile(Predicate<? super T> predicate): 返回从流开头开始匹配给定谓词的所有元素,直到遇到第一个不匹配的元素为止。
    • dropWhile(Predicate<? super T> predicate): 返回从第一个不匹配给定谓词的元素开始的所有元素。
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class StreamEnhancementsExample {
        public static void main(String[] args) {
            List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    
            // 使用 takeWhile 获取所有小于等于 5 的数字
            List<Integer> takenNumbers = numbers.stream()
                                               .takeWhile(n -> n <= 5)
                                               .collect(Collectors.toList());
            System.out.println("Taken Numbers: " + takenNumbers); // 输出: Taken Numbers: [1, 2, 3, 4, 5]
    
            // 使用 dropWhile 跳过所有小于等于 5 的数字
            List<Integer> droppedNumbers = numbers.stream()
                                                 .dropWhile(n -> n <= 5)
                                                 .collect(Collectors.toList());
            System.out.println("Dropped Numbers: " + droppedNumbers); // 输出: Dropped Numbers: [6, 7, 8, 9, 10]
        }
    }
    
  • ofNullable方法

    • Stream<T> ofNullable(T t): 如果传入的参数不是 null,则返回一个包含该参数的流;否则返回一个空流。
    import java.util.Optional;
    import java.util.stream.Stream;
    
    public class StreamEnhancementsExample {
        public static void main(String[] args) {
            String nonNullString = "Hello";
            String nullString = null;
    
            // 使用 ofNullable 处理非空字符串
            long countNonNull = Stream.ofNullable(nonNullString).count();
            System.out.println("Count Non-Null: " + countNonNull); // 输出: Count Non-Null: 1
    
            // 使用 ofNullable 处理空字符串
            long countNull = Stream.ofNullable(nullString).count();
            System.out.println("Count Null: " + countNull); // 输出: Count Null: 0
        }
    }
    

多版本 JAR

  • 支持为不同的 Java 版本在同一个 JAR 文件中提供兼容代码。

HTTP/2 客户端(实验性)

  • 全新 HTTP 客户端,支持 HTTP/2 和 WebSocket。

Java 10(2018 年 3 月发布)

局部变量类型推断(var)

这个特性旨在简化代码,减少模板化的代码,并提高开发效率。var 关键字允许开发者声明局部变量时不必指定明确的类型,编译器会根据变量的初始值自动推断出变量的类型。

  1. 声明和初始化

    使用 var 声明的变量必须在声明时立即初始化。

    var name = "LZH";
    
  2. 类型推断

    编译器会根据变量的初始值推断出变量的类型。

    var list = new ArrayList<String>();
    
  3. 类型安全

    使用 var 声明的变量是类型安全的。一旦类型被推断出来,变量的行为就像显式声明的类型一样。

    var map = new HashMap<>();
    map.put("key", "value"); // 正确
    map.put(1, "value");     // 编译错误:incompatible types
    
  4. 限制

    • var 只能用于局部变量,不能用于成员变量、方法参数或返回类型。
    • var 不能用于数组类型推断,数组的类型必须显式声明。
    var arr = new int[] {1, 2, 3}; // 编译错误:需要显式声明数组类型
    int[] arr = new int[] {1, 2, 3}; // 正确
    
  5. 与泛型一起使用

    当与泛型一起使用时,var 可以简化代码,但类型参数仍然需要显式声明。

    var list = new ArrayList<>(); // 编译错误:需要显式声明泛型类型
    var list = new ArrayList<String>(); // 正确
    
  6. 与 lambda 表达式一起使用

    var 可以用于声明 lambda 表达式的参数类型,但通常不需要,因为 lambda 参数的类型通常可以被编译器推断。

    list.forEach(var element -> System.out.println(element)); // 正确,但不必要
    list.forEach(element -> System.out.println(element)); // 更常见
    
  7. 代码可读性

    虽然 var 可以减少代码量,但过度使用可能会降低代码的可读性。因此,建议在变量类型显而易见或者类型很长时使用 var。

GC 改进

  • 引入 G1 并行回收垃圾收集器,优化垃圾回收性能。

Application Class-Data Sharing(AppCDS)

  • 提升应用启动速度,允许共享类数据。

Java11(2018 年 9 月发布,LTS 版本)

HttpClient(正式版)

Java 11 引入了一个新的 HTTP 客户端 API,它完全支持 HTTP/2 协议,解决了之前 HttpURLConnection API 的一些不足,提供了更现代、更高效的 HTTP 通信方式。

HTTP/2 的优势

HTTP/2 是 HTTP 协议的重大改进版本,它带来了许多重要的优势,包括:

  • 多路复用(Multiplexing): 允许在同一个 TCP 连接上同时发送多个请求和响应,消除了 HTTP/1.1 中的队头阻塞问题,提高了并发性能。
  • 头部压缩(Header Compression): 使用 HPACK 压缩算法压缩 HTTP 头部,减少了传输的数据量,提高了传输效率。
  • 二进制分帧(Binary Framing): 使用二进制格式传输数据,而不是 HTTP/1.1 中的文本格式,提高了传输效率和解析效率。
  • 服务器推送(Server Push): 允许服务器主动向客户端推送资源,减少了客户端的请求次数,提高了页面加载速度。
Java 11 的 HTTP 客户端 API

Java 11 引入的新的 HTTP 客户端 API(java.net.http 包)旨在解决 HttpURLConnection 的不足,并充分利用 HTTP/2 的优势。它具有以下特点:

  • 现代化的 API 设计: 使用流畅的 API 风格,易于使用和理解。
  • 完全支持 HTTP/2: 原生支持 HTTP/2 协议,可以充分利用 HTTP/2 的各项特性。
  • 支持异步和同步请求: 既可以发送同步请求并阻塞等待响应,也可以发送异步请求并使用回调函数处理响应。
  • 支持 WebSocket: 支持 WebSocket 协议,可以进行双向通信。
  • 更好的性能: 通过多路复用等技术,提高了 HTTP 通信的性能。
示例

以下是一个简单的示例,演示如何使用 Java 11 的 HTTP 客户端 API 发送一个 GET 请求:

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

public class Http2Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2) // 设置使用 HTTP/2
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://www.google.com")) // 请求地址
                .GET() // 请求方法
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status Code: " + response.statusCode());
        System.out.println("Body: " + response.body());
    }
}

在这个示例中:

  1. 我们使用 HttpClient.newBuilder() 创建了一个 HttpClient 实例,并使用 version(HttpClient.Version.HTTP_2) 方法设置使用 HTTP/2 协议。
  2. 我们使用 HttpRequest.newBuilder() 创建了一个 HttpRequest 实例,并设置了请求地址和请求方法。
  3. 我们使用 client.send() 方法发送请求,并使用 HttpResponse.BodyHandlers.ofString() 方法将响应体解析为字符串。
关键点和注意事项
  • 默认使用 HTTP/2: 如果服务器支持 HTTP/2,并且没有明确指定使用 HTTP/1.1,则客户端会自动使用 HTTP/2。
  • 需要 HTTPS: 大部分浏览器和服务器都要求在 TLS 加密连接(HTTPS)上使用 HTTP/2。
  • 异步请求: 新的 API 提供了 sendAsync() 方法用于发送异步请求,可以提高并发性能。

字符串增强

新增方法:isBlank、lines、strip、repeat 等。

  1. String.repeat()

    这个方法允许你重复一个字符串指定的次数。

    String str = "abc".repeat(3);
    System.out.println(str); // 输出 "abcabcabc"	
    
  2. String.isBlank()

    这个方法检查一个字符串是否为空或者仅包含空白字符(如空格、制表符、换行符等)。

    System.out.println(" ".isBlank()); // 输出 true
    System.out.println("\t".isBlank()); // 输出 true
    System.out.println("\n".isBlank()); // 输出 true
    System.out.println("hello".isBlank()); // 输出 false
    
  3. String.strip()

    • 这个方法删除字符串的前导和尾随空白字符,支持Unicode中的空白字符。

      String str = "   hello, world!   ";
      System.out.println(str.strip()); // 输出 "hello, world!"
      
    • 与 trim 的区别

      1. 字符集支持:
        • String.trim() 方法只识别并去除ASCII字符集中的空白字符,包括空格(' ')、制表符('\t')和换行符('\n')。
        • String.strip() 方法识别并去除更广泛的空白字符,包括所有Unicode空白字符。这意味着strip()可以去除如零宽度空格('\u200B')、不间断空格('\u00A0')等Unicode空白字符。
      2. 性能:
        • 由于 String.strip() 需要检查更多的空白字符,它可能比 String.trim() 在性能上稍微慢一些,尤其是在处理大量数据时。
      3. 兼容性:
        • String.trim() 是Java早期版本就存在的API,兼容性更好。
        • String.strip() 是Java 11中引入的,因此不能在Java 11之前的版本中使用。
  4. String.stripLeading() 和 String.stripTrailing()

    这两个方法分别用于删除字符串的前导空白字符和尾随空白字符。

    System.out.println("   hello, world!   ".stripLeading()); // 输出 "hello, world!   "
    System.out.println("   hello, world!   ".stripTrailing()); // 输出 "   hello, world!"
    
  5. String.lines()

    这个方法将字符串按行分隔,并返回一个 Stream<String>,其中每个元素是字符串中的一行。

    String input = "I am line 1.\nI am line 2. \rI am line 3.";
    Stream<String> lines = input.lines();
    lines.forEach(System.out::println);
    

Lambda 参数的局部变量语法

  • 支持在 Lambda 参数中使用局部变量语法(如 var)。

运行时新特性

  • 运行单文件 Java 源代码,无需显式编译。

Java 12(2019 年 3 月发布)

Switch 表达式(预览)

将 switch 语句改为表达式,支持返回值和更简洁的写法。

传统 switch 语句的不足

在 Java 12 之前,传统的 switch 语句存在一些问题:

  • 容易忘记 break 导致 case 穿透 (fall-through): 如果在 case 分支末尾忘记添加 break 语句,程序会继续执行下一个 case 分支的代码,这很容易导致逻辑错误。
  • 代码冗长: 即使正确使用了 break,大量的 case 和 break 也会使代码显得冗长和难以阅读。
  • 无法返回值: 传统的 switch 语句只能执行语句,不能直接返回值。
Java 12 的 Switch 表达式

Switch 表达式通过以下方式解决了传统 switch 语句的不足:

  • 使用 -> 简化语法: 使用 -> 代替 : 和 break,避免了 case 穿透的风险。
  • 支持返回值: Switch 表达式可以返回值,可以直接赋值给变量。
  • 支持多个 case 值: 可以使用逗号分隔多个 case 值,使代码更加简洁。
Switch 表达式的语法
  1. 使用->

    int dayOfWeek = 2;
    String dayType = switch (dayOfWeek) {
        case 1, 2, 3, 4, 5 -> "Weekday";
        case 6, 7 -> "Weekend";
        default -> "Invalid day";
    };
    System.out.println(dayType); // Output: Weekday
    

    在这个例子中,如果 dayOfWeek 的值为 1 到 5,则返回 “Weekday”;如果值为 6 或 7,则返回 “Weekend”;否则返回 “Invalid day”。

  2. 使用yield返回值(需要使用{})

    如果需要在 case 分支中执行多条语句,可以使用花括号 {} 将这些语句括起来,并使用 yield 关键字返回值。

    int score = 85;
    String grade = switch (score) {
        case 90 -> "A";
        case 80 -> {
            System.out.println("Good job!");
            yield "B";
        }
        case 70 -> "C";
        default -> "D";
    };
    System.out.println(grade); // Output: Good job! B
    

    在这个例子中,当 score 的值为 80 时,会先输出 “Good job!”,然后返回 “B”。

JVM 常量 API

  • 提供对动态生成和操作常量的支持。

垃圾收集优化

  • 引入 Shenandoah GC 和 G1 GC 的改进。

Java 13(2019 年 9 月发布)

文本块(Text Blocks,预览) {#tb}

Java 13 引入了 文本块 (Text Blocks),这是一个重要的语言增强,旨在简化多行字符串字面量的表示,提高代码的可读性和可维护性。文本块通过使用三个双引号 """ 作为定界符,允许直接在代码中编写多行文本,而无需使用大量的转义字符和连接操作符。

  • 语法:

    String html = """
                  <html>
                      <body>
                          <p>Hello, world</p>
                      </body>
                  </html>""";
    
  • 关键特性

    • 保留换行和缩进: 代码中的格式会被保留。
    • 自动去除前导空白: 根据结束定界符的位置,自动去除公共的前导空白。
    • 仍然是 String 对象: 可以像普通字符串一样使用各种 String 方法。
  • 转义字符

    虽然大部分情况下不需要转义,但以下情况仍然需要:

    • 转义 ": 使用 \" 转义双引号。例如 \"\"\" 表示三个连续的双引号。

动态应用类数据共享

  • 改进 Class-Data Sharing(CDS)功能。

Java 14(2020 年 3 月发布)

Switch 表达式(正式版)

  • switch 表达式脱离预览,成为正式功能。

Record(预览)

Record 是一种新的类型,使用 record 关键字定义。它可以自动生成构造函数、访问器方法、equals()、hashCode() 和 toString() 方法,大大减少了样板代码的编写。上面的 Point 类可以使用 Record 简化为:

record Point(int x, int y) {}

简化前:

class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}
  • 关键特性
    • 不可变性: Record 实例创建后不能修改。
    • 自动生成: 自动生成构造函数、getter(方法名与字段名相同)、equals、hashCode 和 toString 方法。
    • 紧凑构造函数: 可以自定义构造函数进行参数验证。
    • 可以实现接口。
    • 隐式 final 类,不能被继承。

NullPointerException 改进

增强 NPE 的错误提示,提供具体的上下文信息。

在 Java 14 之前,当程序抛出 NPE 时,通常只会显示如下信息:

Exception in thread "main" java.lang.NullPointerException
        at com.example.MyClass.myMethod(MyClass.java:10)

在 Java 14 及以后版本,可能会显示类似这样的信息:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.toUpperCase()" because "s" is null
        at com.example.MyClass.main(MyClass.java:6)

垃圾收集器移除

  • 移除了 CMS(Concurrent Mark-Sweep)GC。

Java 15(2020 年 9 月发布)

文本块(正式版)

  • 文本块功能从预览转为正式版。

sealed 类(预览)

密封类允许你指定哪些类可以继承它。它使用 sealed 关键字来声明一个类为密封类,并使用 permits 关键字来指定允许继承它的类。

sealed class Shape permits Circle, Rectangle, Triangle {
    // ...
}

final class Circle extends Shape {
    // ...
}

final class Rectangle extends Shape {
    // ...
}

final class Triangle extends Shape {
    // ...
}

在这个例子中:

  • sealed class Shape 声明 Shape 类为密封类。
  • permits Circle, Rectangle, Triangle 指定只有 Circle、Rectangle 和 Triangle 类可以继承 Shape。

隐藏类(Hidden Classes)

这是一个主要面向框架和库开发者的高级特性,普通应用程序开发者通常不会直接使用。

隐藏类是一种特殊的类,它具有以下特点:
  • 不可见性: 隐藏类对于 Java 的反射 API 是默认不可见的。这意味着它们不能通过通常的反射方式(例如 Class.forName()、Class.getDeclaredMethods() 等)被发现或访问。
  • 不兼容性: 隐藏类与普通的 Java 类不兼容。你不能将一个隐藏类实例转换为任何非隐藏类,反之亦然。
  • 生命周期管理: 隐藏类的生命周期可以由创建它们的框架或库更精细地控制。这意味着框架可以更灵活地卸载或回收不再需要的隐藏类,从而提高内存利用率。
如何创建隐藏类?

隐藏类不是通过通常的 ClassLoader.defineClass() 方法创建的,而是使用 java.lang.invoke.MethodHandles.Lookup 类中的 defineHiddenClass() 方法。这个方法接受字节码数组作为参数,并返回一个 Class 对象,该对象代表一个隐藏类。

以下是一个简单的示例(需要一定的字节码知识):

import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodType;
import java.lang.invoke.MethodHandle;

public class HiddenClassExample {
    public static void main(String[] args) throws Throwable {
        byte[] bytecode = createBytecode(); // 自定义方法生成字节码

        Lookup lookup = MethodHandles.lookup();
        Class<?> hiddenClass = lookup.defineHiddenClass(bytecode, true, MethodHandles.Lookup.ClassOption.NESTMATE).lookupClass();

        // 通过反射调用隐藏类的方法(需要特定的 Lookup 对象)
        MethodHandle constructor = lookup.findConstructor(hiddenClass, MethodType.methodType(void.class));
        Object instance = constructor.invoke();

        MethodHandle helloMethod = lookup.findVirtual(hiddenClass, "hello", MethodType.methodType(void.class));
        helloMethod.invoke(instance);
    }

    // 简化的字节码生成示例 (实际应用中会更复杂)
    private static byte[] createBytecode() {
        // ... (省略字节码生成部分,需要使用 ASM 或其他字节码操作库)
        // 这里只是一个占位符,实际需要生成符合 Java 虚拟机规范的字节码
        return new byte[]{}; // 实际应用中需要替换为有效的字节码
    }
}
总结

隐藏类是 Java 15 引入的一项强大的特性,它为框架和库开发者提供了更大的灵活性和控制力,可以更好地封装内部实现,提高代码的安全性和性能。虽然普通应用程序开发者通常不需要直接使用它,但了解它的概念和作用对于理解一些高级框架的工作原理是有帮助的。


Java 16(2021 年 3 月发布)

Record(正式版)

  • 简化数据类的创建,正式成为标准特性。

instanceof 模式匹配(预览) {#ins}

Java 16 对 instanceof 运算符进行了一项重要的增强,称为 Pattern Matching for instanceof(instanceof 的模式匹配)。这项改进简化了类型检查和类型转换的代码,提高了代码的可读性和简洁性。

  • 优化前

    Object obj = "Hello";
    
    if (obj instanceof String) {
        String str = (String) obj; // 需要显式类型转换
        System.out.println(str.toUpperCase());
    }
    
  • 优化后

    Object obj = "Hello";
    
    if (obj instanceof String str) { // 在 instanceof 中声明变量 str
        System.out.println(str.toUpperCase()); // 直接使用 str,无需再次转换
    }
    

ZGC 增强

  • 支持更大的堆内存,达到 16TB。

向量 API(预览)

  • 引入用于并行计算的向量 API。

Java 17(2021 年 9 月发布,LTS 版本)

在之前版本中预览的新特性就不详细说明了

语言增强:

  • 密封类 (Sealed Classes): 限制类的继承,增强封装性。例如 sealed interface Shape permits Circle, Rectangle { ... } 表示 Shape 接口只能被 Circle 和 Rectangle 实现。
  • instanceof 模式匹配: 类型检查和转换更简洁。例如 if (obj instanceof String s) { ... } 直接声明 s 并转换类型。
  • switch 表达式模式匹配: switch 支持类型和 null 匹配。例如 switch (obj) { case String s -> ...; case null -> ...; }
  • 文本块 (Text Blocks): 多行字符串更易写。用 """ 包裹。

性能: ZGC 垃圾回收器成为正式特性并得到改进,降低延迟。

平台: 更好支持 macOS AArch64(Apple Silicon)。

其他: 增强伪随机数生成器,移除 Applet API,恢复严格浮点语义。


Java 18(2022 年 3 月发布)

**默认字符集设为 UTF-8

统一默认字符集为 UTF-8,提升跨平台一致性。

简易 Web 服务器

简易 Web 服务器(Simple Web Server)。这是一个非常实用的新特性,尤其对于快速原型开发、测试和教学场景非常有用。它允许开发者通过简单的命令行指令快速启动一个静态文件服务器,而无需依赖 Tomcat、Jetty 或 Nginx 等传统的 Web 服务器。

主要特性
  • 易用性: 无需额外安装和配置,只需 JDK 即可使用。通过简单的命令行指令即可启动。
  • 轻量级: 专注于提供静态文件服务,不包含复杂的 Web 应用功能,因此非常轻量级。
  • 仅支持 HTTP/1.1: 目前只支持 HTTP/1.1 协议,不支持 HTTP/2。
  • 仅支持 GET 和 HEAD 请求: 仅支持这两种基本的 HTTP 请求方法。
  • 不支持 HTTPS: 出于简单性和安全考虑,目前不支持 HTTPS。
  • 不提供安全功能: 不提供身份验证、访问控制或加密等安全功能。
  • 不适用于生产环境: 定位是用于开发、测试和教学,不适合在生产环境中使用。****
常用命令:
  • jwebserver -p <端口号>:指定端口。
  • jwebserver -d <目录>:指定根目录。

@snippet 标签

在 Javadoc 中引入 @snippet 标签,简化代码示例的嵌入。

/**
 * 这是一个使用 @snippet 标签的示例。
 *
 * @snippet {@java
 * public class HelloWorld {
 *     public static void main(String[] args) {
 *         System.out.println("Hello, World!");
 *     }
 * }
 * }
 */
public class MyClass {
    // ...
}

/**
 * 这是一个从外部文件引入代码片段的示例。
 *
 * @snippet file="path/to/HelloWorld.java" region="main"
 */
public class MyClass {
    // ...
}

/**
 * 这是一个使用 include 和 exclude 属性的示例。
 *
 * @snippet file="path/to/MyCode.java" include="method1, method2" exclude="method2.inner"
 */
public class MyClass {
    // ...
}

/**
 * 这是一个使用 replace 属性的示例。
 *
 * @snippet file="path/to/MyConstants.java" replace="MAX_VALUE=1000"
 */
public class MyClass {
    // ...
}

其中:

  • file 属性指定外部文件的路径。可以是相对路径或绝对路径。
  • region 属性指定代码片段中的一个区域。需要在外部文件中使用 // region <区域名> 和 // end region 标记区域。
  • 可以使用 include 和 exclude 属性更精细地控制包含哪些代码区域。
  • 可以使用 replace 属性替换代码片段中的文本。这对于修改代码片段中的一些变量名或常量值非常有用。

Java 19(2022 年 9 月发布)

虚拟线程(预览)

虚拟线程是 Java 并发编程的一个重要革新,旨在简化高并发应用程序的开发,并提高其性能和吞吐量。

虚拟线程是一种轻量级的线程,由 JVM 管理,而不是由操作系统直接管理。它可以大幅度减少线程创建和管理的开销,并提高并发性能。

虚拟线程的关键特性
  • 轻量级: 虚拟线程的创建和销毁开销非常小,可以轻松创建数百万个虚拟线程。
  • 用户态线程: 虚拟线程在用户态执行,不需要操作系统内核的参与,减少了上下文切换的开销。
  • M:N 调度: 多个虚拟线程可以映射到少量的平台线程(即传统的操作系统线程)上运行。JVM 负责将虚拟线程调度到平台线程上执行。
  • 阻塞操作友好: 当虚拟线程执行阻塞操作时,JVM 会将其从当前平台线程卸载,并调度其他虚拟线程执行。当阻塞操作完成后,JVM 会将虚拟线程重新调度到平台线程上继续执行。这种方式可以有效地利用 CPU 资源,提高吞吐量。
虚拟线程与平台线程的比较
特性虚拟线程平台线程
管理者JVM操作系统
创建/销毁的开销非常小较大
数量可创建百万个受操作系统限制
调度JVM调度到平台线程操作系统调度
阻塞操作自动卸载和重新调度,不阻塞平台线程阻塞平台线程
使用场景高并发、I/O密集型应用CPU密集型应用,需要长时间运行的任务
如何使用虚拟线程

Java 19 提供了新的 API 来创建和管理虚拟线程:

  • Thread.startVirtualThread(Runnable task):创建一个并启动一个新的虚拟线程。
  • Thread.ofVirtual().start(Runnable task):使用构建器模式创建并启动虚拟线程。
import java.time.Duration;

public class VirtualThreadExample {

    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();

        // 创建并启动 10000 个虚拟线程
        for (int i = 0; i < 10000; i++) {
            Thread.startVirtualThread(() -> {
                try {
                    Thread.sleep(Duration.ofSeconds(1)); // 模拟 I/O 阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //System.out.println("Virtual Thread " + Thread.currentThread().getId() + " finished.");
            });
        }

        Thread.sleep(Duration.ofSeconds(2)); // 等待所有虚拟线程执行完成
        long end = System.currentTimeMillis();

        System.out.println("执行耗时:" + (end - start) + "ms");
    }
}
注意事项
  • 虚拟线程主要适用于 I/O 密集型应用,对于 CPU 密集型应用,使用虚拟线程并不能带来明显的性能提升。
  • 虚拟线程目前仍然是预览特性,需要在编译和运行时启用预览特性:--enable-preview。
  • 虚拟线程的调试和监控可能与传统线程有所不同,需要使用新的工具和技术。
总结

虚拟线程是 Java 并发编程的一个重要进步,它简化了高并发应用程序的开发,并提高了其性能和吞吐量。通过合理地使用虚拟线程,可以更好地利用系统资源,并构建更高效的应用程序。Java 21 将虚拟线程正式发布,意味着可以更放心地在生产环境中使用。

结构化并发(预览)

结构化并发是 Java 并发编程的一个新特性,旨在简化多线程编程,提高代码的可读性、可维护性和可靠性。它目前处于孵化阶段,意味着 API 可能会在未来的版本中发生变化。

传统并发的挑战

在传统的 Java 并发编程中,我们使用 Thread、ExecutorService 等工具来创建和管理线程。然而,这种方式存在一些挑战:

  • 错误处理复杂: 当多个线程并发执行时,如果其中一个线程发生异常,如何正确处理并传播异常变得复杂。
  • 取消任务困难: 如何安全地取消正在执行的多个线程任务是一个难题。
  • 代码难以理解和维护: 并发代码通常比顺序代码更难理解和维护,尤其是在处理复杂的并发逻辑时。
结构化并发的目标

结构化并发旨在解决以上挑战,它将并发任务视为一个整体,并提供了一种结构化的方式来管理这些任务。其核心思想是将并发任务的生命周期限制在一个明确的作用域内,使得并发代码更易于理解、调试和维护。

核心概念:StructuredTaskScope

结构化并发的核心 API 是 StructuredTaskScope。它可以创建一个作用域,用于管理一组并发任务。

StructuredTaskScope 的主要功能

  • 创建并发任务: 可以使用 fork() 方法在作用域内创建并启动并发任务。
  • 等待所有任务完成: 可以使用 join() 方法等待作用域内的所有任务完成。
  • 处理异常: 如果任何一个任务抛出异常,join() 方法会抛出该异常。
  • 关闭作用域: 可以使用 close() 方法关闭作用域,并取消所有未完成的任务。
代码示例
import java.time.Duration;
import java.util.concurrent.StructuredTaskScope;

public class StructuredConcurrencyExample {

    public static void main(String[] args) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            StructuredTaskScope.Subtask<String> user = scope.fork(() -> findUser());
            StructuredTaskScope.Subtask<Integer> order = scope.fork(() -> fetchOrder());

            scope.join(); // 等待所有任务完成

            String theUser = user.get();
            Integer theOrder = order.get();

            System.out.println("User: " + theUser + ", Order: " + theOrder);
        } catch (Exception e) {
            System.err.println("处理异常: " + e.getMessage());
        }
    }

    static String findUser() throws InterruptedException {
        Thread.sleep(Duration.ofMillis(200));
        return "Alice";
    }

    static Integer fetchOrder() throws InterruptedException {
        Thread.sleep(Duration.ofMillis(100));
        return 123;
    }
}

代码解释

  1. 使用 try-with-resources 语句创建 StructuredTaskScope.ShutdownOnFailure 实例。ShutdownOnFailure 策略表示,如果任何一个子任务失败,则关闭整个作用域并取消所有其他未完成的任务。
  2. 使用 fork() 方法创建并启动两个并发任务:findUser() 和 fetchOrder()。
  3. 使用 join() 方法等待所有任务完成。如果任何一个任务抛出异常,join() 方法会抛出该异常,并自动关闭作用域。
  4. 使用 get() 方法获取任务的结果。
其他 StructuredTaskScope 策略

除了 ShutdownOnFailure 策略,StructuredTaskScope 还提供了其他策略:

  • StructuredTaskScope.ShutdownOnSuccess():当所有任务成功完成时关闭作用域。
  • 自定义策略:可以实现 StructuredTaskScope.Subtask.CompletionHandler 接口来定义自定义的完成处理逻辑。
结构化并发的优势
  • 更清晰的代码结构: 将并发任务限制在明确的作用域内,使代码更易于理解和维护。
  • 更简单的错误处理: 简化了并发任务的异常处理,提高了代码的可靠性。
  • 更方便的任务取消: 可以方便地取消一组并发任务。
与虚拟线程的结合

结构化并发通常与虚拟线程一起使用,以充分发挥其优势。虚拟线程可以大幅度减少线程创建和管理的开销,而结构化并发可以更好地管理这些虚拟线程。

外部函数与内存 API(预览)

FFM API 是 Java 平台的重要发展方向,它提供了一种更现代、更安全、更高效的方式来与本地代码和非堆内存进行交互。虽然目前仍是预览特性,但它代表了 Java 平台在互操作性方面的重要进步。通过使用 FFM API,开发者可以更好地利用现有的本地库和硬件资源,构建更强大的应用程序。需要注意的是,由于是预览特性,API 可能会在未来的版本中发生变化,使用时需要关注官方文档的更新。


Java 20(2023 年 3 月发布)

模式匹配 for switch(第二次预览)

Java 20 对 switch 的增强,主要指的是模式匹配(Pattern Matching)在 switch 表达式和语句中的应用。

String formatted = switch (obj) {
    case Integer i -> String.format("int %d", i);
    case String s -> String.format("String %s", s);
    case null -> "null"; // 处理 null 值
    default -> "other";
};

switch (obj) {
    case Integer i -> {
        System.out.println("int " + i);
    }
    case String s -> {
        System.out.println("String " + s);
    }
    case null -> {
        System.out.println("null");
    }
    default -> {
        System.out.println("other");
    }
}
类型模式和保护模式
  • 类型模式: 使用 case Type variable -> 的形式进行类型匹配。例如 case Integer i -> 匹配 Integer 类型的对象,并将对象赋值给变量 i。
  • 保护模式: 在类型模式后添加 when 子句,用于添加额外的布尔条件。
switch (obj) {
    case Integer i when i > 0 -> System.out.println("positive int " + i);
    case Integer i -> System.out.println("non-positive int " + i);
    default -> System.out.println("other");
}
模式支配(Pattern Dominance)

模式支配是指在一个 switch 块中,如果一个模式比另一个模式更具体,则更具体的模式应该放在前面。例如:

switch (obj) {
    case String s -> System.out.println("String");
    case CharSequence cs -> System.out.println("CharSequence"); // 错误:此 case 被 String case 支配
    default -> System.out.println("other");
}
密封类和接口的模式匹配

模式匹配 switch 与密封类和接口(Sealed Classes and Interfaces)结合使用,可以提供更强大的功能。密封类和接口限制了哪些类可以实现或继承它们,从而使得编译器可以进行更严格的类型检查,并推断出所有可能的类型。

sealed interface Shape permits Circle, Rectangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double length, double width) implements Shape {}

double getArea(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.length() * r.width();
    }; // 由于 Shape 是密封接口,这里不需要 default case
}

记录模式(预览)

虽然记录类在 Java 14 就已引入,但记录模式的出现进一步增强了记录类的使用,使得从记录类中提取数据变得更加简洁和方便。

记录模式的用法

记录模式可以用于以下场景:

  1. switch 表达式和语句: 与类型模式结合使用,进行复杂的类型和数据匹配。
  2. instanceof 运算符: 简化类型检查和数据提取。
  3. 增强 for 循环: 直接在循环头解构记录类实例。
record Point(int x, int y) {}
record ColoredPoint(Point p, String color) {}


// switch 表达式和语句
Object obj = new ColoredPoint(new Point(1, 2), "red");

String result = switch (obj) {
    case ColoredPoint(Point(int x, int y), String color) ->
        "Colored point at (" + x + ", " + y + ") with color " + color;
    case Point(int x, int y) -> "Point at (" + x + ", " + y + ")";
    default -> "Not a point";
};

System.out.println(result); // 输出:Colored point at (1, 2) with color red

switch (obj) {
    case ColoredPoint(Point(var x, var y), var color) -> // 使用 var 推断类型
        System.out.println("Colored point at (" + x + ", " + y + ") with color " + color);
    case Point(var x, var y) -> System.out.println("Point at (" + x + ", " + y + ")");
    default -> System.out.println("Not a point");
}


// instanceof 运算符
Object obj = new Point(3, 4);

if (obj instanceof Point(int x, int y)) {
    System.out.println("Point at (" + x + ", " + y + ")");
}

// 增强 for 循环
import java.util.List;

public class RecordPatternForLoop {
    record Point(int x, int y) {}

    public static void main(String[] args) {
        List<Point> points = List.of(new Point(1, 2), new Point(3, 4), new Point(5, 6));

        for (Point(int x, int y) : points) {
            System.out.println("Point at (" + x + ", " + y + ")");
        }
    }
}

外部函数与内存 API(第二次预览)

  • 提供更加稳定和功能丰富的外部函数调用能力。

Java 21(2023 年 9 月发布,LTS 版本)

字符串模板(预览)

Java 21 引入的字符串模板(String Templates),这是一项旨在简化字符串创建和操作的新特性。它允许你将表达式嵌入到字符串字面量中,从而避免了繁琐的字符串拼接和格式化操作。字符串模板在 Java 21 中是预览特性(JEP 430),意味着它可能会在未来的版本中进行修改。

背景:传统字符串操作的不足

在 Java 中,我们通常使用以下方式来创建和操作字符串:

  • 字符串拼接(+ 运算符): 简单直接,但当拼接的字符串较多或包含表达式时,代码可读性较差。
  • String.format() 方法: 功能强大,可以进行复杂的格式化,但语法相对繁琐。
String name = "Alice";
int age = 30;

// 字符串拼接
String message1 = "Hello, " + name + "! You are " + age + " years old.";

// String.format()
String message2 = String.format("Hello, %s! You are %d years old.", name, age);

这些方式在处理包含大量变量和表达式的复杂字符串时,代码会变得难以阅读和维护。

字符串模板的目标

字符串模板旨在提供一种更简洁、更直观的方式来创建和操作字符串,其主要目标包括:

  • 提高代码可读性: 通过将表达式直接嵌入到字符串字面量中,使代码更易于理解。
  • 简化字符串操作: 减少了字符串拼接和格式化操作的复杂性。
  • 提高性能: 在某些情况下,字符串模板可以比传统的字符串操作方式更高效。
字符串模板的用法

字符串模板使用 ${} 或 \{} 来嵌入表达式。在 Java 21 中,主要通过 STR 模板处理器来使用。

// 在这个例子中,${name} 和 ${age} 分别被替换为变量 name 和 age 的值。
String name = "Bob";
int age = 25;

String message = STR."Hello, ${name}! You are ${age} years old."; // 使用 STR 处理器

System.out.println(message); // 输出:Hello, Bob! You are 25 years old.


// 字符串模板可以嵌入更复杂的表达式,例如方法调用、算术运算等。
int x = 10;
int y = 20;

String result = STR."The sum of ${x} and ${y} is ${x + y}.";

System.out.println(result); // 输出:The sum of 10 and 20 is 30.

String greeting = STR."Hello, ${name.toUpperCase()}!"; // 调用 toUpperCase() 方法

System.out.println(greeting); // 输出:Hello, BOB!


// 字符串模板也支持多行字符串。
String html = STR."""
        <html>
            <body>
                <h1>Hello, ${name}!</h1>
            </body>
        </html>
        """;

System.out.println(html);


// 如果需要在字符串模板中包含 ${} 或 \{} 字符本身,可以使用反斜杠进行转义。
String literal = STR."This is a literal \${not_a_variable}.";

System.out.println(literal); // 输出:This is a literal ${not_a_variable}.

在这里插入图片描述

虚拟线程(正式版)

  • 虚拟线程功能正式发布,为并发编程带来极大便利。

模式匹配 for switch(正式版)

  • switch 中的模式匹配成为正式功能。

记录模式(正式版)

  • 记录模式正式发布,简化对 Record 类型的操作。

分代 ZGC

  • 引入分代垃圾收集机制,优化内存管理性能。

有序集合

这是 Java 集合框架的一个重要增强,旨在提供更一致和方便的方式来处理具有定义顺序的集合。在 Java 21 之前,访问不同类型集合的第一个和最后一个元素的方式不统一,而且有些操作比较繁琐。有序集合的引入解决了这些问题。

背景:传统集合的不足

在 Java 中,我们有多种集合类型,例如 List、Set、Deque 等。其中一些集合类型(如 List 和 Deque)具有明确的元素顺序,而另一些(如 HashSet)则没有。即使是具有顺序的集合,访问其第一个或最后一个元素的方式也各不相同,例如:

  • List: list.get(0) 获取第一个元素,list.get(list.size() - 1) 获取最后一个元素。
  • Deque: deque.getFirst() 获取第一个元素,deque.getLast() 获取最后一个元素。
  • SortedSet: set.first() 获取第一个元素,set.last() 获取最后一个元素。

这种不一致性使得代码编写和维护变得复杂,尤其是在需要处理多种集合类型的情况下。

有序集合的目标

有序集合的目标是提供一组统一的接口和方法,用于处理具有定义顺序的集合,包括:

  • 统一访问第一个和最后一个元素: 提供一致的方法来访问集合的第一个和最后一个元素。
  • 支持逆序遍历: 提供方便的方法来逆序遍历集合。
  • 提供新的集合类型: 引入新的有序集合类型。
Java 21 引入了以下新的接口:
  • SequencedCollection<E>: 这是一个新的接口,扩展了 Collection<E> 接口,表示具有定义顺序的元素集合。它定义了以下方法:

    • E getFirst(): 返回集合的第一个元素。
    • E getLast(): 返回集合的最后一个元素。
    • SequencedCollection<E> reversed(): 返回一个原集合的逆序视图。
    • E removeFirst(): 移除并返回集合的第一个元素。
    • E removeLast(): 移除并返回集合的最后一个元素。
    • void addFirst(E e): 在集合的开头添加一个元素。
    • void addLast(E e): 在集合的末尾添加一个元素。
  • SequencedSet<E>: 这是一个新的接口,扩展了 Set<E> 和 SequencedCollection<E> 接口,表示具有定义顺序且不包含重复元素的集合。

  • SequencedMap<K, V>: 这是一个新的接口,扩展了 Map<K, V> 接口,表示具有定义顺序的键值对集合。它定义了以下方法:

    • Map.Entry<K, V> firstEntry(): 返回 Map 中的第一个条目。
    • Map.Entry<K, V> lastEntry(): 返回 Map 中的最后一个条目。
    • SequencedMap<K, V> reversed(): 返回此 Map 的逆序视图。
    • K firstKey(): 返回 Map 中的第一个键。
    • K lastKey(): 返回 Map 中的最后一个键。
    • V putFirst(K k, V v): 在 Map 的开头添加一个键值对。
    • V putLast(K k, V v): 在 Map 的末尾添加一个键值对。
    • Map.Entry<K, V> pollFirstEntry(): 移除并返回 Map 中的第一个条目,如果 Map 为空,则返回 null。
    • Map.Entry<K, V> pollLastEntry(): 移除并返回 Map 中的最后一个条目,如果 Map 为空,则返回 null。
    现有集合的改进

    Java 21 对现有的集合类也进行了改进,使其实现了 SequencedCollection 或 SequencedMap 接口:

    • List 实现了 SequencedCollection 接口。
    • Deque 实现了 SequencedCollection 接口。
    • LinkedHashSet 实现了 SequencedSet 接口。
    • LinkedHashMap 实现了 SequencedMap 接口。
    • SortedSet 和 SortedMap 也进行了更新,以更好地与 SequencedCollection 和 SequencedMap 协同工作。

    示例

    import java.util.List;
    import java.util.SequencedCollection;
    
    public class SequencedCollectionExample {
        public static void main(String[] args) {
            SequencedCollection<String> list = List.of("a", "b", "c");
    
            System.out.println(list.getFirst()); // 输出:a
            System.out.println(list.getLast()); // 输出:c
    
            SequencedCollection<String> reversedList = list.reversed();
            System.out.println(reversedList); // 输出:[c, b, a]
    
            List<Integer> numbers = new java.util.ArrayList<>(List.of(1, 2, 3));
            numbers.addFirst(0);
            numbers.addLast(4);
            System.out.println(numbers); // 输出:[0, 1, 2, 3, 4]
    
        }
    }
    

Java 22(2024 年 3 月预计发布)

外部函数与内存 API(正式版)

  • 为高效的跨语言调用提供正式支持。

未命名模式和变量(正式版)

未命名模式和变量(Unnamed Patterns and Variables),这是一项旨在提高代码可读性和简洁性的语言增强特性。它主要解决的是在某些情况下,我们需要声明变量或模式,但实际上并不需要使用它们的情况。

未命名模式和变量的目标是允许我们使用下划线 _ 来表示未使用的变量和模式,从而消除这些冗余的声明,提高代码的简洁性和可读性。

背景:冗余的变量和模式声明

在 Java 编程中,我们有时需要为了语法上的完整性而声明一些变量或模式,即使这些变量或模式在后续的代码中并没有被使用。例如:

  • try-catch 语句中的异常变量: 有时我们只需要捕获异常,而不需要访问异常对象本身。
  • lambda 表达式中的参数: 有时我们只需要 lambda 表达式的部分参数,而不需要使用所有参数。
  • switch 语句中的模式变量: 在一些简单的模式匹配场景中,我们可能只需要匹配类型,而不需要访问匹配到的对象。

这些未使用的变量和模式声明会使代码显得冗余,降低代码的可读性。

未命名模式和变量的用法
try {
    // 一些可能抛出异常的代码
} catch (IOException _) { // 使用 _ 表示未使用的异常变量
    // 处理异常
    System.out.println("发生 IO 异常");
}


List<String> strings = List.of("a", "bb", "ccc");
strings.forEach(_ -> System.out.println("Hello")); // 使用 _ 表示未使用的参数


Object obj = "hello";
switch (obj) {
    case String _ -> System.out.println("It's a string!"); // 使用 _ 表示未使用的模式变量
    default -> System.out.println("It's not a string.");
}


Object obj = 1;
switch (obj) {
    case Integer _, Float _ -> System.out.println("It's a number!"); // 合并 case 标签
    default -> System.out.println("It's not a number.");
}


// 未命名模式也可以用于嵌套模式中。例如,假设我们有以下记录类
record Point(int x, int y) {}
record ColoredPoint(Point p, String color) {}

ColoredPoint cp = new ColoredPoint(new Point(1, 2), "red");
if (cp instanceof ColoredPoint(_, String color)) { // 使用 _ 忽略 Point 记录
    System.out.println("The color is " + color);
}

G1 垃圾收集器改进

  • 增强性能和可预测性。

Java 23(2024 年 9 月预计发布)

模式匹配 for 原始类型(预览)

模式匹配对原始类型的增强(Primitive Types in Patterns, instanceof, and switch),这是一项旨在扩展模式匹配功能的预览特性(JEP 455)。它允许在所有模式上下文中使用原始类型模式,包括 instanceof 和 switch 表达式/语句,从而提高了代码的简洁性和效率。

背景:模式匹配的现有局限

在 Java 23 之前,模式匹配主要针对引用类型(Reference Types)进行。虽然已经支持了类型模式、记录模式等强大的功能,但对于原始类型(primitive types,如 int、long、boolean 等)的支持却相对有限。例如,你不能直接在 switch 语句的 case 中使用 int i 这样的模式来匹配一个 int 值,而是需要通过装箱(boxing)将 int 转换为 Integer 对象。

这种限制导致了一些不便:

  • 需要手动装箱/拆箱: 为了使用模式匹配,需要显式或隐式地进行装箱和拆箱操作,这会带来一定的性能开销。
  • 代码不够简洁: 有时需要编写额外的代码来处理原始类型和包装类型之间的转换,使代码不够简洁直观。
模式匹配 for 原始类型 的目标

此特性的目标是消除这些限制,使模式匹配能够无缝地应用于原始类型,从而:

  • 提高性能: 避免不必要的装箱和拆箱操作,提高代码执行效率。
  • 简化代码: 使代码更加简洁、易懂,提高可读性和可维护性。
  • 统一模式匹配语法: 使原始类型和引用类型的模式匹配语法保持一致,降低学习成本。
模式匹配 for 原始类型 的用法

此特性主要扩展了以下几个方面:

// 1.instanceof 运算符
Object obj = 10;

if (obj instanceof Integer i) { // 之前的用法,i 是 Integer 类型
    System.out.println("It's an Integer: " + i);
}

if (obj instanceof int i) {     // Java 23 新增:i 是 int 类型
    System.out.println("It's an int: " + i);
}


// 2.switch 表达式/语句
int status = 1;

String message = switch (status) {
    case 0 -> "OK";
    case 1 -> "Warning";
    case 2 -> "Error";
    case int i -> "Unknown status: " + i; // Java 23 新增:匹配所有其他 int 值
    default -> "Invalid status";
};

System.out.println(message); // 输出:Warning


Object obj = Integer.valueOf(5);
switch (obj) {
    case Integer i -> System.out.println("Integer: " + i); // 之前的用法
    case int i -> System.out.println("int: " + i);       // Java 23 新增:即使 obj 是 Integer,也能匹配 int
    default -> System.out.println("Not an integer");
}


// 3.所有模式上下文
// 此特性不仅限于 instanceof 和 switch,还扩展到所有可以使用模式的上下文,例如:
// 增强 for 循环: 虽然在增强 for 循环中直接使用原始类型的情况不多见,但在某些特殊场景下也可能用到。
// 记录模式中的组件: 记录类的组件现在也可以是原始类型,并直接在模式中匹配。
record Point(int x, int y) {}

Point p = new Point(3, 4);

if (p instanceof Point(int x, int y)) { // x 和 y 都是 int 类型
    System.out.println("Point at (" + x + ", " + y + ")");
}

类文件 API(第二次预览)

Java 23 的类文件 API (Class-File API, JEP 466),这是该 API 的第二次预览。这个 API 提供了一种标准化的方式来解析、生成和转换 Java 类文件。类文件是 Java 字节码的存储格式,包含了类的结构信息,例如类名、字段、方法、指令等。

在 Java 23 之前,处理类文件通常依赖于第三方库,例如 ASM、Byte Buddy 等。虽然这些库功能强大,但使用它们存在一些不足:
  • 依赖外部库: 引入额外的依赖,增加了项目的复杂性。
  • API 不统一: 不同库的 API 设计风格各异,学习成本较高。
  • JDK 内部实现不一致: JDK 内部的一些工具也使用了不同的库来处理类文件,导致实现不一致。
类文件 API 的目标

类文件 API 的目标是提供一套标准的 API,用于解析、生成和转换 Java 类文件,从而:

  • 标准化类文件处理: 提供统一的 API,降低学习成本,提高代码的可移植性。
  • 减少外部依赖: 减少对第三方库的依赖,简化项目管理。
  • 提高 JDK 内部实现的一致性: 使 JDK 内部的工具能够使用标准的 API,提高代码的可维护性。
类文件 API 的主要组成部分

类文件 API 主要包含以下几个核心组件:

  • ClassReader: 用于读取类文件。它将类文件的字节流解析为内部的数据结构,方便后续的处理。
  • ClassWriter: 用于生成类文件。它允许你以编程方式创建类文件的内容,并将其转换为字节流。
  • ClassVisitor: 用于访问和修改类文件的结构。它定义了一系列的回调方法,用于处理类文件的不同部分,例如类名、字段、方法、注解等。你可以通过实现 ClassVisitor 接口来定制类文件的处理逻辑。
  • MethodVisitor、FieldVisitor、AnnotationVisitor 等: 这些是 ClassVisitor 的辅助接口,用于更精细地访问和修改类文件中的方法、字段和注解等。
类文件 API 的使用示例(概念性)

以下是一个简化的示例,演示如何使用类文件 API 读取类名:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import jdk.internal.classfile.ClassReader;
import jdk.internal.classfile.ClassFile;

public class ClassFileApiExample {
    public static void main(String[] args) throws IOException {
        byte[] classFileBytes = Files.readAllBytes(Paths.get("path/to/MyClass.class")); // 读取类文件

        ClassReader reader = ClassReader.of(classFileBytes); // 创建 ClassReader

        ClassFile cf = ClassFile.parse(reader); //解析类文件

        System.out.println("Class Name: " + cf.name().stringValue()); // 获取类名
    }
}

需要注意的是,jdk.internal.classfile 包是内部 API,在未来的版本中可能会发生变化。更推荐使用 java.lang.classfile 包(在 Java 22 引入,在 Java 23 中是第二次预览),它提供了更加稳定和友好的 API。

Java 23 对类文件 API 的改进

Java 23 对类文件 API 进行了一些改进,主要集中在以下方面:

  • CodeBuilder 类的简化: 精简了 CodeBuilder 类的方法,删除了一些重复或不常用的方法,使其更加易用。CodeBuilder 用于构建方法体中的字节码指令序列。
  • ClassSignature 类的增强: 增强了 ClassSignature 类对泛型签名的建模精确度。这使得类文件 API 能够更准确地处理包含泛型的类。
  • 默认包含字节码指令的工厂方法: 包括低级工厂、中级工厂和基本块的高级构建器。

Markdown 文档注释

Java 23 引入的 Markdown 文档注释 (Markdown Documentation Comments, JEP 467)。这是一项旨在改进 Java 文档编写体验的重要特性。它允许开发者使用 Markdown 语法来编写 JavaDoc 文档注释,从而替代了以往 HTML 和 JavaDoc 标签混合使用的繁琐方式。

背景:传统 JavaDoc 的不足

传统的 JavaDoc 文档注释使用 HTML 标签和 JavaDoc 特定的 @ 标签(例如 @param、@return、@throws 等)来格式化文档。这种方式存在一些不足:

  • 编写繁琐: HTML 标签语法相对复杂,编写和维护都比较麻烦。
  • 可读性差: HTML 标签与代码混合在一起,降低了代码的可读性。
  • 学习成本高: 开发者需要学习 HTML 和 JavaDoc 标签的语法,增加了学习成本。
Markdown 文档注释的语法

使用 Markdown 编写 JavaDoc 注释非常简单,只需要将注释块的开头从 /** 修改为 /// 即可。例如:

/// 这是类级别的 Markdown 文档注释
///
/// 这是一个段落。
///
/// * 这是一个列表项。
/// * 这是另一个列表项。
public class MyClass {

    /// 这是一个方法的 Markdown 文档注释
    ///
    /// @param name 用户的姓名
    /// @return 欢迎消息
    public String greet(String name) {
        return "Hello, " + name + "!";
    }
}
与 JavaDoc 标签的兼容性

Markdown 文档注释仍然支持 JavaDoc 特定的 @ 标签,例如 @param、@return、@throws 等。这意味着你可以混合使用 Markdown 语法和 JavaDoc 标签。

向量 API(第八次孵化)

  • 优化向量计算性能,用于高效并行计算。

分代 ZGC 默认启用

  • 分代垃圾收集模式成为 ZGC 的默认设置。

未命名类和实例 main 方法(第三次预览)

Java 23 的“未命名类和实例 main 方法”(Unnamed Classes and Instance Main Methods),也称为“隐式声明的类和实例 main 方法”(Implicitly Declared Classes and Instance Main Methods)。这项特性旨在简化初学者的 Java 入门体验,降低学习门槛。它在 Java 21 中首次作为预览功能引入,并在 Java 22 和 Java 23 中持续改进。

背景:传统 main 方法的复杂性

传统的 Java 程序需要一个包含 public static void main(String[] args) 方法的类。对于初学者来说,这个方法声明包含了很多他们尚未理解的概念:

  • public:访问修饰符,表示该方法是公共的。
  • static:表示该方法是静态的,可以直接通过类名调用,无需创建对象。
  • void:表示该方法没有返回值。
  • String[] args:表示该方法接收一个字符串数组作为命令行参数。

这些概念对于刚接触编程的人来说可能比较难以理解,容易造成困惑。

未命名类和实例 main 方法的目标

这项特性的目标是:

  • 简化 main 方法的声明: 允许开发者使用更简洁的方式编写 main 方法,无需显式声明类和 static 修饰符。
  • 降低学习门槛: 使初学者能够更快地编写简单的 Java 程序,而无需过早地接触复杂的面向对象概念。
  • 提高代码的简洁性: 对于简单的脚本式程序,可以减少样板代码。
未命名类和实例 main 方法的用法

在 Java 23 中,你可以使用以下方式编写 main 方法:

void main() {
    System.out.println("Hello, world!");
}

void main(String[] args) {
    for (String arg : args) {
        System.out.println("Argument: " + arg);
    }
}

可以看到,与传统的 main 方法声明相比,这种方式更加简洁明了。

结构化并发(第三次预览)

  • 进一步优化结构化并发 API 的功能和稳定性。

以下内容更新于2025年10月16日


Java 24(2025 年 3 月 发布)

Java 24 是一个短期版本(非 LTS),含有多个 JEP 来推动语言、JVM、库层面的演进。

类别特性说明 / 备注
实验性 / 孵化 / 预览JEP 404: Generational Shenandoah (实验性)探索 Shenandoah GC 的分代模式,以改进垃圾回收效率。(openjdk.org)
实验性JEP 450: Compact Object Headers (实验性)目标将对象头压缩到较小位宽(例如 64 位),减少内存占用、提升缓存亲和性。(jrebel.com)
预览JEP 492: Flexible Constructor Bodies (第三预览)允许在 super(...) / this(...) 调用之前出现语句(注意限制,不能访问未初始化的对象)。(openjdk.org)
预览JEP 488: Primitive Types in Patterns, instanceof, switch(第二预览)在模式匹配、instanceof、switch 中支持原始类型(如 int, byte 等),减少装箱操作。(openjdk.org)
正式 / 永久JEP 490: ZGC – Remove the Non-Generational ModeZGC 不再保留非分代模式,仅支持分代模式;简化实现并强制使用更现代的 GC 模型。(openjdk.org)
正式 / 永久JEP 491: Synchronize Virtual Threads without Pinning为虚拟线程提供同步机制,避免将线程“固定”(pin)到平台线程。(openjdk.org)
正式 / 永久JEP 485: Stream Gatherers(流收集器)引入新的机制让流操作在收集(gathering)阶段更灵活,支持自定义过滤、映射等。已在 Java 24 中定稿。(PVS-Studio)
预览JEP 494: Module Import Declarations(第二预览)在 Java 源文件中用 import module … 的方式简化模块依赖声明。(openjdk.org)
正式 / 永久JEP 492、JEP 493 等包括 “Linking Run-Time Images without JMODs” 等模块运行/启动层面的改进。(openjdk.org)
废弃 / 移除 / 警告删除 32 位 x86 Windows 支持Java 24 不再支持 Windows 的 32 位 x86 架构。(InfoWorld)
废弃 / 警告对 sun.misc.Unsafe 的直接内存访问方法发出警告在首次调用这些方法时触发运行时警告,提示使用标准 API。(InfoWorld)

注意:以上并不是 Java 24 中所有 JEP,而是比较突出或对应用程序影响较大的特性。

JEP 485: Stream Gatherers(流收集器)

旨在增强 Java Stream API 的灵活性,通过引入“Gatherers”来支持自定义的中间操作。

背景与问题

Java Stream API 自 JDK 8 引入以来,提供了一系列内置中间操作(如 map、filter、distinct),但对于复杂转换(如按长度去重、固定大小窗口分组、状态化扫描或并发映射),开发者往往需要使用工作围绕(如自定义收集器 Collector 或包装对象),这会破坏流式的声明性和懒惰性,尤其在处理无限流或并行执行时。JEP 485 通过 Gatherers 解决这些痛点,让 Stream pipelines 更具表达力,而无需转向命令式循环。

描述(Description)

JEP 485 在 Stream 接口中添加新方法 Stream.gather(Gatherer),它是一个自定义中间操作,返回一个新的 Stream,允许将输入元素转换为输出元素,支持一对一、一对多、多对一或多对多映射。Gatherer 是 java.util.stream.Gatherer 接口的实例,由四个可选函数定义:

初始化器(Initializer):Supplier<A>,为状态对象提供初始值(A 是累加器类型)。
集成器(Integrator):Integrator<A, T, R>,处理每个输入元素 T(返回输出 R),通过 Downstream 接口向下游推送结果,并返回 boolean 表示是否继续处理(支持短路)。
组合器(Combiner):BiFunction<A, A, A>,用于并行执行时合并分支状态。
完成器(Finisher):BiConsumer<A, Downstream<? super R>>,在处理结束时推送最终结果或清理。

Gatherers 与现有 API 无缝集成:所有内置中间操作(如 map)都可以实现为 Gatherer;管道等价于多次 gather 后接终端操作(如 collect)。Gatherers 支持组合(andThen 方法),类似于函数组合。内置实用类 Gatherers 提供常见模式:fold(状态化聚合)、mapConcurrent(并发映射)、scan(累积扫描)、windowFixed(固定窗口)、windowSliding(滑动窗口)。
Gatherers 处理无限流时,通过集成器返回 false 来短路;并行执行类似于 reduce 或 forEachOrdered,取决于是否有组合器。

例:按长度去重

无 Gatherers 时,需要包装对象和 distinct:

record DistinctByLength(String str) {
    @Override public boolean equals(Object obj) {
        return obj instanceof DistinctByLength d && str.length() == d.str.length();
    }
    @Override public int hashCode() {
        return Integer.hashCode(str.length());
    }
}

var result = Stream.of("foo", "bar", "baz", "quux")
                   .map(DistinctByLength::new)
                   .distinct()
                   .map(d -> d.str)
                   .toList();  // [foo, quux]

使用 Gatherers(自定义):

static <T> Gatherer<T, Set<Integer>, T> distinctBy(Function<T, Integer> keyExtractor) {
    return Gatherer.of(
        HashSet::new,
        (set, element, downstream) -> {
            int key = keyExtractor.apply(element);
            if (set.add(key)) {
                return downstream.push(element);
            }
            return true;
        }
    );
}

var result = Stream.of("foo", "bar", "baz", "quux")
                   .gather(distinctBy(String::length))
                   .toList();  // [foo, quux]

Java 25(2025 年 9 月 发布,LTS)

类别特性说明 / 备注
预览JEP 507: Primitive Types in Patterns, instanceof, switch(第三预览)进一步拓展在模式匹配、instanceof、switch 中对原始类型的支持。(azul.com)
正式 / 完成JEP 511: Module Import Declarations模块导入声明功能定稿,使模块依赖在源文件中声明更直观。(azul.com)
正式 / 完成JEP 512: Compact Source Files & Instance Main Methods降低初学者入门门槛,允许源码更简洁地写 void main(),省略部分样板代码。(openjdk.org)
预览 / 草案JEP 513: Flexible Constructor Bodies允许在构造方法中 super(...) 调用之前写语句(但受限于不能访问 this 的状态)。目标在 JDK 25 中最终化。(InfoWorld)
正式 / 完成JEP 505: Structured Concurrency(第五预览)继续在 Project Loom 框架支持下推进结构化并发概念,改进子任务组管理、取消和超时处理机制。(openjdk.org)
正式 / 完成JEP 506: Scoped Values (Preview / Incubator)提供一种替代 ThreadLocal 的机制,尤其适用于虚拟线程,支持更灵活的线程内数据传递。(openjdk.org)
正式 / 完成JEP 508: Vector API(第十孵化器)向量 API 继续演进,提供高性能 SIMD 风格计算支持。(openjdk.org)
正式 / 完成JEP 509: JFR CPU-Time Profiling (实验性)在 JFR(Java Flight Recorder)中加入对 CPU 时间的剖析支持(目前为实验特性)。(openjdk.org)
正式 / 完成JEP 510: Key Derivation Function API引入标准 API 支持密钥衍生函数(Key Derivation Functions),增强加密模块能力。(openjdk.org)
废弃 / 移除JEP 503: Remove 32-bit x86 Port正式移除对 32 位 x86 架构的支持(此前版本逐步废弃)。(openjdk.org)
正式 / 完成JEP 514: Ahead-of-Time Command-Line Ergonomics改善 AOT 编译/运行时的命令行体验,让 AOT 使用更便捷。(openjdk.org)
正式 / 完成JEP 515: Ahead-of-Time Method Profiling提供方法级别的 AOT 配置、性能导向,用于加速程序启动与预热。(openjdk.org)
正式以及其它 JEPs包括 JEP 518(JFR Cooperative Sampling)、JEP 519(Compact Object Headers)、JEP 520、521(如 Generational Shenandoah)、JEP 503 等。(openjdk.org)

JEP 511: Module Import Declarations

旨在增强 Java 编程语言的模块导入机制,通过引入“模块导入声明”(Module Import Declarations)来简化对模块公共类型的访问。

背景与问题

自 JDK 9 引入模块系统以来,开发者需要在 module-info.java 中使用 requires 声明模块依赖,然后在源代码中使用传统的 import 语句导入特定包或类。如果一个模块导出多个包,且代码需要频繁使用这些包的公共类型(如 GUI 组件),就会导致大量的 import 语句,增加代码冗余和维护负担。例如,从 java.desktop 模块导入 Swing 和 AWT 组件时,可能需要数十行 import。JEP 511 通过一行声明导入整个模块的公共类型,解决这一痛点,而不破坏模块的封装性。

例
例如,在一个使用 java.desktop 模块的源文件中:
module my.module {
    requires java.desktop;
}

import module java.desktop;  // 新语法:一行导入所有公共类型

public class MyApp {
    public static void main(String[] args) {
        JFrame frame = new JFrame();  // 直接使用,无需 import javax.swing.JFrame;
        JButton button = new JButton();  // 直接使用,无需 import javax.swing.JButton;
        // ... 其他组件
    }
}

这取代了原本的多个 import javax.swing.*; 和 import java.awt.*; 语句。

GUI 应用中的组件导入(基本场景)

无 JEP 511 时,需要多个 import:

import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JLabel;
import java.awt.FlowLayout;
// ... 更多 import

使用 JEP 511:

import module java.desktop;  // 一行搞定

public class SimpleGUI {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Hello");
        frame.setLayout(new FlowLayout());
        frame.add(new JButton("Click"));
        frame.add(new JLabel("Label"));
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

开发体现:在 Swing 项目中,减少了 10+ 行 import,提高了代码整洁度,尤其在团队协作时。

JEP 512: Compact Source Files & Instance Main Methods

一句话所就是main方法更简洁,直接上案例。

最简单的Hello World
// Hello.java (紧凑源文件,无类声明)
void main() {
	System.out.println("Hello, World!");
}

运行:java Hello.java(无需编译为.class)。

带参数的
// Greet.java
void main(String[] args) {
	String name = args.length > 0 ? args[0] : "World";
	System.out.println("Hello, " + name + "!");
}

运行:java Greet.java Alice 输出 “Hello, Alice!”。
这些特性结合使用:紧凑源文件支持实例 main,并默认导入 I/O 方法(如 System.out.println),无需显式 import。

JEP 510: Key Derivation Function API

旨在为 Java 平台引入密钥派生函数(Key Derivation Functions, KDFs)的标准 API,用于从秘密密钥和其他数据中派生出额外的密钥。

背景与问题

密钥派生函数(KDFs)是一种加密算法,利用初始密钥材料、盐值和伪随机函数等输入,生成新的加密强密钥材料。它常用于从共享输入中创建可重复且安全的密钥,支持多方协作(如客户端和服务器)。KDF 与密码哈希类似,但使用带密钥的哈希和额外熵来提取或扩展密钥流。
随着量子计算的兴起,传统加密算法面临实际攻击风险,因此 Java 平台需支持后量子加密(Post-Quantum Cryptography, PQC)。JEP 510 是构建混合公钥加密(Hybrid Public Key Encryption, HPKE)的第二个构建块,继 JEP 452(KEM API,JDK 21)之后,帮助平稳过渡到量子安全算法。此外,现有的 Java 加密 API(如 KeyGenerator 和 SecretKeyFactory)不适合表示 KDFs:前者依赖随机熵生成非确定性密钥,后者仅支持单密钥创建,无法处理确定性多密钥派生。第三方提供商(如 PKCS#11 硬件设备)和高级密码哈希(如 Argon2)也缺乏自然支持。

例

在实际开发中,JEP 510 适用于加密协议(如 TLS 密钥协商)或密码存储。以下是两个典型例子(JDK 25+),展示 HKDF 使用。

例1:基本 HKDF 密钥派生(HPKE 场景)
import javax.crypto.KDF;
import javax.crypto.spec.HKDFParameterSpec;
import javax.crypto.SecretKey;
import java.security.SecureRandom;

// 假设 initialKeyMaterial 是共享秘密,salt 是随机盐
byte[] initialKeyMaterial = ...;  // 初始密钥材料
byte[] salt = new byte[32];
new SecureRandom().nextBytes(salt);
byte[] info = "aes-256-gcm".getBytes();  // 上下文信息

// 创建 KDF 实例
KDF hkdf = KDF.getInstance("HKDF-SHA256");

// 创建 Extract-Expand 参数
HKDFParameterSpec params = HKDFParameterSpec.ofExtract()
                                           .addIKM(initialKeyMaterial)
                                           .addSalt(salt)
                                           .thenExpand(info, 32);  // 32 字节输出

// 派生 AES 密钥
SecretKey key = hkdf.deriveKey("AES", params);

// 使用密钥(例如加密)

开发体现:在 Web 服务中,用于从共享密钥派生会话密钥,支持量子安全过渡,无需第三方库。

例2: 连续密钥派生(多密钥场景)
KDF hkdf = KDF.getInstance("HKDF-SHA256");
HKDFParameterSpec params = ...;  // 如上

// 派生第一个密钥(加密)
SecretKey encKey = hkdf.deriveKey("AES", params);

// 派生第二个密钥(MAC)
byte[] macBytes = hkdf.deriveBytes(HKDFParameterSpec.ofExpand()
                                                   .addPRK(encKey.getEncoded())
                                                   .addInfo("hmac-sha256".getBytes(), 32));
                                                   

开发体现:在消息认证系统中,从单一 PRK(伪随机密钥)派生多用途密钥,提高效率和安全性。
总之,JEP 510 强化了 Java 的加密生态,是 PQC 路线图的关键一步。未来将添加 Argon2 等。如果你有具体加密代码或场景,我可以进一步举例!

JEP 505: Structured Concurrency

旨在引入结构化并发(Structured Concurrency)的第五次预览版本,作为 Project Loom 的一部分。

背景与问题

传统 Java 并发编程(如使用 ExecutorService)往往导致任务生命周期难以管理:子任务失败时,父任务可能继续运行,导致资源泄漏;取消一个任务时,其他相关任务可能未被及时终止,造成复杂错误处理和调试难题。结构化并发通过将一组相关任务视为单个逻辑单元(类似于结构化编程的块),解决这些问题:任务的启动、完成和取消由语法结构决定,确保可预测性和安全性。这在微服务、异步 I/O 或高并发应用中特别有用,尤其结合虚拟线程(Virtual Threads)时。

例

在实际开发中,JEP 505 适用于 Web 服务中的并行调用或批处理。以下是两个典型例子(JDK 25+,启用预览)。

例子 1: 并行 HTTP 请求(基本场景)

无结构化并发时,使用 CompletableFuture 需手动处理异常和取消:

CompletableFuture<String> userCf = CompletableFuture.supplyAsync(() -> fetchUser());
CompletableFuture<Integer> orderCf = CompletableFuture.supplyAsync(() -> fetchOrderCount());
CompletableFuture.allOf(userCf, orderCf).join();  // 手动聚合
// 复杂异常处理...

使用 JEP 505:

import java.util.concurrent.StructuredTaskScope;

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    var userFuture = scope.fork(() -> fetchUser());
    var orderFuture = scope.fork(() -> fetchOrderCount());
    scope.join();
    scope.throwIfFailed();
    return new Profile(userFuture.resultNow(), orderFuture.resultNow());
}
例子 2: 短路并行搜索(应用场景)

使用 ShutdownOnSuccess 短路成功任务:

try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
    scope.fork(() -> searchInDatabase(query));
    scope.fork(() -> searchInCache(query));
    scope.fork(() -> searchInExternalAPI(query));
    String result = scope.join().resultNow();  // 第一个成功即返回
    return result;
} catch (InterruptedException e) {
    // 处理取消
}

开发体现:在搜索引擎或电商推荐系统中,加速响应时间(基准测试显示延迟降 40%),并自动取消失败分支。
总之,JEP 505 标志着结构化并发趋于成熟,是 Java 并发编程的重大进步。如果你有具体代码或与虚拟线程的结合问题,我可以进一步举例!

JEP 506: Scoped Values (Preview / Incubator)

旨在引入作用域值(Scoped Values),一种用于在同一线程内及其子线程中安全、高效共享不可变数据的容器对象。

背景与问题

传统 Java 并发中,ThreadLocal 用于线程内共享数据,但存在问题:数据生命周期不明确(可能无限期存在,导致内存泄漏)、双向修改(深层调用者可意外更改父级值)、跨线程继承复杂(需手动复制)、性能开销高(尤其在虚拟线程中)。在 Web 框架、事务或图形上下文中,频繁传递参数(如请求上下文)会使代码冗长。Scoped Values 解决这些,提供单向、不可变共享,生命周期由代码结构界定,与结构化并发(JEP 505)和虚拟线程(JEP 444)无缝集成。

开发中的例子

在实际开发中,Scoped Values 常用于框架上下文传播,如 Web 请求或事务。以下是两个典型例子(JDK 25+)。

例子 1: Web 框架上下文共享(基本场景)

传统 ThreadLocal 方式:

static final ThreadLocal<FrameworkContext> CONTEXT = new ThreadLocal<>();

void serve(Request req) {
    CONTEXT.set(createContext(req));  // 双向,易泄漏
    try {
        Application.handle(req);
    } finally {
        CONTEXT.remove();  // 手动清理
    }
}

问题:用户代码可能遗忘 remove,导致泄漏;子线程需手动复制。
使用 Scoped Values:

static final ScopedValue<FrameworkContext> CONTEXT = ScopedValue.newInstance();

void serve(Request req) {
    var ctx = createContext(req);
    where(CONTEXT, ctx).run(() -> Application.handle(req));  // 自动绑定/清理
}

public PersistedObject readKey(String key) {
    var ctx = CONTEXT.get();  // 安全读取,无需参数
    // DB 操作...
}

开发体现:在 Spring Boot 中,减少参数传递,自动清理上下文;在高并发下,内存使用降 50%(基准测试)。

例子 2: 结构化并发中的继承(应用场景)

用户代码并发读取数据,继承框架上下文:

@Override
public Response handle(Request req, Response res) {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        var userFuture = scope.fork(() -> readUserInfo());  // 继承 CONTEXT
        var offersFuture = scope.fork(() -> fetchOffers());  // 继承 CONTEXT
        scope.join().throwIfFailed();
        return new Response(userFuture.resultNow(), offersFuture.resultNow());
    }
}

UserInfo readUserInfo() {
    var ctx = CONTEXT.get();  // 从父线程继承
    return framework.readKey("user", ctx);  // 访问框架方法
}

开发体现:在微服务中,并行 API 调用时,请求 ID 等上下文自动传播,无需显式传递;结合虚拟线程,支持 10k+ 并发请求。
总之,JEP 506 使 Java 并发更安全高效,是 Loom 生态的核心。如果你有具体迁移代码或与 JEP 505 的结合问题,我可以进一步举例!

JEP 514: Ahead-of-Time Command-Line Ergonomics

旨在通过简化命令行选项来改进 Ahead-of-Time (AOT) 缓存的创建过程,这些缓存可以加速 Java 应用的启动时间。

背景与问题

Project Leyden 自 JDK 21 开始,通过 AOT 技术(如类加载和链接)优化 JVM 启动,但早期实现(如 JDK 24 中的 JEP 510)要求多阶段命令:先“训练”(train)应用以生成配置文件,然后“组装”(assemble)成缓存。这导致命令行复杂,用户需多次运行 java 命令,易出错,尤其在 CI/CD 或脚本环境中。JEP 514 针对这些痛点,简化为单命令流程,同时与 JEP 515(AOT 方法剖析)结合,提供更全面的启动优化。

例

在实际开发中,JEP 514 适用于优化 Web 应用启动。以下是两个典型例子(JDK 25+)。

例子 1: 基本应用缓存生成(基本场景)

传统两阶段(JDK 24):

# 步骤 1: 训练
java -XX:TrainAOTCache -jar app.jar

# 步骤 2: 组装
jaotc --output cache.so @train-profile.txt

使用 JEP 514 单命令:

# 生成缓存
java -XX:TrainAOTCache=cache-dir -jar app.jar

# 加载缓存运行
java -XX:AOTCacheLoad=cache-dir -jar app.jar

开发体现:在 Spring Boot 项目中,启动时间从 2s 降至 0.8s;在 CI 中,一条命令生成缓存 artifact。

例子 2: 排除模块的微服务优化(应用场景)
# 训练并排除 java.desktop(假设不需 GUI)
java -XX:TrainAOTCache=cache-dir --XX:TrainAOTCache=exclude=java.desktop -jar microservice.jar

# 生产运行
java -XX:AOTCacheLoad=cache-dir -XX:+UnlockExperimentalVMOptions -jar microservice.jar

开发体现:在 Kubernetes 部署中,减少镜像大小 15%,并加速冷启动;结合 JEP 515 的方法剖析,进一步优化热点路径。
总之,JEP 514 使 AOT 更易用,是 Project Leyden 向生产就绪迈进的关键。如果你有具体命令测试或与 JEP 515 的结合问题,我可以进一步举例!

JEP 515: Ahead-of-Time Method Profiling

旨在通过在应用训练运行中预先收集方法执行配置文件,来改进 Java 应用的预热时间。

背景与问题

Java 应用的启动和预热阶段依赖 JIT(Just-In-Time)编译器动态收集方法剖析数据(如调用频率、分支概率),以优化热点代码。但在服务器less、容器或边缘计算场景中,频繁的冷启动会导致高延迟(例如,Spring Boot 应用预热需数秒)。传统方法剖析仅在运行时进行,无法提前利用历史数据。JEP 515 通过 AOT(Ahead-of-Time)方法剖析解决这一问题:在“训练”运行中生成配置文件,存储为 AOT 缓存的一部分,让后续运行跳过初始剖析阶段。

例

在实际开发中,JEP 515 适用于优化 Web 或批处理应用。以下是两个典型例子(JDK 25+)。

例子 1: Spring Boot 应用预热(基本场景)

传统运行(无 AOT):

java -jar spring-app.jar  # 启动 3s,预热 2s

使用 JEP 515:

# 训练(模拟生产负载)
java -XX:TrainAOTCache=cache-dir -Dspring.profiles.active=prod -jar spring-app.jar

# 生产启动
java -XX:AOTCacheLoad=cache-dir -jar spring-app.jar  # 启动 1.2s,预热 0.8s

开发体现:在 CI/CD 中,Docker 镜像包含缓存,减少部署延迟 40%。

例子 2: 排除敏感模块的批处理优化(应用场景)
# 训练,排除 crypto 模块(避免敏感数据剖析)
java -XX:TrainAOTCache=cache-dir --XX:TrainAOTCache=exclude=java.security -jar batch-job.jar input.txt

# 运行
java -XX:AOTCacheLoad=cache-dir -jar batch-job.jar input.txt  # 预热降 25%

开发体现:在金融批处理中,加速 ETL 管道,同时保护安全模块。
总之,JEP 515 是 Project Leyden 的重要优化,使 Java 更适合低延迟环境。如果你有具体基准测试或与 JEP 514 的结合问题,我可以进一步举例!


持续更新

更多推荐