JDK 新版本中都有哪些新特性？

最新推荐文章于 2024-07-24 17:27:32 发布

协享科技

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量173

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/smile_tianya/article/details/132421242

版权

Java 专栏收录该内容

55 篇文章 2 订阅

订阅专栏

面试回答

JDK 8 推出了 Lambda 表达式、Stream、Optional、新的日期 API 等

JDK 9 中推出了模块化

JDK 10 中推出了本地变量类型推断

JDK 12 中增加了 switch 表达式

JDK 13 中增加了 text block

JDK 14 中增加了 Records

JDK 15 中增加了封闭类

JDK 17 中扩展了 switch 模式匹配

JDK 19 中增加了协程

知识扩展

Stream

Java 8引入了Stream API，它提供了一种简洁、灵活且功能强大的方式来处理集合数据。

Optional

Java 8引入了Optional类，它是一个用于处理可能为空（null）值的容器类。Optional提供了一种优雅的方式来避免空指针异常，并使代码更加健壮和可读。

创建Optional对象

Optional.empty()：创建一个空的Optional对象。
Optional.of(value)：将非空的值包装在Optional对象中，如果value为空，则抛出NullPointerException。
Optional.ofNullable(value)：将值包装在Optional对象中，如果value为空，则创建一个空的Optional对象。

判断Optional对象是否包含值

isPresent()：判断Optional对象是否包含非空值。
isEmpty()（Java 11+）：判断Optional对象是否为空。

获取Optional对象中的值

get()：获取Optional对象中的值，如果值为空，则抛出NoSuchElementException异常。
orElse(defaultValue)：获取Optional对象中的值，如果值为空，则返回defaultValue作为默认值。
orElseGet(Supplier)：获取Optional对象中的值，如果值为空，则通过Supplier提供的函数生成一个默认值。
orElseThrow(ExceptionSupplier)：获取Optional对象中的值，如果值为空，则通过ExceptionSupplier提供的函数抛出自定义异常。

链式操作

map(Function)：对Optional对象中的值进行映射转换。
flatMap(Function)：对Optional对象中的值进行扁平化处理。
filter(Predicate)：对Optional对象中的值进行过滤。
ifPresent(Consumer)：如果Optional对象中的值非空，则执行给定的操作。

使用Optional可以更安全地处理可能为空的值，避免了繁琐的空指针检查和异常处理。它提供了一种优雅的方式来处理可能缺失的值，并鼓励编写更健壮、可读性更高的代码。

请注意，尽管Optional可以有效地处理空值，但在某些情况下，过度使用Optional可能会使代码变得复杂和冗长。因此，在使用Optional时应考虑适当的场景和平衡。

代码示例：


public class Main {


    public static void main(String[] args) {
        String name = "John";
        Optional<String> optionalName = Optional.ofNullable(name);

        // 检查Optional是否包含值
        if (optionalName.isPresent()) {
            System.out.println("Name is present: " + optionalName.get());
        } else {
            System.out.println("Name is absent");
        }

        // 使用orElse方法获取Optional的值，如果没有值则返回默认值
        String defaultName = optionalName.orElse("Default");
        System.out.println("Default name: " + defaultName);

        // 使用map方法对Optional的值进行转换
        Optional<String> upperCaseName = optionalName.map(String::toUpperCase);
        System.out.println("Upper case name: " + upperCaseName.orElse("No name"));

        // 使用flatMap方法对Optional的值进行扁平化处理
        Optional<String> flatMapExample = optionalName.flatMap(Main::getString);
        System.out.println("Flat map example: " + flatMapExample.orElse("No value"));
    }

    public static Optional<String> getString(String input) {
        if (input.isEmpty()) {
            return Optional.empty();
        }
        return Optional.of("Processed " + input);
    }

}

输出如下：

Name is present: John
Default name: John
Upper case name: JOHN
Flat map example: Processed John

本地变量类型推断

在 Java 10 之前的版本中，我们想要定义局部变量时。我们需要在赋值的左侧提供显式类型，并在赋值的右边提供实现类型：

MyObject value=new MyObject();

在 Java 10 中，提供了本地变量类型推断的功能，可以通过 var 声明变量:

var value = new MyObject();

本地变量类型推断引入 “var”关键字，而不需要显式的规范变量的类型。

其实，所谓的本地变量类型推断，也是 java 10 提供给开发者的语法糖。

虽然我们在代码中使用 var 进行了定义，但是对于虚拟机来说他是不认识这个 var 的，在 java 文件编译成 class 文件的过程中，会进行解糖，使用变量真正的类型来替代 var。

Switch 表达式

在 JDK 12 中引入了 Switch 表达式作为预览特性。并在 Java 13 中修改了这个特性，引入了 yield 语句，用于返回值。

而在之后的 java 14 中，这一功能正式作为标准功能提供出来。

在以前，我们想要在 switch 中返回内容，还是比较麻烦的，一般语法如下：

    int i;
    switch (x) {
        case "1":
            i = 1;
            break;
        case "2":
            i = 2;
            break;
        default:
            i = x.length();
            break;
    }

在 JDK13 中使用一下语法：

int i = switch (x) {
    case "1" -> 1;
    case "2" -> 2;
    default -> {
        int len = x.length();
        yield len;
    }
};

或者：

    int i = switch (x) {
        case "1" :yield 1;
        case "2" :yield 2;
        default : {
            int len = x.length();
            yield len;
        }
    };

在这之后，switch 中就多了一个关键字用于跳出 switch 块了，那就是 yield，他用于返回一个值。

和 return 的区别在于： return 会直接跳出当前循环或者方法，而 yield 只会跳出当前 switch 块。

Text Blocks

Java 13 中提供了一个 Text Blocks 的预览特性，并且在 Java 14 中提供了第二个版本的预览。

text block，文本块，是一个多行字符串文字，它避免了对大多数转义序列的需要，以可预测的方式自动格式化字符串，并在需要时让开发人员控制格式。

我们以前从外部 copy 一段文本串到 Java 中，会被自动转义，如有一段以下字符串：

<html>
<body>
    <p>hello,world</p>
</body>
</html>

将其复制到 Java 的字符串中，会展示成以下内容：

"<html>\n" +
"    <body>\n" +
"        <p>hello,world</p>\n" +
"    </body>\n" +
"</html>"

即被自动进行了转义，这样的字符串看起来不是很直观，在 JDK 13 中，就可以使用一下语法了：

"""
<html>
    <body>
        <p>hello,world</p>
    </body>
</html>
"""

使用 """ 作为文本块的开始符和结束符，在其中就可以放置多行的字符串，不需要进行任何转义。看起来就十分清爽了。

如常见的 SQL 语句：

String query = """
        SELECT l.* FROM lin_log l
        WHERE l.is_deleted = 0
        ORDER BY l.create_time DESC
      """;

看起来就比较直观，清爽了。

Records

Java 14 中便包含了一个新特性：EP 359；Records

Records 的目标是扩展 Java 语言语法，Records 为声明类提供了一种紧凑的语法，用于创建一种类中是“字段，只是字段，除了字段什么都没有”的类。

通过对类做这样的声明，编译器可以通过自动创建所有方法并让所有字段参与 hashCode() 等方法。这是 JDK 14 中的一个预览特性。

使用 record 关键字可以定义一个记录：

public record Person(String firstName,String lastName) {
}

public static void main(String[] args) {
    Person person = new Person("Tango", "Chi");
    System.out.println(person.firstName());
}

record 解决了使用类作为数据包装器的一个常见问题。纯数据类从几行代码显著地简化为一行代码。

封闭类

在 Java 15 之前，Java 认为“代码重用”始终是一个终极目标，所以，一个类和接口都可以被任意的类实现或继承。

但是，在很多场景中，这样做是容易造成错误的，而且也不符合物理世界的真实规律。

例如，假设一个业务领域只适用于汽车和卡车，而不适用于摩托车。

在 Java 中创建 Vehicle 抽象类时，应该只允许 Car 和 Truck 类扩展它。

通过这种方式，我们希望确保在域内不会出现误用 Vehicle 抽象类的情况。

为了解决类似的问题，在 Java 15 中国引入了一个新的特性——密闭。

想要定义一个密闭接口，可以将 sealed 修饰符应用到接口的声明中。然后，permit 字句指定允许实现密闭接口的类：

public sealed interface Vehicle permits Car,Truck {
}

以上代码定义了一个密闭接口 Vehicle，它规定只能被 Car 和 Truck 两个类实现。

与接口类似，我们可以通过使用相同的 sealed 修饰符来定义密闭类：

public sealed abstract class Vehicle permits Car,Truck{
}

通过密闭特性，我们定义出来的 Vehicle 类只能被 Car 和 Truck 继承。

instanceof 模式匹配

instanceof 是 Java 中的一个关键字，我们在对类型做强制转换之前，会使用 instanceof 做一次判断，例如：

if (animal instanceof Dog){
    Dog dog=(Dog)animal;
    dog.run();
}else if (animal instanceof Cat){
    Cat cat=(Cat)animal;
    cat.run();
}

Java 14 带来了改进版的 instanceof 操作符，这意味着我们可以用更简洁的方式写出之前的代码例子：

if (animal instanceof Dog dog){
    dog.run();
}else if (animal instanceof Cat cat){
    cat.run();
}

我们都不难发现这种写法大大简化了代码，省略了显式强制类型转换的过程，可读性也大大提高了。

switch 模式匹配

基于 instanceof 模式匹配这个特性，我们可以使用如下方式来对对象 o 进行处理：

static String formatter(Object o) {
    String formatted = "unknow";
    if (o instanceof Integer i) {
        formatted = String.format("int %d", i);
    } else if (o instanceof Long l) {
        formatted = String.format("long %d", l);
    } else if (o instanceof Double d) {
        formatted = String.format("double %f", d);
    } else if (o instanceof String s) {
        formatted = String.format("String %s", s);
    }
    return formatted;
}

可以看到，这里使用了很多 if-else，其实，Java 中给我们提供了一个多路比较的工具，那就是 switch，而且从 Java 14 开始支持 switch 表达式，但 switch 的功能一直都是非常有限的。

在 Java 17 中，Java 的工程师们扩展了 switch 语句和表达式，使其可以适用于任何类型，并允许 case 标签中不仅带有变量，还能带有模式匹配。我们就可以更清楚、更可靠地重写上述代码，例如：

    static String formatter(Object o) {
        return switch (o) {
            case Integer i -> String.format("int %d", i);
            case Long l -> String.format("long %d", l);
            case Double d -> String.format("double %f", d);
            case String s -> String.format("String %s", s);
            default -> o.toString();
        };
    }

可以看到，以上的 switch 处理的是一个 Object 类型，而且 case 中也不再是精确的值匹配，而是模式匹配了。

协享科技

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JDK 新版本中都有哪些新特性？

可以看到，这里使用了很多 if-else，其实，Java 中给我们提供了一个多路比较的工具，那就是 switch，而且从 Java 14 开始支持 switch 表达式，但 switch 的功能一直都是非常有限的。虽然我们在代码中使用 var 进行了定义，但是对于虚拟机来说他是不认识这个 var 的，在 java 文件编译成 class 文件的过程中，会进行解糖，使用变量真正的类型来替代 var。在这之后，switch 中就多了一个关键字用于跳出 switch 块了，那就是 yield，他用于返回一个值。
复制链接

扫一扫