JDK 17 新特性 (一)

code-vibe

已于 2024-02-17 13:41:59 修改

阅读量1.6k

点赞数 24

于 2024-02-17 13:38:17 首次发布

本文链接：https://blog.csdn.net/qq_38373149/article/details/136137709

版权

java 基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

既然 Springboot 3.0 强制使用 JDK 17 那就看看 JDK17 有哪些新特性吧

参考链接

介绍一下新特性的历史渊源

JDK 17是Java Development Kit（JDK）的一个版本，它是Java编程语言的一种实现。JDK 17于2021年9月14日发布，并作为Java SE 17的一部分。在了解JDK 17的新特性之前，让我们先了解一下Java的发展历史。
Java最早由Sun Microsystems公司于1991年启动，目的是开发一种能够在不同操作系统上运行的编程语言。1995年，Sun Microsystems发布了Java的第一版，被称为Java 1.0。自那时以来，Java经历了多个版本的发展，每个版本都引入了新的特性和功能。
Java SE（Standard Edition）是Java的标准版本，用于开发桌面、服务器和嵌入式应用程序。不同的Java SE版本编号代表了不同的发展阶段和功能改进。
JDK 17是Java SE 17的一部分，它引入了许多新的特性和改进。这些新特性包括：
1. 类型模式匹配：引入了新的模式匹配语法，使得开发者能够更方便地对不同的模式进行匹配和处理。
2. 垃圾收集器：引入了一种新的垃圾收集器，名为ZGC（Z Garbage Collector），它提供了更低延迟和更高吞吐量的垃圾收集。
3. 向量API：引入了一种新的向量API，允许开发者使用向量化数据处理指令来加速并行计算。
4. Sealed类：引入了Sealed类的概念，它限制了某些类的继承和实现，从而提供更强的封装和安全性。
5. Pattern Matching for switch：扩展了switch语句的功能，使其更灵活和易用。
6. 预览功能：引入了一些预览功能，包括Pattern Matching for instanceof、Sealed类和Switch表达式的模式匹配等。
这些新特性使得Java编程更加方便、高效和安全。开发者可以利用这些新特性来提高代码的质量和性能，同时减少开发时间和调试困难。JDK 17的发布标志着Java的不断发展和改进，为开发者提供了更多有用的工具和功能，以应对不断变化的技术需求和挑战。JDK 17是Java Development Kit（JDK）的一个版本，它是Java编程语言的一种实现。JDK 17于2021年9月14日发布，并作为Java SE 17的一部分。在了解JDK 17的新特性之前，让我们先了解一下Java的发展历史。

学习前置

使用 IDEA 创建一个 maven 项目方法省略
网上一搜一大把这里就不再说了

文本块可以直接打印 json

在Java17之前的版本里，如果我们需要定义一个字符串，比如一个JSON数据，基本都是如下方式定义:

public void printJson() {
    String text = "{\n" +
        "  \"username\": \"小黑说Java\",\n" +
        "  \"password\": \"TR5#q659\",\n" +
        "  \"mailbox\": \"db58@96sn.vip\"\n" +
        "}";
    System.out.println(text);
}

这种方式定义具有几个问题：
1. 双引号需要进行转义；
2. 为了字符串的可读性需要通过+号连接；
3. 如果需要将JSON复制到代码中需要做大量的格式调整（当然这一点也可以通过其他工具解决）；
通过Java 17中的文本块语法，类似的字符串处理则会方便很多；通过三个双引号可以定义一个文本块，并且结束的三个双引号不能和开始的在同一行。
上面例子中的JSON可以更方便，可读性更好的通过文本块定义。代码如下:

public void printJson() {
    String text = """
            {
              "username": "小黑说Java",
              "password": "TR5#q659",
              "mailbox": "db58@96sn.vip"
            }
            """;
    System.out.println(text);
}

这段代码的输出结果是

{
  "username": "小黑说Java",
  "password": "TR5#q659",
  "mailbox": "db58@96sn.vip"
}

全部代码如下:

package com.codervibe;

public class Test {
    public static void switchTest(String id) {
        switch (id) {
            case "1", "2" -> System.out.println("崔霞");
            case "3", "4" -> System.out.println("梁熙涵");
            default -> System.out.println("唐文昊");
        }
    }
    public static void main(String[] args) {
       printJson();
    }
}

Swicth 语句语法升级

Java 17版本中switch表达式将允许switch有返回值，并且可以直接作为结果赋值给一个变量，等等一系列的变化。
下面有一个switch例子，依赖于给定的枚举值，执行case操作，故意省略break。

private static void switchTest(String id) {
    switch (id) {
        case "1":
            System.out.println("田雨泽");
        case "2":
            System.out.println("谢忠林");
        default:
            System.out.println("高芳");
    }
}

输出结果我就不放出来了都知道是什么(注意这里没有 break )
显然这不是期望的结果，因为我们需要在每个case里添加break防止所有的case都没执行。
所以

private static void switchTest(String id) {
    switch (id) {
        case "1":
            System.out.println("田雨泽");
            break;
        case "2":
            System.out.println("谢忠林");
            break;
        default:
            System.out.println("高芳");
            break;
    }
}

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

  public static void switchTest(String id) {
         String text = switch (id) {
            case "1", "2" -> "白汝鑫";
            case "3", "4" -> "邱凌晶";
            default -> "袁文轩";
        };
    }
    public static void main(String[] args) {
        switchTest("2");
        switchTest("");
    }

运行结果

崔霞
唐文昊

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

 public static void switchTest2(String id) {
        String text = switch (id) {
            case "1", "2" -> "白汝鑫";
            case "3", "4" -> "邱凌晶";
            default -> "袁文轩";
        };
        System.out.println(text);
    }
    public static void main(String[] args) {
        switchTest2("2");
        switchTest2("");
    }

但是刚才出现了一个意外

public static void switchTest2(String id) {
        String text = switch (id) {
            case "1", "2" -> System.out.println("崔霞");
            case "3", "4" -> System.out.println("梁熙涵");
            default -> System.out.println("唐文昊");
        };
        System.out.println(text);
    }

我在复制粘贴代码时忘记修改后面的语句了 IDEA 给我了一个这样的提示 switch 表达式中存在错误类型: void 无法转换为 java.lang.String
而 System.out.println("唐文昊");的方法返回值正是 void 于是有了以下代码

 public static String backJson() {
        String text = """
                {
                  "username": "小黑说Java",
                  "password": "TR5#q659",
                  "mailbox": "db58@96sn.vip"
                }
                """;
        return text;
    }

    public static void outsideSwitchTest(String id) {
        String text = switch (id) {
            default -> backJson();
        };
        System.out.println(text);
    }

    public static void main(String[] args) {
        outsideSwitchTest("");
    }

而运行结果正是

{
  "username": "小黑说Java",
  "password": "TR5#q659",
  "mailbox": "db58@96sn.vip"
}

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

public static void switchTest(String id) {

    System.out.println(switch (id) {
        case "1", "2" -> "赵雅涵";
        case "3", "4" -> "顾晨涵";
        default -> "黎润莎";
    });
}
 public static void main(String[] args) {
       switchTest("");
}

如果你想在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);
}

这是参考链接中的代码但是作为原创又怎么可能不改改呢
那么就修改亿点点吧

  private static class User {
        String username;
        String password;
        String sex;
        String age;
        String school_address;

        public String getUsername() {
            return username;
        }

        public void setUsername(String username) {
            this.username = username;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }

        public String getAge() {
            return age;
        }

        public void setAge(String age) {
            this.age = age;
        }

        public String getSchool_address() {
            return school_address;
        }

        public void setSchool_address(String school_address) {
            this.school_address = school_address;
        }

        @Override
        public String toString() {
            return "User{" +
                    "username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", sex='" + sex + '\'' +
                    ", age='" + age + '\'' +
                    ", school_address='" + school_address + '\'' +
                    '}';
        }
    }
    public static void switchTest(String id) {

        User user = switch (id) {
            case "1" -> {
                System.out.println("1");
                ArrayList<User> userArrayList = new ArrayList<>();
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                yield userArrayList.get(3);
            }
            
            default -> throw new IllegalStateException("Unexpected value: " + id);
        };
        System.out.println("user = " + user);
        System.out.println("user.toString() = " + user.toString());
    }
    public static void main(String[] args) {
        switchTest("1");
    }

回到参考链接
当然也可以直接使用yield返回结果。

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

然后我又有了亿点点想法那就再次修改亿点点

public static void switchTest(String id) {

        User user = switch (id) {
            case "1" -> {
                System.out.println("user");
                ArrayList<User> userArrayList = new ArrayList<>();
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                yield userArrayList.get(3);
            }
            default -> throw new IllegalStateException("Unexpected value: " + id);
        };
        System.out.println("user = " + user);
        System.out.println("user.toString() = " + user.toString());

        ArrayList<User> userArrayList =switch (id) {
            case "1" -> {
                ArrayList<User> users = new ArrayList<>();
                System.out.println("userArrayList");
                users.add(new User());
                users.add(new User());

                yield users;
            }
            default -> throw new IllegalStateException("Unexpected value: " + id);
        };
        System.out.println("userArrayList = " + userArrayList);

    }
    public static void main(String[] args) {
        switchTest("1");

    }

输出结果

user
user = User{username='null', password='null', sex='null', age='null', school_address='null'}
user.toString() = User{username='null', password='null', sex='null', age='null', school_address='null'}
userArrayList
userArrayList = [User{username='null', password='null', sex='null', age='null', school_address='null'}, User{username='null', password='null', sex='null', age='null', school_address='null'}]

最后整个代码

package com.codervibe;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void printJson() {
        String text = """
                {
                  "username": "小黑说Java",
                  "password": "TR5#q659",
                  "mailbox": "db58@96sn.vip"
                }
                """;
        System.out.println(text);
    }
    public static void switchTest2(String id) {
        String text = switch (id) {
            case "1", "2" -> "白汝鑫";
            case "3", "4" -> "邱凌晶";
            default -> "袁文轩";
        };
        System.out.println(text);
    }

    public static String backJson() {
        String text = """
                {
                  "username": "小黑说Java",
                  "password": "TR5#q659",
                  "mailbox": "db58@96sn.vip"
                }
                """;
        return text;
    }

    public static void outsideSwitchTest(String id) {
        String text = switch (id) {
            default -> backJson();
        };
        System.out.println(text);
    }
    private static class User {
        String username;
        String password;
        String sex;
        String age;
        String school_address;

        public String getUsername() {
            return username;
        }

        public void setUsername(String username) {
            this.username = username;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }

        public String getAge() {
            return age;
        }

        public void setAge(String age) {
            this.age = age;
        }

        public String getSchool_address() {
            return school_address;
        }

        public void setSchool_address(String school_address) {
            this.school_address = school_address;
        }

        @Override
        public String toString() {
            return "User{" +
                    "username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", sex='" + sex + '\'' +
                    ", age='" + age + '\'' +
                    ", school_address='" + school_address + '\'' +
                    '}';
        }
    }
    public static void switchTest(String id) {

        User user = switch (id) {
            case "1" -> {
                System.out.println("user");
                ArrayList<User> userArrayList = new ArrayList<>();
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                userArrayList.add(new User());
                yield userArrayList.get(3);
            }
            default -> throw new IllegalStateException("Unexpected value: " + id);
        };
        System.out.println("user = " + user);
        System.out.println("user.toString() = " + user.toString());

        ArrayList<User> userArrayList =switch (id) {
            case "1" -> {
                ArrayList<User> users = new ArrayList<>();
                System.out.println("userArrayList");
                users.add(new User());
                users.add(new User());

                yield users;
            }
            default -> throw new IllegalStateException("Unexpected value: " + id);
        };
        System.out.println("userArrayList = " + userArrayList);

    }
    public static void main(String[] args) {
        switchTest("1");

    }



}

为了方便后续的学习在此插入使用 Maven 项目中的 pom.xml 文件中引入 lombok 以及 junit 测试

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.codervibe</groupId>
    <artifactId>Newfeature</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

Java 17 新特性 - 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之后将会变得非常容易。

package com.codervibe;


import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Test;
public class testPerson {
    // 这里使用lombok减少代码
    @Data
    @AllArgsConstructor
    public  static  class Person {
        private String name;

        private int age;

        private String address;
    }
    @Test
    public void testPerson() {
        Person p1 = new Person("胡欣怡", 18, "贵州省遵义市习水县醒民镇");
        Person p2 = new Person("石子辰", 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);

    }
}

在改造亿点点

    @Test
    public void testPerson() {
        Person p1 = new Person("胡欣怡", 18, "贵州省遵义市习水县醒民镇");
        Person p2 = new Person("石子辰", 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);

        // 要怎么改下呢
        ArrayList<Person> personArrayList=new ArrayList<>();
        personArrayList.add(p1);
        personArrayList.add(p2);
        record personArrayList(String name,int age){}

        personArrayList personArrayList1 = new personArrayList(personArrayList.get(0).getAddress(),personArrayList.get(1).getAge());
        System.out.println("personArrayList1 = " + personArrayList1);
    }
    //结合之前的 特性  可以造出什么呢？这就要看你们的了

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

package com.codervibe;

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

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

public static void testPerson() {
    Person p1 = new Person("卢欣宜", 18, "福建省南平市建阳区黄坑镇");
    Person p2 = new Person("廖林", 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());
}

输出结果为

name 卢欣宜 age 18
name 廖林 age 28

Java 17 新特性 - 密封类 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 {};
}