Java 17的这些新特性，Java迈入新时代

前言

2021年9月14日Java 17发布，作为新时代的农民工，有必要了解一下都有哪些新东西。

Java 17是Java 11以来又一个LTS（长期支持）版本，Java 11 和Java 17之间发生了那些变化可以在OpenJDK官网找到JEP（Java增强建议）的完整列表。

本期文章会重点介绍在语法方面Java 17的更新，并且通过一些代码示例让大家更容易理解，主要涉及以下9个点：

• 文本块

• 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); }

这种方式定义具有几个问题：

• 双引号需要进行转义；

• 为了字符串的可读性需要通过+号连接；

• 如果需要将JSON复制到代码中需要做大量的格式调整（当然这一点也可以通过其他工具解决）；

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

上面例子中的JSON可以更方便，可读性更好的通过文本块定义。代码如下：

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("普通水果"); case MANGO, AVOCADO: System.out.println("进口水果"); default: System.out.println("未知水果"); } }

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

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

显然这不是期望的结果，因为我们需要在每个case里添加break防止所有的case都没执行。

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("未知水果"); } }

可以通过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的使用非常紧凑，所以可以直接在需要使用的地方直接定义。

​

编辑切换为居中

添加图片注释，不超过 140 字（可选）

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.heiz.java11包中定义了如下的三个类：

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

那么我们可以在另一个包com.heiz123.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.heiz.java11包以外被扩展，在Java11版本中只能改变访问权限，去掉class的public修饰符。这样虽然可以控制被被继承，但是也会导致Fruit fruit = apple;也编译失败；在Java 17中通过密封类可以解决这个问题。

package com.heiz.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.heiz.java17.HelpfulNullPointerExceptionsDemo.main(HelpfulNullPointerExceptionsDemo.java:13)

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

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "com.heiz.java17.Address.getCity()" because the return value of "com.heiz.java17.Person.getAddress()" is null at com.heiz.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

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

上午 下午 晚上 晚上 午夜

可见咱们的晚上是包括英美国家的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); } } 复制代码

 

                                   资源获取：

大家点赞、收藏、关注、评论啦 、查看👇🏻👇🏻👇🏻微信公众号获取联系方式👇🏻👇🏻👇🏻

 精彩专栏推荐订阅：在下方专栏👇🏻👇🏻👇🏻👇🏻

每天学四小时：Java+Spring+JVM+分布式高并发，架构师指日可待