【JDK8/11/17流行版本对比详解】（三）

4. Unicode 10支持

JDK11支持Unicode 10标准，这意味着Java现在可以使用更广泛的字符集。Unicode是一个标准，用于表示世界上所有文本字符的编码。Unicode字符集可以处理各种语言的字符，从西方语言如英语、德语和法语到东方语言如中文、日语和韩语。

在Java中，字符串是Unicode字符的序列。在早期版本的Java中，字符串使用UTF-16编码，这意味着每个字符使用16位来表示。但是，Unicode字符集已经发展到了超过16位，因此JDK11现在支持更大的字符集。JDK11支持UTF-8，UTF-16和UTF-32编码，这些编码可以处理Unicode字符集中的所有字符。

除了更大的字符集之外，JDK11还提供了一些新的Unicode相关功能。其中一个是Unicode文本块，这是一种在Java中表示Unicode字符串的新方式。文本块可以将多行文本嵌入到Java代码中，而无需使用转义序列。这使得Java中处理多语言字符串更加容易。

JDK11还支持Unicode标准中的一些其他功能，例如emoji字符和符号。Java现在可以处理和显示这些字符，这使得在Java应用程序中使用emoji和符号更加容易。

示例代码如下：

public class UnicodeDemo {
    public static void main(String[] args) {
        // 使用Unicode表示中文字符
        String chinese = "\u4e2d\u6587";
        System.out.println(chinese); // 输出：中文
        // 使用Unicode文本块表示多行文本
        String multiline = """
                这是多行文本，
                可以直接嵌入到Java代码中，
                而无需使用转义序列。
                """;
        System.out.println(multiline); 
        // 支持emoji字符和符号
        String emoji = "🎉";
        System.out.println(emoji); // 输出：🎉
    }
}

输出结果：

中文
这是多行文本，
可以直接嵌入到Java代码中，
而无需使用转义序列。
🎉

总之，JDK11的Unicode支持为Java提供了更强大的多语言和字符集处理能力。Java开发人员现在可以更轻松地处理各种语言和字符，从而更好地满足现代应用程序的需求。

5. 新的字符串方法

JDK11引入的新方法如下：

1. strip()：去除字符串首尾空格
2. stripLeading()：去除字符串开头空格
3. stripTrailing()：去除字符串结尾空格
4. repeat()：重复指定次数字符串

这些方法的实现原理相对简单，主要是基于字符数组的操作。

对于strip()方法，它的实现过程就是先判断字符串长度是否为0，如果是直接返回空字符串。如果不是，则调用trim()方法将字符串首尾空格去除。

stripLeading()和stripTrailing()方法的实现也类似，只是在去除空格时只针对字符串开头或结尾进行操作。

而对于repeat()方法，其实现原理也较为简单，就是通过循环构造一个新字符串，重复指定次数传入的字符串即可。

需要注意的是，这些方法在Java中都是属于String类的方法，而不是字符数组的方法。在使用这些方法时应当注意空格的处理，以免产生问题。同时，使用repeat()方法时需要注意传入的字符串不为null，否则会抛出NullPointerException异常。

示例代码如下：

public class StringExample {
    public static void main(String[] args) {
        // 使用strip()方法去除字符串首尾空格
        String str1 = "  Hello World!  ";
        String strippedStr1 = str1.strip();
        System.out.println(strippedStr1); // 输出: "Hello World!"
        // 使用stripLeading()方法去除字符串开头空格
        String str2 = "  Hello World!";
        String strippedLeadingStr2 = str2.stripLeading();
        System.out.println(strippedLeadingStr2); // 输出: "Hello World!"
        // 使用stripTrailing()方法去除字符串结尾空格
        String str3 = "Hello World!  ";
        String strippedTrailingStr3 = str3.stripTrailing();
        System.out.println(strippedTrailingStr3); // 输出: "Hello World!"
        // 使用repeat()方法重复指定次数字符串
        String str4 = "abc";
        String repeatedStr4 = str4.repeat(3);
        System.out.println(repeatedStr4); // 输出: "abcabcabc"
    }
}

6. 局部变量语法增强

JDK11引入的var关键字可以用于局部变量的类型推断，它可以让Java程序员在不牺牲代码可读性的情况下，更加简洁地定义局部变量。

在try-with-resources语句中使用var时，var关键字可以用于替换资源的类型声明。例如，下面是一个使用try-with-resources语句以及var关键字的例子：

try (var inputStream = new FileInputStream("input.txt")) {
    // Do something with the input stream
}

在上面的例子中，inputStream是用var关键字定义的局部变量。编译器将根据赋值表达式的类型来推断inputStream的类型，因此inputStream的类型将是文件输入流类FileInputStream的实际类型。

使用var关键字的好处是可以减少代码的冗余性，并且在一些情况下可以使代码更加清晰和易于理解。然而，需要注意的是，使用var关键字也可能会导致代码的可读性降低，特别是在代码较为复杂的情况下。

值得一提的是，var本质上只是一种语法糖，它并不会改变Java程序的运行时行为。在编译时，编译器会使用类型推断来确定变量的实际类型，并且在运行时，变量的类型与在声明语句中指定的类型相同。

下面是一个使用var关键字来定义局部变量的示例代码：

// 定义一个整型数组并初始化
var nums = new int[]{1, 2, 3, 4, 5};
// 遍历数组并输出每个元素的值
for (var num : nums) {
    System.out.println("数组元素为：" + num);
}
// 定义一个字符串并赋值
var message = "Hello, world!";
// 输出字符串长度
System.out.println("字符串长度为：" + message.length());
// 使用try-with-resources语句读取文件内容
try (var reader = new BufferedReader(new FileReader("input.txt"))) {
    String line = null;
    while ((line = reader.readLine()) != null) {
        // 处理文件内容
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

在上面的示例代码中，var关键字被用于定义整型数组、字符串和文件读取器等局部变量。使用var关键字可以让代码更加简洁，同时也能够使代码更加易于理解。需要注意的是，var关键字必须与初始化表达式一起使用，否则编译器无法推断变量的类型。同时，使用var关键字也不意味着放弃类型检查，编译器仍会对变量的类型进行检查，确保程序的类型安全性。

7. 空判断操作符

JDK11引入的空判断操作符“??”是一种简化处理空值的语法糖。在Java中，当一个变量的值为null时，我们通常需要使用if语句或者三目运算符来处理这种情况，这样会使代码变得冗长且不够简洁。

使用空判断操作符“??”可以更加方便地处理空值。如果一个变量的值为null，则表达式返回操作符右侧的值；如果一个变量的值不为null，则表达式返回操作符左侧的值。语法如下：

expression1 ?? expression2

其中，expression1为要进行空判断的变量或者表达式，expression2为expression1为空时所返回的默认值。

例如，我们可以使用空判断操作符来简化以下代码：

String str = getName();
if (str == null) {
    str = "Unknown";
}

可以改写为：

String str = getName() ?? "Unknown";

这样可以使代码更加简洁易懂。

在底层，空判断操作符的实现原理是利用了Java中的短路运算符。如果操作符左侧的表达式不为空，则右侧的表达式将不会被执行，避免了不必要的计算。

需要注意的是，空判断操作符只能用于引用类型，对于基本类型则无效。同时，在使用空判断操作符时也要注意保证代码的可读性和可维护性。如果使用不当，可能会导致代码变得晦涩难懂。

8. 集合工厂方法

JDK11引入了一组新的集合工厂方法，这些方法都是在java.util包下的静态方法。这些方法可以用来创建各种不同类型的集合对象，如List、Set、Map等。这些新的方法使得创建集合对象变得更加便捷和容易。下面我们来深入探讨这些集合工厂方法的工作原理和运行原理。

首先，这些集合工厂方法都是在java.util包下的静态方法，因此可以直接通过类名来调用。这些方法使用了Java 9中引入的工厂方法特性，它们都返回了不可变的集合对象。这些不可变的集合对象与传统的集合对象的最大区别在于它们不支持修改操作。如果尝试在不可变的集合对象上进行修改操作，将会抛出UnsupportedOperationException异常。

这些集合工厂方法的实现方案非常巧妙。它们都是调用了对应集合的构造方法，并将传入的元素转化为集合中存放的元素。例如，List.of方法就是调用了ArrayList的构造方法，并将传入的元素逐个添加到集合中。这样就可以快速地创建出一个新的集合对象。

这些集合工厂方法还有一个很重要的特点：它们都使用了可变参数。这意味着我们可以在创建集合对象时一次性添加多个元素。例如，List.of方法可以一次性添加多个元素，如List.of(“A”, “B”, “C”)就会创建一个包含三个元素的List集合对象。

示例代码：

创建一个包含多个元素的List集合对象：

List<String> list = List.of("A", "B", "C");

创建一个空的Set集合对象：

Set<Object> set = Set.of();

创建一个包含多个键值对的Map集合对象：

Map<String, Integer> map = Map.of("A", 1, "B", 2, "C", 3);

需要注意的是，由于这些集合对象都是不可变的，因此不能对其进行修改操作，否则会抛出UnsupportedOperationException异常。

总的来说，JDK11引入的这组新的集合工厂方法使创建集合对象变得更加便捷和简便。它们的实现方案巧妙，使用了Java 9中引入的工厂方法特性，并结合了可变参数。这使得我们可以快速地创建出各种类型的集合对象，并添加所需的元素。同时，这些集合工厂方法所创建的集合对象都是不可变的，这保证了程序的安全性和稳定性。

JDK17语言特性和API

JDK (Java Development Kit) 17 是 Java 的最新版本，于2021年9月发布。它包括了多种新的语言特性和 API。

一些 JDK 17 的主要特性和 API 如下：

1. Sealed Classes

Sealed Classes是Java 15中引入的一种新特性。它通过限制类和接口的可访问继承者，来增强类型检查和安全性。

在Java中，一个类可以被继承，也可以被其他的类实现。但是，有些情况下，我们希望限制这种继承和实现的方式，以达到更好的类型检查和安全性。这就是Sealed Classes的作用。

Sealed Classes有两个关键元素：sealed和permits。sealed用来声明一个类或接口是“密封”的，即只有在该类或接口中声明的类或接口才能继承或实现它。而permits用来声明所允许继承或实现的类或接口。

下面是一个使用Sealed Classes的Java代码示例：

public sealed class Vehicle permits Car, Truck {
    private String make;
    private String model;
    public Vehicle(String make, String model) {
        this.make = make;
        this.model = model;
    }
    public String getMake() {
        return make;
    }
    public String getModel() {
        return model;
    }
}
public final class Car extends Vehicle {
    private int numDoors;
    public Car(String make, String model, int numDoors) {
        super(make, model);
        this.numDoors = numDoors;
    }
    public int getNumDoors() {
        return numDoors;
    }
}
public final class Truck extends Vehicle {
    private int payloadCapacity;
    public Truck(String make, String model, int payloadCapacity) {
        super(make, model);
        this.payloadCapacity = payloadCapacity;
    }
    public int getPayloadCapacity() {
        return payloadCapacity;
    }
}

在这个示例中，Vehicle被声明为密封类，它只允许Car和Truck两个类继承它。Car和Truck分别表示汽车和卡车，它们都继承自Vehicle类，并且均具有自己的特性和方法。

通过使用Sealed Classes，我们可以在编写代码时限制继承和实现的方式，从而提高代码的类型检查和安全性。此外，使用Sealed Classes还可以使代码更加清晰易懂，易于维护和扩展。

Sealed Classes的引入，能够提供更为灵活、安全的类和接口的实现和继承方式。在代码编写和维护过程中，能够更好地避免一些潜在的类型错误和安全问题。

2. Pattern Matching for switch (Preview)

Java 14 引入了 Pattern Matching for switch (Preview) 功能，使得 switch 语句的功能更加强大。该功能基于模式匹配来执行条件分支，可以在 switch 语句中使用更复杂的条件判断，比如使用 instanceof 进行类型判断，以及使用表达式进行匹配。

使用 Pattern Matching for switch (Preview) 需要在 switch 语句中使用关键字 case，后接一个要匹配的模式，然后在箭头后面执行相应的操作。这种模式匹配的方式可以用于匹配对象类型、枚举类型以及其他类型。

例如，我们可以使用 Pattern Matching for switch (Preview) 来匹配一个 Object 对象：

public static void patternMatch(Object obj) {
    switch (obj) {
        case String str -> System.out.println("字符串: " + str);
        case Integer integer -> System.out.println("整数: " + integer);
        case List<?> list -> System.out.println("列表: " + list);
        default -> System.out.println("未知类型");
    }
}

在上述代码中，我们可以在每个 case 子句中使用箭头（->）来执行相应的操作。在这个例子中，我们可以根据传递的 obj 对象的类型来匹配不同的 case，对于 String 对象，我们输出 “字符串”，对于 Integer 对象，我们输出 “整数”，对于 List<?> 对象，我们输出 “列表”，对于其他对象则输出 “未知类型”。

除了上述示例中的对象类型匹配，Pattern Matching for switch (Preview) 也可以用于枚举类型匹配，以及其他类型的匹配，比如通过定义自定义的模式进行匹配。

总之，Pattern Matching for switch (Preview) 是一种很实用的功能，可以让 switch 语句更加易用和灵活，可以根据不同的模式匹配来执行相应的操作。需要注意的是，该功能目前仍处于预览状态，如果要使用该功能需要在编译时添加相应的参数。

3. Records

Records是Java 16中引入的一种新功能，用于定义不可变的数据类。相比于传统的Java类，Records可以更简洁地定义一个数据类，同时也提供了更好的可读性和易用性。

实际上，Records可以看作是一种语法糖，它背后的实现原理还是基于Java类。Records通过自动生成基本的类方法（如equals、hashCode和toString等）来简化开发人员的工作，并且保证了数据类的不可变性。

Records使用关键字record来定义数据类，例如：

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

上面的代码定义了一个Person类，包含了两个属性：name和age。这个类是不可变的，即所有属性都是final的，并且没有setter方法。

在底层实现上，编译器会自动生成以下方法：

• 构造方法：用于初始化类的属性。
• equals：用于比较两个对象是否相等。
• hashCode：用于计算对象的哈希值。
• toString：用于将对象转换成字符串表示。

相比于传统的Java类，Records可以更简洁地定义一个数据类，同时也提供了更好的可读性和易用性。

在运行时，Records类和传统的Java类没有什么区别，都会被编译成字节码。但由于Records类是不可变的，所以它们可以更加安全地在多线程环境下使用。

下面是一个简单的例子：

public record Person(String name, int age) {}
public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Bob", 30);
        System.out.println(person1); // 输出：Person[name=Alice, age=25]
        System.out.println(person2); // 输出：Person[name=Bob, age=30]
        System.out.println(person1.equals(person2)); // 输出：false
    }
}

在上面的例子中，我们定义了一个名为Person的Records类，该类包含两个属性：name和age。Person类是不可变的，因此我们无法更改其属性值。

然后，在main方法中，我们创建了两个Person对象person1和person2，分别传入不同的name和age值。接下来，我们使用System.out.println打印了每个对象的字符串表示，并调用person1.equals(person2)方法进行比较。

可以看到，Records类确实简化了代码的编写，同时也保证了不可变性和多线程安全性。

总的来说，Records可以帮助开发人员更轻松地定义不可变的数据类，提高代码的可读性和易用性。它背后的实现原理是基于Java类，通过自动生成基本的类方法来简化开发人员的工作，并且保证了数据类的不可变性。