HashMap 新的构造方法 Java SE 19，构造哈希表的时候，由于有扩容因子 0.75 的设置，所以如果要开辟一个 120 空间的哈希表，需要如下定义 MapInteger,Integer map1 = new HashMap(160); Java SE 19 中，H
HashMap 新的构造方法
Java SE 19，构造哈希表的时候，由于有扩容因子 0.75 的设置，所以如果要开辟一个 120 空间的哈希表，需要如下定义
Map<Integer,Integer> map1 = new HashMap<>(160);Java SE 19 中，HashMap 有了新的构造方法，可以用 newHashMap 直接指定具体大小，不需要提前做换算。
这个用法类似 Guava的集合构造方式。
如上例，可以使用
Map<Integer, Integer> map2 = HashMap.newHashMap(120);代码如下
import java.util.*;public class NewHashMapMethodTest {
public static void main(String[] arg) {
// jdk 19之前
// 由于有 扩容因子 0.75 的设置，所以如果要开辟一个120的哈希表，需要如下定义
Map<Integer,Integer> map1 = new HashMap<>(160);
for (int i = 0; i < 10; i++) {
map1.put(i,i);
}
System.out.println(map1);
// jdk 19及以后
// 可以用newHashMap直接指定具体大小，不需要提前做换算
Map<Integer, Integer> map2 = HashMap.newHashMap(120);
for (int i = 0; i < 10; i++) {
map2.put(i,i);
}
System.out.println(map2);
}
}
switch 类型匹配增强（第三次预览）
首次引入这个功能是在Java SE 17
switch (obj) {case String s && s.length() > 5 -> System.out.println(s.toUpperCase())。
...
}
我们可以在 switch 语句中检查一个对象是否属于某个特定的类，以及它是否有额外的特征（比如在例子中：长于五个字符）。
在 Java SE 19 中，我们必须使用新的关键字 when 来代替 &&
完整代码如下
package git.snippets.jdk19;/**
* switch 增强 第三次预览
* 需要增加 --enable-preview参数
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/22
* @since 19
*/
public class SwitchEnhancedTest {
public static void main(String[] args) {
checkObjSince19("hello world");
}
public static void checkObjSince19(Object when) {
// when 是一个所谓的 "上下文关键字"，因此只在一个 case 标签中具有意义。如果你的代码中有名称为 "when "的变量或方法，你不需要改变它们。
switch (when) {
case String s when s.length() > 5 -> System.out.println(s.toUpperCase());
case String s -> System.out.println(s.toLowerCase());
case Integer i -> System.out.println(i * i);
default -> {
}
}
}
}
when 是一个所谓的 "上下文关键字"，因此只在一个 case 标签中具有意义。如果你的代码中有名称为 "when "的变量或方法，你不需要改变它们。
record 的匹配增强（预览功能）
switch 和 instanceof 的增强匹配（Java SE 16 新增特性）功能现在可以用于 record，示例代码如下
package git.snippets.jdk19;/**
* record 模式匹配增强
* 需要增加 --enable-preview参数
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/22
* @since 19
*/
public class RecordTest {
public static void main(String[] args) {
Points points = new Points(1, 2);
Line line = new Line(new Points(1, 2), new Points(3, 4));
printPoints(points);
printLine(line);
}
private static void printPoints(Object object) {
if (object instanceof Points(int x,int y)) {
System.out.println("jdk 19 object is a position, x = " + x + ", y = " + y);
}
if (object instanceof Points points) {
System.out.println("pre jdk 19 object is a position, x = " + points.x()
+ ", y = " + points.y());
}
switch (object) {
case Points position -> System.out.println("pre jdk 19 object is a position, x = " + position.x()
+ ", y = " + position.y());
default -> throw new IllegalStateException("Unexpected value: " + object);
}
switch (object) {
case Points(int x,int y) -> System.out.println(" jdk 19 object is a position, x = " + x
+ ", y = " + y);
default -> throw new IllegalStateException("Unexpected value: " + object);
}
}
public static void printLine(Object object) {
if (object instanceof Line(Points(int x1,int y1),Points(int x2,int y2))) {
System.out.println("object is a path, x1 = " + x1 + ", y1 = " + y1
+ ", x2 = " + x2 + ", y2 = " + y2);
}
switch (object) {
case Line(Points(int x1,int y1),Points(int x2,int y2)) ->
System.out.println("object is a path, x1 = " + x1 + ", y1 = " + y1
+ ", x2 = " + x2 + ", y2 = " + y2);
// other cases ...
default -> throw new IllegalStateException("Unexpected value: " + object);
}
}
}
record Points(int x, int y) {
}
record Line(Points from, Points to) {
}
虚拟线程（预览功能）
虚拟线程在 Project Loom中已经开发了好几年，到目前为止只能用自编译的JDK进行测试。
Foreign Function 和 Memory API (预览功能)
在 Project Panama中，取代繁琐、易出错、速度慢的 Java 本地接口（JNI）的工作已经进行了很长时间。
在 Java 14 和 Java 16 中已经引入了 "外来内存访问 API "和 "外来链接器 API"--最初都是单独处于孵化阶段。在 Java 17 中，这些 API 被合并为 "Foreign Function & Memory API"（FFM API），直到 Java 18，它一直处于孵化阶段。
在 Java 19 中， JDK Enhancement Proposal 424最终将新的 API 提升到了预览阶段，
FFM API 可以直接从 Java 访问本地内存（即 Java 堆外的内存）和访问本地代码（如 C 库）。
下面是一个简单的例子，它在堆外内存中存储一个字符串，并对其调用 C 语言标准库的 "strlen "函数。
package git.snippets.jdk19;import java.lang.foreign.FunctionDescriptor;
import java.lang.foreign.Linker;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.SymbolLookup;
import java.lang.invoke.MethodHandle;
import static java.lang.foreign.SegmentAllocator.implicitAllocator;
import static java.lang.foreign.ValueLayout.ADDRESS;
import static java.lang.foreign.ValueLayout.JAVA_LONG;
/**
* FFM API
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/22
* @since 19
*/
public class FFMTest {
public static void main(String[] args) throws Throwable {
// 1\. Get a lookup object for commonly used libraries
SymbolLookup stdlib = Linker.nativeLinker().defaultLookup();
// 2\. Get a handle to the "strlen" function in the C standard library
MethodHandle strlen = Linker.nativeLinker().downcallHandle(
stdlib.lookup("strlen").orElseThrow(),
FunctionDescriptor.of(JAVA_LONG, ADDRESS));
// 3\. Convert Java String to C string and store it in off-heap memory
MemorySegment str = implicitAllocator().allocateUtf8String("Happy Coding!");
// 4\. Invoke the foreign function
long len = (long) strlen.invoke(str);
System.out.println("len = " + len);
}
}
结构化并发（孵化器）
如果一个任务由不同的子任务组成，可以并行完成（例如，从数据库访问数据、调用远程 API 和加载文件），我们可以使用 Java 多线程的一些工具类来完成。
例如：
private final ExecutorService executor = Executors.newCachedThreadPool();// jdk 19 之前
public Invoice createInvoice(int orderId, int customerId, String language) throws ExecutionException, InterruptedException {
Future<Order> orderFuture = executor.submit(() -> loadOrderFromOrderService(orderId));
Future<Customer> customerFuture = executor.submit(() -> loadCustomerFromDatabase(customerId));
Future<String> invoiceTemplateFuture = executor.submit(() -> loadInvoiceTemplateFromFile(language));
Order order = orderFuture.get();
Customer customer = customerFuture.get();
String invoiceTemplate = invoiceTemplateFuture.get();
return Invoice.generate(order, customer, invoiceTemplate);
}
但是：
如果一个子任务发生错误--我们如何取消其他子任务？
如果某个子任务不需要了，我们如何取消这个子任务呢？
这两种情况都可以，但需要相当复杂和难以维护的代码。
而如果我们想对这种类型的并发代码进行调试也非常麻烦。
JDK Enhancement Proposal 428为所谓的 "结构化并发 "引入了一个 API，这个概念旨在改善这种类型需求的代码的实现、可读性和可维护性。
使用 StructuredTaskScope，我们可以把这个例子改写成如下。
public Invoice createInvoiceSinceJava19(int orderId, int customerId, String language)throws ExecutionException, InterruptedException {
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Future<Order> orderFuture =
scope.fork(() -> loadOrderFromOrderService(orderId));
Future<Customer> customerFuture =
scope.fork(() -> loadCustomerFromDatabase(customerId));
Future<String> invoiceTemplateFuture =
scope.fork(() -> loadInvoiceTemplateFromFile(language));
scope.join();
scope.throwIfFailed();
Order order = orderFuture.resultNow();
Customer customer = customerFuture.resultNow();
String invoiceTemplate = invoiceTemplateFuture.resultNow();
return new Invoice(order, customer, invoiceTemplate);
}
}
使用 StructuredTaskScope，我们可以将 executor.submit() 替换为 scope.fork() 。
使用 scope.join() ，我们等待所有任务完成--或者至少有一个任务失败或被取消。在后两种情况下，随后的 throwIfFailed() 会抛出一个 ExecutionException 或一个 CancellationException 。
与旧方法相比，新方法带来了以下改进。
完整代码如下：
package git.snippets.jdk19;import jdk.incubator.concurrent.StructuredTaskScope;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* 预览功能
* 控制台运行
* 1\. 配置Java运行环境是JDK 19
* 2\. 注释掉 package 路径
* 3\. 在本代码的目录下执行
* 编译：javac --enable-preview -source 19 --add-modules jdk.incubator.concurrent StructuredConcurrencyTest.java
*运行：java --enable-preview --add-modules jdk.incubator.concurrent StructuredConcurrencyTest
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/22
* @since 19
*/
public class StructuredConcurrencyTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
new StructuredConcurrencyTest().createInvoiceSinceJava19(1, 2, "ZH");
}
private final ExecutorService executor = Executors.newCachedThreadPool();
// jdk 19 之前
public Invoice createInvoice(int orderId, int customerId, String language) throws ExecutionException, InterruptedException {
Future<Order> orderFuture = executor.submit(() -> loadOrderFromOrderService(orderId));
Future<Customer> customerFuture = executor.submit(() -> loadCustomerFromDatabase(customerId));
Future<String> invoiceTemplateFuture = executor.submit(() -> loadInvoiceTemplateFromFile(language));
Order order = orderFuture.get();
Customer customer = customerFuture.get();
String invoiceTemplate = invoiceTemplateFuture.get();
return Invoice.generate(order, customer, invoiceTemplate);
}
// jdk 19 之后
public Invoice createInvoiceSinceJava19(int orderId, int customerId, String language)
throws ExecutionException, InterruptedException {
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Future<Order> orderFuture =
scope.fork(() -> loadOrderFromOrderService(orderId));
Future<Customer> customerFuture =
scope.fork(() -> loadCustomerFromDatabase(customerId));
Future<String> invoiceTemplateFuture =
scope.fork(() -> loadInvoiceTemplateFromFile(language));
scope.join();
scope.throwIfFailed();
Order order = orderFuture.resultNow();
Customer customer = customerFuture.resultNow();
String invoiceTemplate = invoiceTemplateFuture.resultNow();
return new Invoice(order, customer, invoiceTemplate);
}
}
private String loadInvoiceTemplateFromFile(String language) {
return language;
}
private Customer loadCustomerFromDatabase(int customerId) {
return new Customer(customerId);
}
private Order loadOrderFromOrderService(int orderId) {
return new Order(orderId);
}
}
class Invoice {
// TODO
public Invoice(Order order, Customer customer, String invoiceTemplate) {
}
public static Invoice generate(Order order, Customer customer, String invoiceTemplate) {
return null;
}
}
class Order {
private int id;
public Order(int orderId) {
this.id = orderId;
}
}
class Customer {
private int id;
public Customer(int customerId) {
this.id = customerId;
}
}
Vector API（第四次预览）
新的 Vector API与 java.util.Vector 类没有关系。事实上，它是关于数学向量计算的新 API 及其与现代SIMD（单指令-多数据）CPU的映射。
弃用和删除的一些 API
在 Java SE 19 中，一些函数被标记为 "废弃 "或无法使用。
废弃的 Locale 类构造函数
在 Java SE 19 中，Locale 类的公共构造函数被标记为 "弃用"。
相反，我们应该使用新的静态工厂方法 Locale.of() 。这可以确保每个 Locale 配置只有一个实例。
下面的例子显示了与构造函数相比工厂方法的使用情况。
示例代码如下
package git.snippets.jdk19;import java.util.Locale;
/**
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/22
* @since 19
*/
public class LocaleTest {
public static void main(String[] args) {
Locale german1 = new Locale("de"); // deprecated
Locale germany1 = new Locale("de", "DE"); // deprecated
Locale german2 = Locale.of("de");
Locale germany2 = Locale.of("de", "DE");
System.out.println("german1 == Locale.GERMAN = " + (german1 == Locale.GERMAN));
System.out.println("germany1 == Locale.GERMANY = " + (germany1 == Locale.GERMANY));
System.out.println("german2 == Locale.GERMAN = " + (german2 == Locale.GERMAN));
System.out.println("germany2 == Locale.GERMANY = " + (germany2 == Locale.GERMANY));
}
}
java.lang.ThreadGroup
在 Java SE 14 和 Java SE 16 中，有几个 Thread 和 ThreadGroup 方法被标记为 "被废弃"
以下这些方法在 Java 19 中已被停用。
ThreadGroup.destroy(); //- 该方法的调用将被忽略。ThreadGroup.isDestroyed() ;//- 总是返回false。
ThreadGroup.setDaemon() ; //- 设置守护者标志，但这已经没有效果了。
ThreadGroup.suspend();//会抛出一个UnsupportedOperationException。
ThreadGroup.resume();//会抛出一个UnsupportedOperationException。
ThreadGroup.stop();//会抛出一个UnsupportedOperationException。