jdk17新特性

JDK17新特性

jdk17下载地址：https://download.oracle.com/java/17/latest/jdk-17_windows-x64_bin.exe

JDK 17 文档 - 首页 (oracle.com)

垃圾回收器（Z Garbage Collector）

概述

JDK17引入名为ZGC（Z Garbage Collector）是一种低延迟的垃圾回收器。是JDK 11引入的一项实验性功能，并在JDK 15中成为稳定特性。

它旨在减少应用程序的停顿时间，使得即使在大内存堆上也能保持非常短的垃圾收集暂停时间。暂停时间与正在使用的堆大小无关。ZGC支持从8MB到16TB的堆大小。

Z 垃圾回收器使用命令行选项 启用。-XX:+UseZGC

设置堆大小

尽管ZGC在降低停顿时间方面取得了显著的改进，但这并不意味着它适用于所有场景。在某些情况下，特别是对于小内存堆或强调极致吞吐量的应用程序，其他垃圾收集器可能更合适。因此，在选择垃圾收集器时，还需要综合考虑应用程序的性质和需求。

设置并发GC线程数

想要查看的第二个调整选项是 设置并发 GC 线程数 .ZGC具有自动选择此数字的启发式方法。这种启发式方法通常效果很好，但根据应用程序的特征，可能需要进行调整。此选项基本上决定了应该给 GC 多少 CPU 时间。给它太多，GC 将从应用程序中窃取太多的 CPU 时间。给它太少，应用程序分配垃圾的速度可能会快于 GC 收集它的速度。(-XX:ConcGCThreads)

一个清洁器的简单示例。它执行以下操作：

1. 定义一个清理操作类，该类 初始化清理操作并定义清洁操作本身（通过 重写方法）。State``State::run()

2. 创建 的实例。Cleaner

3. 使用此实例 ，注册对象和清理操作（的实例）。Cleaner``myObject1``State

4. 确保垃圾回收器安排清理程序和 在示例结束之前执行清理操作， 示例：

   State::run()
   

   1. 设置为 确保无法访问它。请参阅。myObject1``null
   2. 循环中的调用以触发 垃圾回收清理。

import java.lang.ref.Cleaner;public class CleanerExample {// This Cleaner is shared by all CleanerExample instancesprivate static final Cleaner CLEANER = Cleaner.create();private final State state;public CleanerExample(String id) {state = new State(id);CLEANER.register(this, state);}// Cleaning action class for CleanerExampleprivate static class State implements Runnable {final private String id;private State(String id) {this.id = id;System.out.println("Created cleaning action for " + this.id);}@Overridepublic void run() {System.out.println("Cleaner garbage collected " + this.id);}}public static void main(String[] args) {CleanerExample myObject1 = new CleanerExample("myObject1");// Make myObject1 unreachablemyObject1 = null;System.out.println("-- Give the GC a chance to schedule the Cleaner --");for (int i = 0; i < 100; i++) {// Calling System.gc() in a loop is usually sufficient to trigger// cleanup in a small program like this.System.gc();try {Thread.sleep(1);} catch (InterruptedException e) {}}System.out.println("-- Finished --");}
}

输出内容

Created cleaning action for myObject1
-- Give the GC a chance to schedule the Cleaner --
Cleaner garbage collected myObject1
-- Finished --

该代码示例演示了Java中的Cleaner类的用法。

Cleaner类是Java 9引入的一个新特性，用于实现在对象被垃圾回收之前执行必要的清理操作。

这段代码定义了一个CleanerExample类，其中包含一个静态的Cleaner实例和一个私有的State内部类，实现了Runnable接口。

在CleanerExample的构造函数中，每次创建实例时都会注册当前对象和其状态（State）到Cleaner中。在State的构造函数中，会打印出创建清理操作的信息。

在main方法中，首先创建了一个CleanerExample实例。然后将myObject1设置为null，使其变得不可达。

接下来，进入一个循环并在循环中调用System.gc()，以尝试手动触发垃圾回收。在每次循环迭代中，通过调用Thread.sleep()来暂停一小段时间，给垃圾回收器调度Cleaner的机会。

最后，程序输出"-- Finished --"表示程序执行结束。

特点

• 低停顿时间：ZGC的主要目标是将垃圾收集暂停时间控制在10毫秒以下，甚至更低。这对于需要快速响应的应用程序和大型内存堆非常重要。
• 回收整个堆：ZGC可以回收整个Java堆，而不仅仅是部分堆区域。这使得它能够处理非常大的内存堆，达到数TB级别。
• 并发垃圾收集：ZGC使用并发线程来执行垃圾收集操作，允许垃圾收集和应用程序执行同时进行，从而减少了停顿时间。
• 基于读屏障：ZGC使用了一种基于读屏障（Read Barrier）的技术，来记录对象引用的读取操作，以便在并发清除过程中保证引用的正确性。
• 可伸缩性：ZGC在设计上注重可伸缩性，能够适应不同规模的应用程序和硬件环境，并能够充分利用多核处理器。

注意： 尽管ZGC在降低停顿时间方面取得了显著的改进，但这并不意味着它适用于所有场景。在某些情况下，特别是对于小内存堆或强调极致吞吐量的应用程序，其他垃圾收集器可能更合适。因此，在选择垃圾收集器时，还需要综合考虑应用程序的性质和需求。

Switch表达式

在Java 14和Java 15中，已经引入了Switch表达式的初始版本。而在JDK 17中，Switch表达式得到了一些改进和增强，包括以下新特性：

1. 简化的Switch表达式：在JDK 17中，可以使用简化的Switch表达式来替代传统的Switch语句。这意味着Switch表达式可以像其他表达式一样返回一个值，无需使用break语句，并且每个分支只需要使用"->"符号来分隔条件和代码块。

   示例：

   int dayOfWeek = 5;
   String dayType = switch (dayOfWeek) {case 1, 2, 3, 4, 5 -> "工作日";case 6, 7 -> "休息日";default -> throw new IllegalArgumentException("无效的星期");
   };
   System.out.println(dayType);  // 输出：工作日
   

   jdk8编写

   int dayOfWeek = 5;
   String dayType;
   switch (dayOfWeek) {case 1:case 2:case 3:case 4:case 5:dayType = "工作日";break;case 6:case 7:dayType = "休息日";break;default:throw new IllegalArgumentException("无效的星期");
   }
   System.out.println(dayType);  // 输出：无效的星期

2. 新增的Pattern匹配：在JDK 17中，Switch表达式还支持对Pattern进行匹配。这使得我们可以使用Switch表达式来处理更复杂的模式匹配操作，例如对类型、枚举常量等进行匹配。

   示例：

   Object obj = "Hello";
   int length = switch (obj) {case String s -> s.length();case Integer i && i > 0 -> i;case int[] arr && arr.length > 0 -> arr.length;default -> -1;
   };
   System.out.println(length);  // 输出：5
   

   jdk8编写

   Object obj = "Hello";
   int length;
   if (obj instanceof String) {String s = (String) obj;length = s.length();
   } else if (obj instanceof Integer && ((Integer) obj) > 0) {int i = (Integer) obj;length = i;
   } else if (obj instanceof int[] && ((int[]) obj).length > 0) {int[] arr = (int[]) obj;length = arr.length;
   } else {length = -1;
   }
   System.out.println(length);  // 输出：5

3. 简化的Lambda类型：在JDK 17中，Switch表达式还支持使用"->"符号来指定Lambda表达式的类型。这使得我们可以更简洁地定义Switch表达式中的Lambda表达式。

   示例：

   int number = 4;
   String numberType = switch (number) {case 1 -> "One";case 2 -> "Two";case 3 -> "Three";default -> {yield "Other";}
   };
   System.out.println(numberType);  // 输出：Other
   

jdk8编写

int number = 4;
String numberType;
switch (number) {case 1:numberType = "One";break;case 2:numberType = "Two";break;case 3:numberType = "Three";break;default:numberType = "Other";break;
}
System.out.println(numberType);  // 输出：Other

Switch表达式的新特性需要Java 17或更高版本才能使用。并且在使用Switch表达式时，仍然需要确保每个分支都能够处理所有可能的情况，否则需要在最后添加default分支来处理未匹配到的情况。

sealed关键字

原文：

概述

sealed 类是 JDK 17 中引入的一个新特性，它通过控制类的直接子类来提供更严格的类继承关系，并对类层次结构进行限制。这有助于提高代码的可读性和可维护性，并在特定领域建模中非常有用。它通过控制类的直接子类来提供更严格的类继承关系，并对类层次结构进行限制。这有助于提高代码的可读性和可维护性，并在特定领域建模中非常有用。

例如：

public sealed class Student permits StudentSon1, StudentSon2 {// 父类定义的共享属性和方法
}final class StudentSon1 extends Student {// 圆形特定的属性和方法
}final class StudentSon2 extends Student {// 矩形特定的属性和方法
}

解释：

通过sealed关键字定义的Student类，只能被permits关键字列出的StudentSon1,StudentSon2类来继承，其他类无法直接继承Student类，负责编译错误

这样的设计有助于受限制继承关系，使得只有特定的StudentSon1和StudentSon2来继承Student父类。

这种模式可以在建模特定领域或实现特定抽象时非常有用，因为它能提供更严格的类层次结构，增加代码的可读性和可维护性。

特点

• 当一个类被声明为sealed类时，这意味着在声明这个类时已经知道了它的所有直接子类，并且不希望或需要有其他直接子类。这种对类直接子类的明确和详尽控制在用类层次来建模领域中的值类型时非常有用，而不仅仅是作为代码继承和重用的机制。直接子类本身也可以声明为sealed类，以进一步控制类层次结构。
• 一个类可以被声明为final类，如果该类的定义已经完整，不希望或需要有任何子类。final类永远不会有任何子类，因此final类的方法也不会被覆盖。
• 如果一个类有一个sealed的直接超类或者一个sealed的直接超接口，而且没有明确或隐式地声明为final、sealed或non-sealed，那么这将是一个编译时错误。

permits关键字

permits 是用于定义一个 sealed 类的子类集合的关键字。在一个 sealed 类的声明中，可以使用 permits 关键字来列出一组允许的子类，这些子类可以继承该 sealed 类。

当一个类被声明为 sealed 类时，它必须显式列出其所允许的所有直接子类。这个列表通过使用 permits 关键字来定义，其后跟随该 sealed 类所允许的子类名称或类型。例如：

public sealed class Animal permits Cat, Dog, Fish {// 类主体
}

Animal 是一个 sealed 类，它允许的子类分别是 Cat、Dog 和 Fish。

需要注意的是，使用 permits 关键字列出的子类必须是 sealed 类、final 类或 non-sealed 类。如果不是这些类型之一，那么会出现编译时错误。

permits 是 Java 中用于定义 sealed 类的允许子类集合的关键字，它可以帮助开发人员更加精确地控制类的继承关系，提高代码的可读性和可维护性。

原文：

/*
定义一个sealed类，在permits列表中出现编译错误p.B
正确的写法是使用完整的包名前缀，例如 package.B
sealed class A 表示类 A 是一个 sealed 类，但由于permits列表中的子句错误，代码无法通过编译。
*/
sealed class A permits B, C, p.B {} // error 
//类 B 是一个非 sealed 类，它继承自类 A。由于 A 是 sealed 类，所以 B 可以作为 A 的子类进行扩展。
non-sealed class B extends A {} 
//类 C 是一个非 sealed 类，也继承自类 A。与类 B 一样，C 作为 A 的子类进行扩展。
non-sealed class C extends A {}