如题：

  • Records（记录类）的增强：

    • 　Java 16进一步增强了记录类的功能，包括允许在记录类中添加静态成员和实现接口。

    •    示例代码：
    •  1 public class RecordExample {
 2     public static void main(String[] args) {
 3         Person person = new Person("John Doe", 30);
 4         System.out.println(person.name());
 5         System.out.println(person.age());
 6         System.out.println(Person.GREETING);
 7     }
 8 }
 9 
10 record Person(String name, int age) {
11     static final String GREETING = "Hello";
12 
13     public Person {
14         if (age < 0) {
15             throw new IllegalArgumentException("Age cannot be negative");
16         }
17     }
18 }

      在上面的示例中，我们定义了一个记录类Person，它包含了name和age两个属性。我们还在记录类中添加了一个静态成员GREETING。注意，在记录类中，我们可以使用构造函数来添加验证逻辑。在main方法中，我们创建了一个Person对象，并访问了其属性和静态成员。

 

  • Pattern Matching for instanceof（instanceof模式匹配）的增强：

    • 　Java 16扩展了instanceof模式匹配的能力，允许在条件判断中使用模式变量。

    •    示例代码：
    •  1 public class PatternMatchingExample {
 2     public static void main(String[] args) {
 3         Object obj = "Hello";
 4 
 5         if (obj instanceof String str) {
 6             System.out.println(str.length());
 7         } else {
 8             System.out.println("Not a string");
 9         }
10     }
11 }

      在上面的示例中，我们使用instanceof模式匹配来判断obj是否是String类型。如果是，我们将其赋值给模式变量str，然后可以在条件块中直接访问str的方法和属性。

 

  • Sealed Classes（密封类）的增强：

    • 　Java 16引入了更灵活的密封类定义方式，允许在接口和抽象类上使用sealed修饰符，以及使用permits子句指定允许继承的类。

    •    示例代码：
    •  1 public sealed interface Animal permits Dog, Cat {
 2     void makeSound();
 3 }
 4 
 5 final class Dog implements Animal {
 6     @Override
 7     public void makeSound() {
 8         System.out.println("Woof!");
 9     }
10 }
11 
12 final class Cat implements Animal {
13     @Override
14     public void makeSound() {
15         System.out.println("Meow!");
16     }
17 }
18 
19 public class SealedClassExample {
20     public static void main(String[] args) {
21         Animal animal1 = new Dog();
22         Animal animal2 = new Cat();
23 
24         animal1.makeSound();
25         animal2.makeSound();
26     }
27 }

      在上面的示例中，我们定义了一个密封接口Animal，并使用permits子句指定了允许继承的类。然后我们定义了Dog和Cat类来实现Animal接口。在main方法中，我们创建了Dog和Cat对象，并调用它们的makeSound()方法。

 

  • Records（记录类）和模式匹配的集成：

    • 　Java 16将记录类和模式匹配相结合，允许在模式匹配中使用记录类的模式。

    •    示例代码：
    •  1 public record Person(String name, int age) {
 2 }
 3 
 4 public class RecordsExample {
 5     public static void main(String[] args) {
 6         Person person = new Person("John Doe", 30);
 7 
 8         if (person instanceof Person p) {
 9             System.out.println("Name: " + p.name());
10             System.out.println("Age: " + p.age());
11         }
12     }
13 }

      在上面的示例中，我们定义了一个Person记录类，它具有name和age属性。然后，我们创建了一个Person对象，并使用instanceof模式匹配来判断对象的类型。如果对象是Person类型，我们将其赋值给模式变量p，然后可以直接访问p的属性。

 

  • 更好的垃圾收集器：

    • 　Java 16引入了一个新的垃圾收集器称为ZGC，它提供了更低的停顿时间和更高的吞吐量。

    •    示例代码：
    •  1 public class GarbageCollectorExample {
 2     public static void main(String[] args) {
 3         System.out.println("Max memory: " + Runtime.getRuntime().maxMemory() / 1024 / 1024 + " MB");
 4 
 5         List<String> list = new ArrayList<>();
 6         for (int i = 0; i < 1000000; i++) {
 7             list.add("Item " + i);
 8         }
 9 
10         System.out.println("List size: " + list.size());
11 
12         list = null; // 设置为null，释放内存
13 
14         System.gc(); // 显式触发垃圾收集
15 
16         System.out.println("List size after GC: " + list.size());
17     }
18 }

      在上面的示例中，我们使用了Java 16引入的ZGC垃圾收集器。我们创建了一个包含1000000个字符串的列表，并将其设置为null以释放内存。然后，我们使用System.gc()显式触发垃圾收集。最后，我们打印列表的大小，以验证垃圾收集是否成功。

 

  • Unix域套接字通信API：

    • 　Java 16引入了Unix域套接字通信API，使得Java应用程序可以直接与本地Unix域套接字进行通信。

    •    示例代码：
    •  1 import java.io.IOException;
 2 import java.net.Socket;
 3 import java.net.SocketAddress;
 4 import java.nio.file.Path;
 5 import java.nio.file.Paths;
 6 import java.nio.file.StandardOpenOption;
 7 
 8 public class UnixSocketExample {
 9     public static void main(String[] args) {
10         try {
11             Path socketPath = Paths.get("/tmp/mysocket.sock");
12 
13             // 创建Unix域套接字
14             Socket socket = Socket.newSocket(SocketAddress.of(socketPath));
15 
16             // 发送数据
17             socket.getOutputStream().write("Hello, Unix Domain Socket!".getBytes());
18 
19             // 关闭套接字
20             socket.close();
21         } catch (IOException e) {
22             e.printStackTrace();
23         }
24     }
25 }

      在上面的示例中，我们使用Java 16引入的Unix域套接字通信API。我们创建了一个Unix域套接字，并通过套接字的输出流发送数据。然后，我们关闭套接字。

 

  • 移除警告：

    • 　Java 16删除了一些过时的API和功能，并发出了相关警告，以便开发者能够及时更新和修改代码。