Java 17 新特性尝鲜

JDK 17更新了包括14个特性，具体如下表所示：

Restore Always-StrictFloating-Point Semantics 恢复始终严格模式（Always-Strict）的浮点语义
EnhancedPseudo-Random Number Generators 增强型伪随机数生成器
New macOS RenderingPipeline 新增macOS渲染管道
macOS/AArch64 Port 支持将JDK移植到macOS或AArch64
Deprecate the AppletAPI for Removal 弃用待移除的Applet API

注：JDK 9中的JEP 289先前已弃用Applet API，但并未将其删除。

Strongly EncapsulateJDK Internals 强封装JDK内部API
Pattern Matching forswitch (Preview) switch模式匹配进入预览（Preview）阶段
Remove RMI Activation 移除RMI（远程方法调用）激活机制
Sealed Classes 密封类

注：密封类是由JEP 360提出的，并在JDK 15中作为预览功能提供。它们由JEP 397再次提出并进行了改进，并作为预览功能在JDK 16中提供。该JEP建议在JDK17中完成密封类，与JDK 16没有任何变化。

Remove theExperimental AOT and JIT Compiler 移除实验性AOT和JIT编译器
Deprecate theSecurity Manager for Removal 弃用待移除的安全管理器（Security Manager）

注：弃用安全管理器，在后续版本中移除。安全管理器可追溯到Java 1.0。多年来，它一直不是保护客户端Java代码的主要手段，也很少用于保护服务器端代码。为了推动Java向前发展，Oracle打算弃用安全管理器，以便与旧Applet API（JEP 398）一起删除。

Foreign Function& Memory API (Incubator) 外部函数和内存API（孵化器）孵化阶段

注：Java程序可以通过该API与Java运行时之外的代码和数据进行互操作。通过有效调用外部函数（即JVM之外的代码），以及安全地访问外部内存（即不由JVM管理的内存），API使Java程序能够调用本地库和处理本地数据，而没有JNI。[关于JDK17新特性开发应用，关注公众号Java精选，后续文章更新]

Vector API (SecondIncubator) Vector API（第二孵化器）第二孵化阶段

注：引入一个API来表达向量计算，这些计算在运行时可靠地编译为支持的CPU架构上的最佳向量指令，从而实现优于等效标量计算的性能。

Context-SpecificDeserialization Filters 上下文特定的反序列化过滤器

注：允许应用程序通过JVM范围的过滤器工厂配置特定于上下文和动态选择的反序列化过滤器，该工厂被调用以为每个单独的反序列化操作选择一个过滤器。[关于JDK17新特性开发应用，关注公众号Java精选，后续文章更新]

至于Spring，其官方曾宣布Spring Framework 6.0和Spring Boot 3.0将基于JDK 17版本，预计2022年，下半年发布 Spring Framework 6.0正式候选（RC）版本。

代码层面

文本块
switch表达式
record关键字
sealed classes密封类
instanceof模式匹配
Helpful NullPointerExceptions
日期周期格式化
精简数字格式化支持
Stream.toList()简化

文本块

在Java17之前的版本里，定义一个字符串，比如一个JSON数据，基本都是如下拼接方式定义：

public void lowVersion() { 
    String text = "{\n" + " \"name\": \"小黑说Java\",\n" + " \"age\": 18,\n" + "         
     \"address\": \"北京市西城区\"\n" + "}"; System.out.println(text); 
}

通过Java 17中的类似的字符串处理则会方便很多；通过三个双引号可以定义一个文本块，并且结束的三个双引号不能和开始的在同一行。文本块语法代码如下：

private void highVersion() {
  String text = """{"name":"小黑说Java", "age": 18, "address": "北京市西城区"}"""; 
  System.out.println(text); 
}

这段代码的输出结果是：

{ "name": "小黑说Java", "age": 18, "address": "北京市西城区" }

switch表达式

Java 17版本中switch表达式将允许switch有返回值，并且可以直接作为结果赋值给一个变量，等等一系列的变化。

下面有一个switch例子，依赖于给定的枚举值，执行case操作，故意省略break。

private static void lowVesion(Fruit fruit) { 
    switch (fruit) { 
            case APPLE, PEAR: System.out.println("普通水果");break;
            case MANGO, AVOCADO: System.out.println("进口水果"); break;
            default: System.out.println("未知水果"); 
    } 
}

调用这个方法传入一个APPLE，会输出以下结果：

普通水果 进口水果 未知水果

通过switch表达式来进行简化。将冒号（:）替换为箭头（->），并且switch表达式默认不会失败，所以不需要break。

private static void withSwitchExpression(Fruit fruit) { 
    switch (fruit) { 
        case APPLE, PEAR -> System.out.println("普通水果"); 
        case MANGO, AVOCADO -> System.out.println("进口水果"); 
        default -> System.out.println("未知水果"); 
    } 
}

switch表达式也可以返回一个值，比如上面的例子可以让switch返回一个字符串来表示要打印的文本。需要注意在switch语句的最后要加一个分号。

private static void withReturnValue(Fruit fruit) { 
    String text = switch (fruit) { 
            case APPLE, PEAR -> "普通水果"; 
            case MANGO, AVOCADO -> "进口水果"; 
            default -> "未知水果"; 
        }; 
    System.out.println(text); 
}

也可以直接省略赋值动作直接打印。

private static void withReturnValue(Fruit fruit) { 
    System.out.println(switch (fruit) { 
            case APPLE, PEAR -> "普通水果"; 
            case MANGO, AVOCADO -> "进口水果"; 
            default -> "未知水果"; 
     }); 
}

如果想在case里想做不止一件事，比如在返回之前先进行一些计算或者打印操作，可以通过大括号来作为case块，最后的返回值使用关键字yield进行返回。

private static void withYield(Fruit fruit) { 
    String text = switch (fruit) { 
        case APPLE, PEAR -> { System.out.println("给的水果是: " + fruit); yield "普通水果";} 
        case MANGO, AVOCADO -> "进口水果";
        default -> "未知水果"; 
    }; 
    System.out.println(text); 
}

这个输出结果是：

给的水果是: APPLE 普通水果

也可以直接使用yield返回结果。

private static void oldStyleWithYield(Fruit fruit) { 
    System.out.println(switch (fruit) {
         case APPLE, PEAR: yield "普通水果"; 
         case MANGO, AVOCADO: yield "进口水果"; 
         default: yield "未知水果"; 
    }); 
}

record关键字

record用于创建不可变的数据类。在这之前如果需要创建一个存放数据的类，通常需要先创建一个Class，然后生成构造方法、getter、setter、hashCode、equals和toString等这些方法，或者使用Lombok来简化这些操作。

比如定义一个Person类：

//这里使用lombok减少代码 
@Data 
@AllArgsConstructor 
public class Person {
    private String name; 
    private int age; 
    private String address; 
}

通过Person类做一些测试，比如创建两个对象，对他们进行比较，打印这些操作。

public static void testPerson() { 
    Person p1 = new Person("小黑说Java", 18, "北京市西城区"); 
    Person p2 = new Person("小白说Java", 28, "北京市东城区"); 
    System.out.println(p1); 
    System.out.println(p2); 
    System.out.println(p1.equals(p2)); 
}

假设有一些场景只需要对Person的name和age属性进行打印，在有record之后将会变得非常容易。

public static void testPerson() { 
    Person p1 = new Person("小黑说Java", 18, "北京市西城区"); 
    Person p2 = new Person("小白说Java", 28, "北京市东城区"); 
    // 使用record定义 
    record PersonRecord(String name,int age){} 
    PersonRecord p1Record = new PersonRecord(p1.getName(), p1.getAge()); 
    PersonRecord p2Record = new PersonRecord(p2.getName(), p2.getAge());             
    System.out.println(p1Record); 
    System.out.println(p2Record); 
}

record也可以单独定义作为一个文件定义，但是因为Record的使用非常紧凑，所以可以直接在需要使用的地方直接定义。

public record PersonRecord(String name, int age){
    
}

record同样也有构造方法，可以在构造方法中对数据进行一些验证操作。

public static void testPerson() { 
    Person p1 = new Person("小黑说Java", 18, "北京市西城区"); 
    Person p2 = new Person(null, 28, "北京市东城区"); 
    record PersonRecord(String name, int age) { 
        // 构造方法 
        PersonRecord { 
            System.out.println("name " + name + " age " + age); 
            if (name == null) { 
                throw new IllegalArgumentException("姓名不能为空");
            } 
        } 
    } 
    PersonRecord p1Record = new PersonRecord(p1.getName(), p1.getAge()); 
    PersonRecord p2Record = new PersonRecord(p2.getName(), p2.getAge()); 
}

密封类 sealed class

密封类可以让更好的控制哪些类可以对定义的类进行扩展。密封类可能对于框架或中间件的开发者更有用。在这之前一个类要么是可以被extends的，要么是final的，只有这两种选项。

密封类可以控制有哪些类可以对超类进行继承，在Java 17之前如果需要控制哪些类可以继承，可以通过改变类的访问级别，比如去掉类的public，访问级别为。比默认如在com.everlight.java11包中定义了如下的三个类：

package com.everlight.java11; 
public abstract class Furit { } 
public class Apple extends Furit { } 
public class Pear extends Furit { }

那么可以在另一个包com.everlight.java11中写如下的代码：

private static void test() { 
    Apple apple = new Apple(); 
    Pear pear = new Pear(); 
    Fruit fruit = apple; 
    class Avocado extends Fruit {}; 
}

既可以定义Apple，Pear，也可以将apple实例赋值给Fruit，并且可以对Fruit进行继承。

如果不想让Fruit在com.everlight.java11包以外被扩展，在Java11版本中只能改变访问权限，去掉class的public修饰符。这样虽然可以控制被被继承，但是也会导致Fruit fruit = apple;也编译失败；在Java 17中通过密封类可以解决这个问题。

package com.everlight.java17; 
public abstract sealed class Furit permits Apple,Pear { } 
public non-sealed class Apple extends Furit { }
public final class Pear extends Furit { }

在定义Furit时通过关键字sealed声明为密封类，通过permits可以指定Apple,Pear类可以进行继承扩展。

子类需要指明它是final,non-sealed或sealed的。父类不能控制子类是否可以被继承。

private static void test() { 
    Apple apple = new Apple(); 
    Pear pear = new Pear(); 
    // 可以将apple赋值给
    Fruit Fruit fruit = apple; 
    // 只能继承Apple，不能继承
    Furit class Avocado extends Apple {}; 
}

instanceof模式匹配

通常使用instanceof时，一般发生在需要对一个变量的类型进行判断，如果符合指定的类型，则强制类型转换为一个新变量。

private static void oldStyle(Object o) { 
    if (o instanceof Furit) { 
        Furit furit = (GrapeClass) o; 
        System.out.println("This furit is :" + furit.getName); 
    } 
}

在使用instanceof的模式匹配后，上面的代码可进行简写。

private static void oldStyle(Object o) { 
    if (o instanceof Furit furit) { 
        System.out.println("This furit is :" + furit.getName); 
    } 
}

可以将类型转换和变量声明都在if中处理。同时，可以直接在if中使用这个变量。

private static void oldStyle(Object o) { 
    if (o instanceof Furit furit && furit.getColor()==Color.RED) { 
        System.out.println("This furit is :" + furit.getName); 
    } 
}

因为只有当instanceof的结果为true时，才会定义变量furit，所以这里可以使用&&，但是改为||就会编译报错。

Helpful NullPointerExceptions

Helpful NullPointerExceptions可以在遇到NPE时节省一些分析时间。如下的代码会导致一个NPE。

public static void main(String[] args) { 
    Person p = new Person(); 
    String cityName = p.getAddress().getCity().getName(); 
}

在Java 11中，输出将显示NullPointerException发生的行号，但不知道哪个方法调用时产生的null，必须通过调试的方式找到。

Exception in thread "main" java.lang.NullPointerException at 
com.everlight.java17.HelpfulNullPointerExceptionsDemo.main(HelpfulNullPointerExceptionsDemo.java
:13)

在Java 17中，则会准确显示发生NPE的精确位置。

Exception in thread "main" java.lang.NullPointerException: Cannot invoke 
"com.everlight.java17.Address.getCity()" because the return value of 
"com.everlight.java17.Person.getAddress()" is null at 
com.everlight.java17.HelpfulNullPointerExceptionsDemo.main(HelpfulNullPointerExceptionsDemo.java
:13)

日期周期格式化

在Java 17中添加了一个新的模式B,用于格式化DateTime,它根据Unicode标准指示一天时间段。

使用默认的英语语言环境，打印一天的几个时刻：

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("B"); 
System.out.println(dtf.format(LocalTime.of(8, 0))); 
System.out.println(dtf.format(LocalTime.of(13, 0))); 
System.out.println(dtf.format(LocalTime.of(20, 0))); 
System.out.println(dtf.format(LocalTime.of(23, 0))); 
System.out.println(dtf.format(LocalTime.of(0, 0)));

输出结果：

in the morning in the afternoon in the evening at night midnight

如果是中文语言环境，则输出结果为：

上午 下午 晚上 晚上 午夜

可见java17的晚上是包括英美国家的evening和night的。

精简数字格式化支持

在NumberFormat中添加了一个工厂方法，可以根据Unicode标准以紧凑的、人类可读的形式格式化数字。

short格式如下所示:

NumberFormat fmt = NumberFormat
                    .getCompactNumberInstance(Locale.ENGLISH, NumberFormat.Style.SHORT); 
System.out.println(fmt.format(1000)); 
System.out.println(fmt.format(100000)); 
System.out.println(fmt.format(1000000));

输出格式为：

1K 100K 1M

long格式如下所示：

fmt = NumberFormat.getCompactNumberInstance(Locale.ENGLISH, NumberFormat.Style.LONG); 
System.out.println(fmt.format(1000)); 
System.out.println(fmt.format(100000)); 
System.out.println(fmt.format(1000000));

输出结果为：

1 thousand 100 thousand 1 million

Stream.toList()

如果需要将Stream转换成List,需要通过调用collect方法使用Collectors.toList()，代码非常冗长。

private static void oldStyle() { 
    Stream<String> stringStream = Stream.of("a", "b", "c"); 
    List<String> stringList = stringStream.collect(Collectors.toList()); 
    for(String s : stringList) { 
        System.out.println(s); 
    } 
}

在Java 17中将会变得简单，可以直接调用toList()。

private static void streamToList() { 
    Stream<String> stringStream = Stream.of("a", "b", "c");
    List<String> stringList = stringStream.toList();
    for(String s : stringList) { 
        System.out.println(s); 
    } 
}