最近ChatGPT爆火，作为我们程序员我们当然也想要上手来使用一番，下面账号注册，手机认证，服务器上API使用等方便来说明 ChatGPTAPI：https://platform.openai.com/docs/models/overview 聊天：https://chat.openai.com/chat

一 准备工作

1.1 网络环境准备工作​

代理流量： SakuraC3`at

• 注册账号

• 购买流量包

个人建议购买这个套餐（看自己的需求）

• 工具

百度网盘：https://pan.baidu.com/s/1cTK6_uYj2VwAftkWdcEb8w?pwd=sacc Gitub：https://github.com/Fndroid/clash_for_windows_pkg 下载安装完毕之后，我们打开购买的流量包页面 导入到Clash中，点击下载 选择代理节点，看网络延迟，看自己的选择 开启代理，访问服务，注意关闭时请不要直接关闭，先关闭代理，再关程序

• 测试一下

好的我们的网络环境，就搭建再这，下面我们来看看账号的注册的准备工作

1.2 账号注册准备工作​

账号注册是需要国外手机的验证，因此我们需要一个需要虚拟账号 网站：Get a virtual phone number. Temporary number. SMS service activation 点击注册，充值2美元，比较坑的是支付宝最低2美元

1.3 程序开发准备工作​

前提：如果你只是向玩玩ChatGPT可以省掉这一步 关于ChatGPT的api调用，国内可能无法调用，一种方式代理，一种方式外国服务器 我就选择的是外国服务器，我就是来玩玩他们的API文档，这里推荐阿里云的服务器 这里我也参考网络上的其他配置，就是太麻烦了，甲骨文，微软等等，果断放弃了 地址：轻量应用服务器web服务器个人建站_弹性计算-阿里云 看自己的需求吧 付钱，配置一下，SSH工具可以连接就行了，到这我们的准备工作就完了，下面开始注册，当然这种也有缺点，无法工具中调试

二 注册账号

• 第一步代理服务开启

• 进入网站进行注册

地址：https://chat.openai.com/auth/login 这里我们选择微软账号注册，没有微软装好可以先注册一个 需要账号与密码，进行登录，登录成功之后，来到手机号验证界面 谁便填写，关键是手机号验证 这个是时候，来到我们前面装备的工作的虚拟手机号注册，购买手机号 输入openAI 请记住国旗，我这里选择的巴西，看球的都熟悉这个国旗，加入购物车 点击复制手机号，来到验证界面，进行手机号验证 进行验证，等待验证码，粘贴完成认证 注册成功，来到聊天页面，我们就可以聊天了

三 程序开发

API文档：https://platform.openai.com/docs/models/overview 注意他的调用不会是免费的，有5美元的免费额度，自己玩的话够用了 API KEY 调用时验证身份 服务器上测试是否能够调用

curl https://api.openai.com/v1/models \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "OpenAI-Organization: org-gMZJtnznaLIomJ2vTWYWFSLo"

调用成功，之后就可以集成在自己的程序中，具体的使用参考API文档 以上就是这两天玩ChatGPT的笔记，如果不行，请留言

前言：最近写项目用到了Spring3.0，JDK8不行了，一看原来JDK已经更新到了22了，下面是我总结的一些新特性 具体可以参考：https://openjdk.org/projects/jdk/

一 JDK8 新特性

1.1 Lambda 表达式​

Lambda表达式是Java 8引入的一个重要特性，它允许以更简洁的方式编写匿名函数，Lambda表达式可以看作是一种轻量级的函数式编程的语法表示 Lambda表达式的基本语法如下：

(parameter1, parameter2, ..., parameterN) -> {
    // 方法体
}

Lambda表达式包含以下几个部分：

• 参数列表：包含在圆括号内，可以是零个或多个参数。
• 箭头操作符：由箭头符号 "->" 表示，用于分隔参数列表和方法体。
• 方法体：包含在花括号内，实现具体的操作逻辑。

Lambda表达式的主要用途是简化代码，尤其是在使用函数式接口时非常方便。函数式接口是只包含一个抽象方法的接口，Lambda表达式可以与函数式接口@FunctionalInterface一起使用，从而实现函数式编程的效果。

package lambda;

/**
 * @description: 使用 lambda 表达式创建线程
 * @author: shu
 * @createDate: 2023/6/30 9:49
 * @version: 1.0
 */
public class Thread01 {
    public static void main(String[] args) {
        // 1.1 使用匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World! 1.1");
            }
        }).start();

        // 1.2 使用 lambda 表达式
        new Thread(() -> System.out.println("Hello World! 1.2 ")).start();

        // 1.3 使用 lambda 表达式和类型推导
        new Thread(() -> {
            System.out.println("Hello World! 1.3");
        }).start();
    }
}

Lambda表达式可以更简洁地表示匿名函数，避免了传统的匿名内部类的冗余代码，提高了代码的可读性和可维护性。它是Java 8引入的一个强大特性，广泛应用于函数式编程和Java 8以后的各种API中。

1.2 新的日期API​

JDK 8引入了一个新的日期和时间API，名为java.time，它提供了更加灵活和易于使用的日期和时间处理功能。该API在设计上遵循了不可变性和线程安全性的原则，并且提供了许多方便的方法来处理日期、时间、时间间隔和时区等。 下面是java.time包中一些主要的类和接口：

1. LocalDate：表示日期，例如：年、月、日。
2. LocalTime：表示时间，例如：时、分、秒。
3. LocalDateTime：表示日期和时间，结合了LocalDate和LocalTime。
4. ZonedDateTime：表示带时区的日期和时间。
5. Instant：表示时间戳，精确到纳秒级别。
6. Duration：表示时间间隔，例如：小时、分钟、秒。
7. Period：表示日期间隔，例如：年、月、日。
8. DateTimeFormatter：用于日期和时间的格式化和解析。
9. ZoneId：表示时区。
10. ZoneOffset：表示时区偏移量。

这些类提供了一系列方法来执行日期和时间的计算、格式化、解析和比较等操作。而且，java.time包还提供了对日历系统的支持，包括对ISO-8601日历系统的全面支持。 以下是一个简单的示例，展示了如何使用新的日期API创建和操作日期和时间：

package lambda;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;


/**
 * @description: 新的日期和时间 API 示例
 * @author: shu
 * @createDate: 2023/6/30 10:15
 * @version: 1.0
 */
public class DateDemo01 {
    public static void main(String[] args) {
        // 创建日期
        LocalDate date = LocalDate.now();
        System.out.println("Today's date: " + date);

        // 创建时间
        LocalTime time = LocalTime.now();
        System.out.println("Current time: " + time);

        // 创建日期和时间
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println("Current date and time: " + dateTime);

        // 格式化日期和时间
        String formattedDateTime = dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("Formatted date and time: " + formattedDateTime);

        // 执行日期的计算操作
        LocalDate tomorrow = date.plusDays(1);
        System.out.println("Tomorrow's date: " + tomorrow);

        // 执行时间的比较操作
        boolean isBefore = time.isBefore(LocalTime.NOON);
        System.out.println("Is current time before noon? " + isBefore);
    }
}

1.3 使用Optional​

JDK 8引入了一个新的类，名为Optional，用于解决在处理可能为null的值时出现的NullPointerException（空指针异常）问题。Optional类的设计目标是鼓励更好的编程实践，明确表示一个值可能为空，并鼓励开发人员在使用这些可能为空的值时进行显式的处理。 Optional类是一个容器对象，可以包含一个非空的值或者没有值。它提供了一系列方法来处理包含值和没有值的情况，例如：获取值、判断是否有值、获取默认值、执行操作等。 下面是Optional类的一些常用方法：

1. of()：创建一个包含非空值的Optional对象。
2. empty()：创建一个空的Optional对象。
3. ofNullable()：根据指定的值创建一个Optional对象，允许值为null。
4. isPresent()：判断Optional对象是否包含值。
5. get()：获取Optional对象中的值，如果没有值，则抛出NoSuchElementException异常。
6. orElse()：获取Optional对象中的值，如果没有值，则返回默认值。
7. orElseGet()：获取Optional对象中的值，如果没有值，则通过提供的Supplier函数生成一个默认值。
8. orElseThrow()：获取Optional对象中的值，如果没有值，则通过提供的Supplier函数抛出指定的异常。
9. map()：对Optional对象中的值进行转换，并返回一个新的Optional对象。
10. flatMap()：对Optional对象中的值进行转换，并返回一个新的Optional对象，该方法允许转换函数返回一个Optional对象。

以下是一个简单的示例，展示了如何使用Optional类来处理可能为空的值：

import java.util.Optional;

/**
 * @description: Optional 示例
 * @author: shu
 * @createDate: 2023/6/30 10:20
 * @version: 1.0
 */
public class OptionalDemo {
    public static void main(String[] args) {
        String value = "Hello";

        // 创建一个包含非空值的Optional对象
        Optional<String> optional = Optional.of(value);

        // 判断Optional对象是否包含值
        if (optional.isPresent()) {
            // 获取Optional对象中的值
            String result = optional.get();
            System.out.println("Value: " + result);
        }

        // 获取Optional对象中的值，如果没有值，则返回默认值
        String defaultValue = optional.orElse("Default Value");
        System.out.println("Default Value: " + defaultValue);

        // 对Optional对象中的值进行转换
        Optional<String> transformed = optional.map(String::toUpperCase);
        if (transformed.isPresent()) {
            System.out.println("Transformed Value: " + transformed.get());
        }
    }
}

在上面的示例中，我们创建了一个包含非空值的Optional对象，并使用isPresent()和get()方法来判断和获取值。然后，我们使用orElse()方法来获取值或返回默认值，以及使用map()方法对值进行转换。 Optional类可以在代码中提供更加安全和清晰的处理空值的方式。然而，它并不适用于所有的场景，需要根据实际情况来判断是否使用Optional。请注意，过度使用Optional可能会导致代码冗余，因此需要权衡使用的利弊。

1.4 使用Base64​

在JDK 8中，Java提供了对Base64编码和解码的支持，通过java.util.Base64类来实现。Base64是一种用于将二进制数据编码为文本的编码方式，常用于在网络传输中或存储数据时将二进制数据表示为可打印字符 下面是一些基本的使用示例：

1. 编码为Base64字符串：

import java.util.Base64;

/**
 * @description: 编码示例
 * @author: shu
 * @createDate: 2023/7/1 9:23
 * @version: 1.0
 */
public class EncodedDemo {
    public static void main(String[] args) {
        // 原始数据
        String originalData = "Hello, World!";
        // 编码为Base64字符串
        String encodedData = Base64.getEncoder().encodeToString(originalData.getBytes());
        System.out.println("Encoded data: " + encodedData);
    }
}

2. 解码Base64字符串：

import java.util.Base64;

/**
 * @description: 解码示例
 * @author: shu
 * @createDate: 2023/7/1 9:24
 * @version: 1.0
 */
public class DecodeDemo {
    public static void main(String[] args) {
        // Base64字符串
        String encodedData = "SGVsbG8sIFdvcmxkIQ==";
        // 解码为原始数据
        byte[] decodedData = Base64.getDecoder().decode(encodedData);
        System.out.println("Decoded data: " + new String(decodedData));
    }
}

在上述示例中，我们使用Base64.getEncoder()方法获取一个Base64.Encoder对象，并调用其encodeToString()方法将原始数据编码为Base64字符串。同样，我们使用Base64.getDecoder()方法获取一个Base64.Decoder对象，并调用其decode()方法解码Base64字符串为原始数据。 java.util.Base64类还提供了其他一些方法，例如：

• Base64.getEncoder().encodeToString(byte[] src)：将字节数组编码为Base64字符串。
• Base64.getDecoder().decode(String src)：将Base64字符串解码为字节数组。
• Base64.getMimeEncoder().encodeToString(byte[] src)：将字节数组编码为MIME类型的Base64字符串。
• Base64.getMimeDecoder().decode(String src)：将MIME类型的Base64字符串解码为字节数组。
• Base64.getUrlEncoder().encodeToString(byte[] src)：将字节数组编码为URL安全的Base64字符串。
• Base64.getUrlDecoder().decode(String src)：将URL安全的Base64字符串解码为字节数组。

这些方法可以根据不同的需求选择使用。 需要注意的是，Base64编码是不加密的，仅用于编码和解码数据，如果需要加密和解密数据，请使用加密算法，如AES、RSA等。

1.5 接口的默认方法和静态方法​

JDK 8引入了接口的默认方法和静态方法，这使得在接口中添加新功能变得更加灵活。

1. 默认方法（Default Methods）： 默认方法允许在接口中定义具有默认实现的方法。这使得在不破坏现有实现类的情况下，可以向现有接口添加新的方法。

以下是默认方法的示例：

public interface MyInterface {
    // 抽象方法
    void abstractMethod();

    // 默认方法
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("Implementing abstractMethod() in MyClass.");
    }
}

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 9:29
 * @version: 1.0
 */
public class DefaultMethodsDemo {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.abstractMethod();
        obj.defaultMethod();
    }

}

在上述示例中，MyInterface接口中定义了一个抽象方法abstractMethod()和一个默认方法defaultMethod()。MyClass类实现了MyInterface接口，并提供了对抽象方法的具体实现。此外，MyClass类可以继承默认方法defaultMethod()的默认实现。

2. 静态方法（Static Methods）： 静态方法是接口中的另一种类型的方法，它与特定的接口关联，并且只能通过接口名称来调用。

以下是静态方法的示例：

public interface MyInterface {
    // 抽象方法
    void abstractMethod();

    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("Implementing abstractMethod() in MyClass.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.abstractMethod();
        MyInterface.staticMethod();
    }
}

在上述示例中，MyInterface接口中定义了一个抽象方法abstractMethod()和一个静态方法staticMethod()。MyClass类实现了MyInterface接口，并提供了对抽象方法的具体实现。staticMethod()可以通过接口名称直接调用。 通过默认方法和静态方法，接口的功能可以更加灵活地扩展，而无需破坏已有的实现类。这在JDK 8之前是不可能的。

1.6 方法引用格式​

在JDK 8中，引入了方法引用（Method Reference）的概念，用于简化函数式接口（Functional Interface）的实现。方法引用允许您直接引用现有方法作为Lambda表达式的替代，使代码更加简洁和易读。在JDK 8中，有四种不同的方法引用格式：

1. 静态方法引用（Static Method Reference）：格式为类名::静态方法名。例如，Integer::parseInt表示引用Integer类的静态方法parseInt。
2. 实例方法引用（Instance Method Reference）：格式为对象::实例方法名。例如，System.out::println表示引用System.out对象的println方法。
3. 对象方法引用（Object Method Reference）：格式为类名::实例方法名。这种引用适用于无参实例方法。例如，String::length表示引用String类的length方法。
4. 构造方法引用（Constructor Method Reference）：格式为类名::new。例如，ArrayList::new表示引用ArrayList类的构造方法。

在使用方法引用时，要根据接口的抽象方法的参数个数和返回类型选择适当的方法引用格式。 以下是一个简单的示例，展示了这些方法引用格式的使用：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @description: 方法引用示例
 * @author: shu
 * @createDate: 2023/7/1 9:32
 * @version: 1.0
 */
public class MethodReferenceDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        // 静态方法引用
        names.forEach(System.out::println);
        // 实例方法引用
        names.forEach(String::toUpperCase);
        // 对象方法引用
        names.forEach(String::length);
        // 构造方法引用
        List<Integer> lengths = names.stream()
                .map(Integer::new)
                .collect(Collectors.toList());
    }
}

1.7 Stream类​

JDK中的Stream类是Java 8引入的一个新概念，用于处理集合和数组等数据源的元素序列。Stream类提供了一种流式操作的方式，可以用于对数据进行过滤、映射、排序、聚合等各种操作，从而更加方便和高效地处理数据。 下面是一些Stream类的主要特点和用法：

1. 流的创建：可以通过集合、数组、I/O通道等多种方式创建流。例如，通过Collection.stream()方法可以从集合创建一个流，通过Arrays.stream()方法可以从数组创建一个流。
2. 中间操作：Stream类提供了一系列中间操作方法，用于对流进行转换、过滤、映射等操作，这些操作会返回一个新的Stream对象。常见的中间操作方法包括filter()、map()、sorted()等。
3. 终端操作：Stream类也提供了一系列终端操作方法，用于对流进行最终的处理，返回一个结果或产生一个副作用。常见的终端操作方法包括forEach()、collect()、reduce()等。
4. 惰性求值：Stream类的中间操作是惰性求值的，即在调用终端操作之前，中间操作并不会立即执行。这种方式可以优化性能，只对需要处理的元素进行操作。
5. 并行处理：Stream类可以支持并行处理，即在处理大量数据时，可以将操作并行化以提高处理速度。通过parallel()方法可以将流转换为并行流。

下面是一个简单的示例，展示了Stream类的使用：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 9:36
 * @version: 1.0
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave", "Eve");

        // 过滤长度大于3的元素
        names.stream()
                .filter(name -> name.length() > 3)
                .forEach(System.out::println);

        // 转换为大写并排序
        List<String> uppercaseNames = names.stream()
                .map(String::toUpperCase)
                .sorted()
                .collect(Collectors.toList());

        // 求长度之和
        int totalLength = names.stream()
                .mapToInt(String::length)
                .sum();
    }
}

具体参考我前面写的文章

1.8 注解相关的改变​

在JDK 8中，注解相关的改变主要集中在两个方面：重复注解（Repeatable Annotations）和可使用的类型（Type Annotations）。

1. 重复注解（Repeatable Annotations）：在JDK 8之前，每个注解在一个元素上只能使用一次。而在JDK 8中，引入了重复注解的概念，允许在同一个元素上多次使用相同的注解。为了支持重复注解，新增了两个元注解（Meta-Annotations）：@Repeatable和@Retention。 @Repeatable注解用于注解声明，指定了注解的容器注解，该容器注解允许在同一个元素上多次使用相同的注解。 @Retention注解用于指定注解的生命周期，它可以应用于注解声明和容器注解。常用的生命周期包括@Retention(RetentionPolicy.SOURCE)、@Retention(RetentionPolicy.CLASS)和@Retention(RetentionPolicy.RUNTIME)。 通过使用重复注解，可以更灵活地在同一个元素上应用多个相同的注解，而不需要创建额外的容器注解。
2. 可使用的类型（Type Annotations）：在JDK 8之前，注解主要应用于类、方法、字段等元素的声明上。而在JDK 8中，引入了可使用的类型，使得注解可以应用于更多的位置，包括类型的使用上。 可使用的类型注解通过在类型前面添加注解，来对类型使用进行约束和标记。例如，可以在变量声明、方法参数、泛型类型参数等位置使用注解。 可使用的类型注解提供了更丰富的语义，可以帮助编译器和静态分析工具检查类型使用的合法性，并提供更精确的类型检查和约束。

这些改变使得注解在JDK 8中变得更加灵活和强大，可以更好地应用于代码的描述、分析和约束。重复注解和可使用的类型为开发人员提供了更多的选择和扩展性，使得注解在Java语言中的应用更加广泛和多样化。

1.9 支持并行（parallel）数组​

在JDK 8中，引入了对并行数组操作的支持。这个功能由Arrays类和新的ParallelSorter接口提供 Arrays类中新增了一些用于并行操作数组的方法，其中最突出的是parallelSort()方法。该方法用于对数组进行并行排序，可以显著提高排序的性能。与传统的sort()方法相比，parallelSort()方法会将数组划分为多个小块，并在多个线程上并行进行排序。 以下是一个示例代码，展示了parallelSort()方法的使用：

import java.util.Arrays;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 9:39
 * @version: 1.0
 */
public class ParallelArrayDemo {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9, 3, 7, 6, 4};
        // 并行排序数组
        Arrays.parallelSort(numbers);
        // 打印排序结果
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

在上面的示例中，我们使用parallelSort()方法对整型数组进行并行排序，然后遍历数组打印排序结果。 需要注意的是，并行数组操作适用于一些可以被划分为独立块的操作，如排序、查找等。对于一些需要依赖前后元素关系的操作，可能不适合使用并行数组操作。 并行数组操作可以充分利用多核处理器的优势，提高处理大规模数据时的性能。但在使用并行操作时，也需要注意合理划分任务和数据的负载均衡，以避免线程竞争和效率下降。

1.10 对并发类（Concurrency）的扩展​

在JDK 8中，对并发类（Concurrency）进行了一些扩展，以提供更强大、更灵活的并发编程能力。以下是几个主要的扩展：

1. CompletableFuture类：CompletableFuture类是一个实现了CompletableFuture接口的异步计算类，用于处理异步任务的结果。它提供了一系列方法，可以通过回调、组合和转换等方式处理异步任务的完成结果。CompletableFuture类使得异步编程更加方便和直观。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @description: CompletableFuture并发编程示例
 * @author: shu
 * @createDate: 2023/7/1 9:45
 * @version: 1.0
 */
public class ConcurrencyDemo {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 使用CompletableFuture进行异步计算
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });

        // 使用CompletableFuture处理异步计算结果
        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2);
        combinedFuture.thenRun(() -> {
            int result1 = future1.join();
            int result2 = future2.join();
            map.put("result1", result1);
            map.put("result2", result2);
            System.out.println("Results: " + map);
        });

        // 等待所有任务完成
        combinedFuture.join();
    }
}

2. LongAdder和DoubleAdder类：LongAdder和DoubleAdder类是对AtomicLong和AtomicDouble的改进。它们提供了更高的并发性能，在高并发场景下更适合使用。LongAdder和DoubleAdder类通过分解内部计数器，将更新操作分散到多个变量上，以减少竞争和锁争用。

import java.util.concurrent.atomic.DoubleAdder;
import java.util.concurrent.atomic.LongAdder;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 9:51
 * @version: 1.0
 */
public class AdderDemo {
    public static void main(String[] args) {
        LongAdder longAdder = new LongAdder();
        DoubleAdder doubleAdder = new DoubleAdder();

        // 多线程并发增加值
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                longAdder.increment();
                doubleAdder.add(0.5);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                longAdder.increment();
                doubleAdder.add(0.5);
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出结果
        System.out.println("LongAdder Result: " + longAdder.sum());
        System.out.println("DoubleAdder Result: " + doubleAdder.sum());
    }
}

3. StampedLock类：StampedLock类是一种乐观读写锁，用于优化读多写少的场景。与传统的读写锁相比，StampedLock类引入了乐观读模式，避免了获取锁的开销，提供更好的并发性能。

import java.util.concurrent.locks.StampedLock;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 9:52
 * @version: 1.0
 */
public class StampedLockDemo {
    private double x, y;
    private final StampedLock lock = new StampedLock();

    public void move(double deltaX, double deltaY) {
        long stamp = lock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();
        double currentX = x;
        double currentY = y;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    public static void main(String[] args) {
        StampedLockDemo example = new StampedLockDemo();
        example.move(3, 4);
        double distance = example.distanceFromOrigin();
        System.out.println("Distance from origin: " + distance);
    }
}

4. ConcurrentHashMap类的改进：ConcurrentHashMap类在JDK 8中进行了一些改进，提供了更好的并发性能和扩展性。改进包括分段锁（Segmented Locking）机制的优化和内部数据结构的改进，以减少竞争和提高并发性能。

import java.util.concurrent.ConcurrentHashMap;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 9:54
 * @version: 1.0
 */
public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 多线程并发操作map
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.put("A" + i, i);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.put("B" + i, i);
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出map的大小和内容
        System.out.println("Map size: " + map.size());
        System.out.println("Map content: " + map);
    }
}

这些扩展提供了更多并发编程的工具和选择，使得在并发场景下编写高效、可靠的代码更加容易。开发人员可以根据具体需求选择合适的并发类，以提高应用程序的性能和可伸缩性。

二 JDK9 新特性

2.1 模块化​

JDK 9 引入了一个重要的特性，即模块化系统（Module System），也称为 Java 平台模块系统（Java Platform Module System，JPMS）。该特性的目标是改善 Java 平台的可伸缩性、安全性和性能。 模块化系统的主要思想是将 Java 平台分解为一系列模块，每个模块都有自己的封装和依赖关系。这些模块可以被组合在一起，以构建更大的应用程序或库。 下面是一些 JDK 9 模块化的关键概念：

1. 模块（Module）：模块是一个独立的单元，它由一组相关的包和类组成，并且具有清晰的边界。模块可以指定它所依赖的其他模块，并且可以明确地声明它对外部世界提供的公共 API。
2. 模块化源代码（Module Source Code）：在 JDK 9 中，源代码被组织为一组模块。每个模块都有自己的目录结构，其中包含模块定义文件 module-info.java，用于声明模块的名称、依赖关系和导出的包等信息。
3. 模块路径（Module Path）：模块路径是一组目录或 JAR 文件的集合，用于加载和链接模块。与传统的类路径不同，模块路径允许显式地指定模块之间的依赖关系。
4. 模块化 JAR 文件（Modular JAR File）：在 JDK 9 中，可以使用新的 JAR 文件格式来创建模块化的 JAR 文件。这些 JAR 文件包含模块定义文件以及其他模块所需的类和资源。
5. 模块化命令（Module-Related Commands）：JDK 9 引入了一些新的命令，用于处理模块化系统。例如，jdeps 命令用于分析模块之间的依赖关系，jlink 命令用于构建自定义运行时镜像。

模块化系统带来了许多好处，包括：

• 更好的可维护性：模块的边界清晰，易于理解和维护。
• 更好的可扩展性：模块之间的依赖关系更明确，使得应用程序和库的组合更加灵活。
• 更好的性能：模块化系统可以进行更精确的依赖分析和懒加载，从而提高应用程序的启动时间和运行时性能。
• 更好的安全性：模块可以明确声明它们的对外部世界的公共 API，从而提供更细粒度的访问控制。

需要注意的是，尽管 JDK 9 引入了模块化系统，但并不是所有的 Java 库和应用程序都需要立即迁移到模块化系统。在 JDK 9 中，仍然可以使用传统的类路径来运行非模块化的代码。但是，模块化系统为那些需要更好的可伸缩性和安全性的项目提供了一个强大的工具。

案例一

来个案例：首先在模块化中和需要再跟目录下定义module-info.java，里面上面你需要导入或者暴露的模块

/**
 * @description:
 * @author: shu
 * @createDate: 2023/6/30 11:20
 * @version: 1.0
 */
module Model {
    // TODO: 2023/6/30 导入我们需要的模块
    requires cn.hutool;
    // TODO: 2023/6/30 导出我们需要的模块
    exports  com.shu.model;
}

我们调用方法，如果没有导入模块你会发现没有发现该类

import cn.hutool.core.convert.Convert;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/6/30 11:21
 * @version: 1.0
 */
public class Test01 {
    public static void main(String[] args) {
        int a = 1;
        //aStr为"1"
        String aStr = Convert.toStr(a);
        long[] b = {1,2,3,4,5};
        //bStr为："[1, 2, 3, 4, 5]"
        String bStr = Convert.toStr(b);

    }
}

案例二

当一个案例来说明 JDK 9 的模块化系统如何工作。 假设我们正在开发一个简单的图书管理应用程序，它由几个模块组成：bookmanagement.core、bookmanagement.ui 和 bookmanagement.data。其中，bookmanagement.core 模块提供核心业务逻辑，bookmanagement.ui 模块提供用户界面，bookmanagement.data 模块提供数据访问功能。 每个模块都有自己的目录结构，并且包含一个模块定义文件 module-info.java。 首先，让我们看一下 bookmanagement.core 模块的 module-info.java 文件：

module bookmanagement.core {
    // 需要的模块
    requires bookmanagement.data;
    // 暴露的模块
    exports com.example.bookmanagement.core;
}

在这个文件中，我们声明了 bookmanagement.core 模块的名称，并且指定了它依赖于 bookmanagement.data 模块。我们还通过 exports 关键字明确声明了 com.example.bookmanagement.core 包对外的公共 API。 接下来，我们来看一下 bookmanagement.ui 模块的 module-info.java 文件：

module bookmanagement.ui {
    requires bookmanagement.core;
    exports com.example.bookmanagement.ui;
    // 使用那个接口
    uses com.example.bookmanagement.core.BookService;
}

在这个文件中，我们声明了 bookmanagement.ui 模块的名称，并且指定了它依赖于 bookmanagement.core 模块。我们通过 exports 关键字声明了 com.example.bookmanagement.ui 包对外的公共 API，并且使用 uses 关键字声明了它使用了 com.example.bookmanagement.core.BookService 接口。 最后，我们来看一下 bookmanagement.data 模块的 module-info.java 文件：

module bookmanagement.data {
    exports com.example.bookmanagement.data;
    provides com.example.bookmanagement.core.BookService
    with com.example.bookmanagement.data.DefaultBookService;
}

在这个文件中，我们声明了 bookmanagement.data 模块的名称，并且通过 exports 关键字声明了 com.example.bookmanagement.data 包对外的公共 API。我们还使用 provides 关键字声明了 com.example.bookmanagement.core.BookService 接口的实现类为 com.example.bookmanagement.data.DefaultBookService。 通过这些模块定义文件，我们明确了每个模块的名称、依赖关系和对外的公共 API。现在，我们可以使用 JDK 9 提供的命令进行编译、打包和运行。 例如，我们可以使用以下命令编译 bookmanagement.core 模块：

javac -d out/bookmanagement.core src/bookmanagement.core/module-info.java src/bookmanagement.core/com/example/bookmanagement/core/*.java

然后，我们可以使用 jar 命令将 bookmanagement.core 模块打包为一个模块化 JAR 文件：

jar --create --file=bookmanagement.core.jar --module-version=1.0 -C out/bookmanagement.core .

类似地，我们可以编译和打包 bookmanagement.ui 和 bookmanagement.data 模块。 最后，我们可以使用 java 命令来运行我们的应用程序，指定模块路径和主模块：

java --module-path bookmanagement.core.jar;bookmanagement.ui.jar;bookmanagement.data.jar --module bookmanagement.ui/com.example.bookmanagement.ui.Main

这样，我们就可以通过模块化系统构建和运行我们的图书管理应用程序。模块化系统帮助我们管理模块之间的依赖关系，确保模块的封装性和对外公共 API 的可控性。它提供了更好的可维护性、可扩展性和安全性。

2.2 JShell​

JDK 9 引入了一个名为 jshell 的交互式命令行工具，它提供了一个方便的方式来进行 Java 代码的实时交互式探索和实验。jshell 允许您在不需要编写完整的 Java 类或应用程序的情况下，直接在命令行中编写和执行代码片段。 以下是一些关键特性和用法说明：

1. 交互式编程：jshell 提供了一个交互式的命令行环境，您可以直接在命令行中输入和执行 Java 代码。您可以逐行输入代码片段，并立即查看结果。
2. 即时反馈：每次您输入一行代码，jshell 都会立即执行并显示结果。这样可以快速验证代码并获得实时反馈，无需编译和运行完整的 Java 程序。
3. 自动补全：jshell 提供了自动补全功能，可以帮助您快速输入代码和方法名。按下 Tab 键可以自动补全命令、类、方法等。
4. 历史记录：jshell 会记录您在交互式会话中输入的代码，并允许您在以后的会话中检索和重复使用之前的代码。
5. 异常处理：jshell 具有内置的异常处理机制，可以捕获并显示代码中的异常。它会提供有关异常的详细信息，以帮助您调试和修复问题。
6. 定义变量和方法：您可以在 jshell 中定义变量和方法，并在后续代码片段中使用它们。这使得您可以逐步构建复杂的逻辑和功能。
7. 多行输入：jshell 支持多行输入，您可以使用换行符（\）将一段代码分成多行。

要启动 jshell，您可以在命令行中输入 jshell 命令。然后，您可以开始输入 Java 代码并立即查看结果。以下是一个简单的示例会话：

$ jshell
|  Welcome to JShell -- Version 9
|  For an introduction type: /help intro

jshell> int x = 10;
x ==> 10

jshell> int y = 20;
y ==> 20

jshell> int sum = x + y;
sum ==> 30

jshell> System.out.println("The sum is: " + sum);
The sum is: 30

在这个示例中，我们定义了两个变量 x 和 y，并计算它们的和。然后，我们使用 System.out.println 方法打印结果，jshell 对于快速测试代码片段、尝试新功能或进行教学和演示非常有用，它提供了一个轻量级且便捷的方式来进行 Java 代码的交互式探索和验证。

2.3 改进 Javadoc​

Javadoc 工具可以生成 Java 文档， Java 9 的 javadoc 的输出现在符合兼容 HTML5 标准。

2.4 多版本兼容JAR​

多版本兼容 JAR 是 JDK 9 中引入的一个功能，它允许您创建仅在特定版本的 Java 环境中运行的库程序，并通过使用 --release 参数来指定编译版本。 在 JDK 9 之前，使用旧版本的 JDK 编译的 JAR 文件在较新的 Java 环境中可能会遇到兼容性问题。通过多版本兼容 JAR，您可以使用较新的 JDK 编译您的库程序，并指定兼容的目标 Java 版本，以确保在该版本及更高版本的 Java 环境中运行。 以下是使用 --release 参数创建多版本兼容 JAR 的步骤：

1. 编写您的库程序代码，并使用适当的 JDK 版本进行编译。假设您正在使用 JDK 11 编译您的库程序。
2. 使用以下命令创建多版本兼容 JAR 文件：

javac --release <target-version> -d <output-directory> <source-files>

其中：

• <target-version> 是您希望兼容的目标 Java 版本。例如，如果您希望兼容 Java 8，可以将 <target-version> 设置为 8。
• <output-directory> 是输出目录，用于存放编译生成的类文件。
• <source-files> 是您的源代码文件或源代码目录。

例如，要创建一个兼容 Java 8 的 JAR 文件，您可以运行以下命令：

javac --release 8 -d output mylibrary/*.java

这将使用 JDK 11 编译您的库程序，并生成与 Java 8 兼容的类文件。

3. 使用以下命令创建 JAR 文件：

其中：

• <jar-file> 是要创建的 JAR 文件的名称。
• <input-directory> 是包含编译生成的类文件的目录。

例如，要创建名为 mylibrary.jar 的 JAR 文件，您可以运行以下命令：

jar --create --file mylibrary.jar -C output .

这将创建一个包含编译生成的类文件的 JAR 文件，现在，您可以将生成的多版本兼容 JAR 文件提供给其他开发人员，以便他们可以在特定的 Java 环境中使用您的库程序。 需要注意的是，使用多版本兼容 JAR 并不会自动提供对较新 Java 版本的新功能和改进的支持。它仅确保您的库程序可以在指定的目标 Java 版本及更高版本的环境中运行，但不会利用较新版本的语言特性。因此，您需要根据您的目标 Java 版本的要求进行相应的编码和功能选择。

2.5 集合工厂方法​

在 Java 9 中，为集合框架引入了一组新的工厂方法，使创建和初始化集合对象更加简洁和方便。这些工厂方法属于 java.util 包中的 List、Set 和 Map 接口，用于创建不可变的集合对象。 下面是 Java 9 中引入的集合工厂方法的示例用法：

1. List.of() 方法用于创建不可变的列表对象。例如：

List<String> fruits = List.of("Apple", "Banana", "Orange");

在这个示例中，我们使用 List.of() 方法创建一个包含三个元素的不可变列表。

2. Set.of() 方法用于创建不可变的集合对象。例如：

Set<Integer> numbers = Set.of(1, 2, 3, 4, 5);

在这个示例中，我们使用 Set.of() 方法创建一个包含五个元素的不可变集合。

3. Map.of() 方法用于创建不可变的键值对映射。例如：

Map<String, Integer> studentScores = Map.of("Alice", 95, "Bob", 80, "Charlie", 90);

在这个示例中，我们使用 Map.of() 方法创建一个包含三对键值对的不可变映射。 这些集合工厂方法的特点是它们创建的集合对象都是不可变的，即无法修改集合中的元素。这种不可变性有助于编写更加健壮和可靠的代码，并提供更好的线程安全性。 需要注意的是，这些集合工厂方法创建的集合对象是不可变的，因此不能对其进行添加、删除或修改元素的操作。如果需要对集合进行修改操作，仍然可以使用传统的构造函数或其他方法来创建可变的集合对象。 另外，Java 9 中的集合工厂方法还提供了一系列的重载方法，用于处理不同数量的元素。您可以根据自己的需求选择适合的方法来创建集合对象。

2.6 私有接口方法​

Java 9 引入了一项新的特性，即私有接口方法。这意味着接口可以包含私有的方法实现，这些方法只能在接口内部被调用，对于接口的实现类和其他类是不可见的。 私有接口方法可以帮助解决以下问题：

1. 代码重用：通过在接口中定义私有方法，可以在多个默认方法之间共享代码逻辑，避免代码重复。
2. 代码组织：私有接口方法可以将复杂的逻辑分解为更小的、可重用的方法，提高代码的可读性和维护性。

下面是一个示例，演示了如何在接口中定义和使用私有接口方法：

public interface Calculator {
    // 公共的默认方法
    int add(int a, int b);

    default int subtract(int a, int b) {
        return add(a, negate(b));
    }

    default int multiply(int a, int b) {
        return a * b;
    }

    // 私有接口方法
    private int negate(int number) {
        return -number;
    }
}

在上面的示例中，Calculator 接口定义了三个默认方法 add()、subtract() 和 multiply()，以及一个私有接口方法 negate()。subtract() 方法内部调用了 add() 和 negate() 方法，而 negate() 方法是一个私有接口方法，只能在接口内部被调用。 通过私有接口方法，我们可以将 negate() 方法作为辅助方法来共享逻辑，并在多个默认方法中重复使用。 需要注意的是，私有接口方法不能被实现接口的类或其他类直接调用。它们仅用于在接口内部共享代码逻辑，提供更好的代码组织和代码重用。

2.7 该进的进程API​

在 Java 9 中，对进程 API 进行了一些改进，以提供更好的控制和管理应用程序的进程。这些改进主要集中在 java.lang.Process 类和相关类的增强。 以下是 Java 9 中进程 API 的一些改进：

1. ProcessHandle 类：引入了一个新的 ProcessHandle 类，它代表一个本地操作系统进程的句柄。通过 ProcessHandle 类，您可以获取进程的 PID（进程标识符）、父进程的句柄、子进程的句柄以及其他进程相关的信息。
2. ProcessHandle.Info 类：ProcessHandle 类中的 info() 方法返回一个 ProcessHandle.Info 对象，它提供了有关进程的详细信息，如进程的命令行参数、启动时间、累计 CPU 时间等。
3. ProcessBuilder 类的改进：ProcessBuilder 类用于创建和启动新的进程。在 Java 9 中，ProcessBuilder 类添加了一些新的方法，例如 inheritIO() 方法，它允许子进程继承父进程的标准输入、输出和错误流。还添加了 redirectInput()、redirectOutput() 和 redirectError() 方法，用于重定向子进程的标准输入、输出和错误流。
4. destroyForcibly() 方法：Process 类中的 destroyForcibly() 方法用于强制终止进程，无论进程是否响应。这与 destroy() 方法的区别在于，destroy() 方法会尝试优雅地终止进程，而 destroyForcibly() 方法会强制终止进程。

这些改进使得在 Java 中管理和控制进程更加灵活和方便。您可以获取和操作正在运行的进程的信息，获取进程的 PID，以及更好地控制子进程的输入、输出和错误流。这些改进为进程管理和监控提供了更多的功能和选项。 请注意，Java 9 中的进程 API 的改进主要集中在进程管理方面，并没有引入类似于进程间通信的新功能。如果您需要进行进程间通信，可以使用其他 Java 平台提供的库，如 java.nio.channels 或第三方库。

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 11:46
 * @version: 1.0
 */
public class ProcessInfoDemo {
    public static void main(String[] args) {
        // 获取当前进程的 ProcessHandle
        ProcessHandle currentProcess = ProcessHandle.current();

        // 获取当前进程的PID
        long pid = currentProcess.pid();
        System.out.println("当前进程的PID：" + pid);

        // 获取当前进程的信息
        ProcessHandle.Info processInfo = currentProcess.info();
        System.out.println("命令行：" + processInfo.command().orElse(""));
        System.out.println("启动时间：" + processInfo.startInstant().orElse(null));
        System.out.println("累计CPU时间：" + processInfo.totalCpuDuration().orElse(null));
    }

}

2.8 改进的Stream API​

在Java 9中，Stream API得到了一些改进，以提供更多的操作和增强功能。下面是Java 9中改进的一些Stream API功能：

1. takeWhile() 和 dropWhile() 方法：引入了 takeWhile() 和 dropWhile() 两个新的Stream方法。takeWhile() 方法返回从流的开头开始的连续元素，直到遇到第一个不满足给定条件的元素。dropWhile() 方法返回从流的开头开始跳过满足给定条件的连续元素，直到遇到第一个不满足条件的元素。
2. ofNullable() 方法：Stream接口中新增了一个 ofNullable() 静态方法，它允许创建一个包含一个非空元素或空的Stream。如果提供的元素是非空的，将创建一个包含该元素的Stream；如果提供的元素为空，则创建一个空的Stream。
3. iterate() 方法的重载：Stream.iterate() 方法现在支持一个谓词（Predicate）作为第二个参数。这样，您可以定义在生成迭代元素时应该终止迭代的条件。
4. Stream 接口中的新方法：Stream 接口中添加了一些新的方法，如 dropWhile()、takeWhile()、iterate() 的重载版本，以及 forEachOrdered() 和 toArray() 方法的重载版本。

这些改进使得Stream API更加灵活和功能更强大。您可以使用新的方法来处理更多的流操作场景，例如根据条件获取部分元素、创建包含空元素的流等。 以下是一个示例，展示了Java 9中改进的Stream API的一些用法：

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 11:52
 * @version: 1.0
 */
public class StreamApiDemo {
    public static void main(String[] args) {
        // takeWhile() 方法示例
        List<Integer> numbers = Stream.of(1, 2, 3, 4, 5, 6)
                .takeWhile(n -> n < 4)
                .collect(Collectors.toList());
        System.out.println("takeWhile 示例：" + numbers); // 输出：[1, 2, 3]

        // dropWhile() 方法示例
        List<Integer> numbers2 = Stream.of(1, 2, 3, 4, 5, 6)
                .dropWhile(n -> n < 4)
                .collect(Collectors.toList());
        System.out.println("dropWhile 示例：" + numbers2); // 输出：[4, 5, 6]

        // ofNullable() 方法示例
        String name = null;
        List<String> names = Stream.ofNullable(name)
                .collect(Collectors.toList());
        System.out.println("ofNullable 示例：" + names); // 输出：[]

        // iterate() 方法的重载示例
        List<Integer> evenNumbers = Stream.iterate(0, n -> n < 10, n -> n + 2)
                .collect(Collectors.toList());
        System.out.println("iterate 重载示例：" + evenNumbers); // 输出：[0, 2, 4, 6, 8]

        //

        //Stream 接口中的新方法示例
        Stream.of("Java", "Python", "C++")
                .forEachOrdered(System.out::println); // 输出：Java Python C++
    }
}

这个示例展示了如何使用Java 9中改进的Stream API的一些方法，包括takeWhile()、dropWhile()、ofNullable()、iterate()和forEachOrdered()等。您可以运行这个示例并观察输出结果，以便更好地理解这些改进的Stream API功能。

2.9 改进的 try-with-resources​

在Java 7中引入了try-with-resources语句，用于在代码块结束时自动关闭实现AutoCloseable接口的资源。Java 9对try-with-resources进行了改进，使其更加便利和灵活。 Java 9中改进的try-with-resources语句具有以下特点：

1. 支持资源的匿名变量：在Java 9之前，try-with-resources语句中的资源必须是事先声明的变量。在Java 9中，可以在try关键字之后声明资源的匿名变量，并在try语句块中使用。
2. 资源的效率改进：在Java 9中，如果资源实现了Closeable接口，编译器会生成更高效的字节码，以减少关闭资源的开销。

下面是一个示例，演示了Java 9中改进的try-with-resources语句的用法：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 16:04
 * @version: 1.0
 */
public class TryWithResourcesDemo {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们使用try-with-resources语句来自动关闭BufferedReader资源。在try关键字之后，我们创建了一个匿名的BufferedReader对象，并将其包装在FileReader中。在try语句块中，我们可以使用reader对象读取文件的内容。 当代码块结束时，无论是否发生异常，reader资源都会自动关闭。这样可以确保资源的正确释放，而无需显式调用close()方法。 需要注意的是，try-with-resources语句可以处理多个资源，只需将它们用分号分隔即可。所有的资源都会在代码块结束时自动关闭，按照资源的声明顺序逆序关闭。 通过使用Java 9中改进的try-with-resources语句，您可以更方便地处理资源的释放，并使代码更加简洁和易读。

2.10 改进的 @Deprecated 注解​

在Java 9中，@Deprecated注解得到了一些改进，以提供更多的注释功能和精确的描述。以下是Java 9中改进的@Deprecated注解的特点：

1. forRemoval属性：@Deprecated注解新增了一个forRemoval属性，用于指示该元素是否被打算用于移除。设置forRemoval=true表示该元素将来会被移除，而设置forRemoval=false表示该元素被废弃但将保留。
2. since属性：@Deprecated注解中的since属性用于指定元素被废弃的版本。通过指定since属性，您可以明确说明从哪个版本开始该元素被废弃。
3. 更多注释说明：Java 9为@Deprecated注解添加了更多的注释说明，使得可以提供更详细和精确的描述，以便开发人员了解为什么该元素被废弃以及推荐使用的替代方法。

下面是一个示例，演示了Java 9中改进的@Deprecated注解的用法：

public class DeprecatedExample {
    @Deprecated(since = "1.5", forRemoval = true)
    public void oldMethod() {
        // 旧的方法实现
    }

    @Deprecated(since = "2.0", forRemoval = false)
    public void deprecatedMethod() {
        // 废弃的方法实现
    }

    public static void main(String[] args) {
        DeprecatedExample example = new DeprecatedExample();

        // 调用旧的方法，会收到编译器警告
        example.oldMethod();

        // 调用废弃的方法，不会收到编译器警告
        example.deprecatedMethod();
    }
}

在这个示例中，我们定义了一个DeprecatedExample类，其中包含了两个方法：oldMethod()和deprecatedMethod()。我们使用改进的@Deprecated注解对这两个方法进行注释。 在oldMethod()方法上，我们设置了@Deprecated注解的since属性为"1.5"，forRemoval属性为true，表示该方法从版本1.5开始被废弃，并且将来会被移除。 在deprecatedMethod()方法上，我们设置了@Deprecated注解的since属性为"2.0"，forRemoval属性为false，表示该方法从版本2.0开始被废弃，但是会保留。 在main()方法中，我们实例化DeprecatedExample对象，并分别调用了旧的方法和废弃的方法。编译器会对调用旧的方法产生警告，而对调用废弃的方法不会产生警告。 通过使用Java 9中改进的@Deprecated注解，您可以提供更多的注释信息，包括指定废弃的版本和是否打算 移除，以便开发人员了解废弃元素的详细情况，并采取适当的行动。

2.11 钻石操作符​

钻石操作符（Diamond Operator）是Java 7中引入的语法糖，用于在实例化泛型类时省略类型参数的重复声明。Java 9对钻石操作符进行了改进，使其在更多的情况下可以使用。 在Java 9之前，钻石操作符只能用于变量声明的右侧，并且只能省略类型参数的声明，不能省略类型参数的具体实例化。例如：

List<String> list = new ArrayList<>(); // 使用钻石操作符，省略了类型参数的声明

在Java 9中，钻石操作符的适用范围得到了扩展。现在，钻石操作符不仅可以用于变量声明的右侧，还可以用于匿名类的实例化、显式的构造函数调用、显式的方法调用等更多的情况。例如：

// 在匿名类的实例化中使用钻石操作符
Map<String, Integer> map = new HashMap<>() {
    // 匿名类的实现
};

// 在显式的构造函数调用中使用钻石操作符
MyClass obj = new MyClass<>();

// 在显式的方法调用中使用钻石操作符
myMethod(new ArrayList<>());

通过在实例化时使用钻石操作符，可以使代码更简洁、更易读。编译器会根据上下文推断出类型参数，并自动进行类型推断。 需要注意的是，钻石操作符只能用于具有泛型类型的类的实例化。对于原始类型或无类型参数的类，仍需要显式地声明类型参数。 总结来说，Java 9对钻石操作符进行了改进，使其可以在更多的情况下使用，包括变量声明、匿名类的实例化、显式的构造函数调用、显式的方法调用等。这使得代码更加简洁和易读，同时不影响类型安全性。

2.12 改进的 Optional 类​

在Java 8中引入的Optional类提供了一种用于处理可能为null的值的封装。Java 9对Optional类进行了一些改进，以提供更多的实用方法和增强功能 下面是Java 9中改进的Optional类的特点：

1. ifPresentOrElse()方法：新增了ifPresentOrElse()方法，用于在Optional对象有值时执行一个操作，否则执行一个备选操作。这样可以避免使用传统的if-else语句来处理Optional对象的值。
2. stream()方法：Optional类中新增了stream()方法，用于将Optional对象转换为一个包含单个元素的Stream。如果Optional对象有值，则返回一个包含该值的Stream，否则返回一个空Stream。
3. or()方法的重载：Optional.or()方法现在支持Supplier函数接口，用于提供备选值。如果Optional对象为空，则使用Supplier提供的备选值。
4. ifPresentOrElse()方法的重载：ifPresentOrElse()方法现在支持两个Consumer函数接口，分别用于处理Optional对象有值时的情况和没有值时的情况。这样可以提供更多的灵活性和定制化的处理逻辑。

下面是一个示例，演示了Java 9中改进的Optional类的用法：

import java.util.Optional;

/**
 * @description:
 * @author: shu
 * @createDate: 2023/7/1 16:04
 * @version: 1.0
 */
public class OptionalDemo {
    public static void main(String[] args) {
        Optional<String> optionalValue = Optional.of("Hello");

        // 使用ifPresentOrElse()方法执行操作
        optionalValue.ifPresentOrElse(
                value -> System.out.println("Value: " + value),
                () -> System.out.println("No value present")
        );

        // 使用stream()方法将Optional转换为Stream
        optionalValue.stream()
                .forEach(value -> System.out.println("Stream value: " + value));

        // 使用or()方法提供备选值
        Optional<String> emptyOptional = Optional.empty();
        String result = emptyOptional.or(() -> Optional.of("Default Value"))
                .orElse("Fallback Value");
        System.out.println("Result: " + result);
    }
}

在这个示例中，我们使用Optional类创建了一个包含值的Optional对象。然后，我们使用改进的方法对Optional对象进行操作。 使用ifPresentOrElse()方法，我们指定了一个Consumer函数来处理Optional对象有值时的情况，并指定一个备选操作来处理Optional对象为空的情况。 使用stream()方法，我们将Optional对象转换为一个包含单个元素的Stream，并对每个元素执行操作。 在or()方法示例中，我们创建了一个空的Optional对象，并使用Supplier函数提供了一个备选值。如果Optional对象为空，则使用备选值。 通过使用Java 9中改进的Optional类，我们可以更方便地处理Optional对象，提供更多的处理选项，并使代码更简洁和可读。这些改进使得Optional类更加实用和强大。

三 JDK10 新特性

参考网站：https://openjdk.org/projects/jdk

286: Local-Variable Type Inference 局部变量类型推断

296: Consolidate the JDK Forest into a Single Repository JDK库的合并

304: Garbage-Collector Interface 统一的垃圾回收接口

307: Parallel Full GC for G1 为G1提供并行的Full GC

310: Application Class-Data Sharing 应用程序类数据（AppCDS）共享

312: Thread-Local Handshakes ThreadLocal握手交互

313: Remove the Native-Header Generation Tool (javah) 移除JDK中附带的javah工具

314: Additional Unicode Language-Tag Extensions 使用附加的Unicode语言标记扩展

316: Heap Allocation on Alternative Memory Devices 能将堆内存占用分配给用户指定的备用内存设备

317: Experimental Java-Based JIT Compiler 使用基于Java的JIT编译器

319: Root Certificates 根证书

322: Time-Based Release Versioning 基于时间的发布版本

3.1 局部变量类型推断​

JDK 10 引入了局部变量类型推断，通过使用 var 关键字，可以让编译器根据上下文自动推断局部变量的类型。这个特性可以使代码更加简洁和易读。 下面是一个示例：

var str = "Hello, World!"; // 推断为 String 类型
var list = new ArrayList<String>(); // 推断为 ArrayList<String> 类型

在上面的代码中，var 关键字用于声明局部变量 str 和 list，编译器根据右侧的表达式自动推断变量的类型为 String 和 ArrayList<String>。 需要注意的是，局部变量类型推断只能用于局部变量的声明和初始化，不能用于方法的参数、方法的返回类型、类的字段等。并且推断的类型是在编译时确定的，运行时变量的类型仍然是具体的类型，这个特性并不会影响 Java 的静态类型检查。 局部变量类型推断可以简化代码书写，特别是在使用泛型、匿名类和复杂类型时能够减少冗余的类型声明。然而，为了保持代码的可读性和清晰性，建议在使用 var 关键字时仍然给变量赋予有意义的名称。 请注意，这个特性是在 JDK 10 中引入的，如果你使用的是更早的 JDK 版本，将无法使用局部变量类型推断。

3.2 引入并行 Full GC算法​

• G1 是设计来作为一种低延时的垃圾回收器。G1收集器还可以进行非常精确地对停顿进行控制。从JDK7开始启用G1垃圾回收器，在JDK9中G1成为默认垃圾回收策略。截止到ava 9，G1的Full GC采用的是单线程算法。也就是说G1在发生Full GC时会严重影响性能。
• JDK10又对G1进行了提升，G1 引入并行 Full GC算法，在发生Full GC时可以使用多个线程进行并行回收。能为用户提供更好的体验。

3.3 应用程序类数据共享​

应用程序类数据共享（Application Class-Data Sharing）是 JDK 10 引入的一项特性，它旨在改善 Java 应用程序的启动性能和内存占用。 在传统的 Java 应用程序中，每次启动都需要加载和解析大量的类文件，这会消耗较多的时间和内存资源。应用程序类数据共享通过将类元数据和字节码预先计算和存储在共享的存档文件中，使得多个 Java 进程可以共享这些数据，从而减少了类加载和解析的时间和内存开销。 具体来说，应用程序类数据共享包括以下步骤：

1. 构建共享的类数据存档（Shared Class-Data Archive，CDS）：使用 java -Xshare:dump 命令构建共享的类数据存档。这个命令会启动应用程序，执行一些预热操作，然后生成一个包含类元数据和字节码的存档文件。
2. 启用应用程序类数据共享：使用 java -Xshare:on 命令启用应用程序类数据共享。在启用后，Java 进程将使用共享的类数据存档，从而减少类加载和解析的时间和内存占用。

通过应用程序类数据共享，可以显著缩短 Java 应用程序的启动时间和减少内存占用，尤其对于较大的应用程序或需要频繁启动的场景更为有效。 需要注意的是，应用程序类数据共享仅适用于具有相同类路径和相同类加载器结构的 Java 进程。因此，它主要适用于服务器端的 Java 应用程序，而对于客户端或桌面应用程序可能不太适用。 此外，应用程序类数据共享是 JDK 中的商业特性（Commercial Feature），只在 Oracle JDK 和 Oracle OpenJDK 中可用。在其他发行版或替代的 JDK 实现中，可能没有该特性或有所不同的实现方式。

3.4 线程本地握手​

• Safepoint是Hotspot JVM中一种让应用程序所有线程停止的机制。为了要做一些非常之安全的事情，需要让所有线程都停下来它才好做。比如菜市场，人来人往，有人忽然要清点人数，这时候，最好就是大家都原地不动，这样也好统计。Safepoint起到的就是这样一个作用。
• JVM会设置一个全局的状态值。应用线程去观察这个值，一旦发现JVM把此值设置为了“大家都停下来”。此时每个应用线程就会得到这个通知，然后各自选择一个point（点）停了下来。这个点就叫Safepoint。待所有的应用线程都停下来了。
• JVM就开始做一些安全级别非常高的事情了，比如下面这些事情：垃圾清理暂停。类的热更新。偏向锁的取消。各种debug操作。
• 然而，让所有线程都到就近的safepoint停下来本是需要较长的时间。而且让所有线程都停下来显得有些粗暴。为此Java10就引入了一种可以不用stop all threads的方式，就是Thread Local Handshake（线程本地握手）。该新特性的效果线程本地握手是在 JVM 内部相当低级别的更改，修改安全点机制，允许在不运行全局虚拟机安全点的情况下实现线程回调，使得部分回调操作只需要停掉单个线程，而不是停止所有线程。

3.5 JDK库的合并​

JDK 10 引入了一项名为 "JDK 库的合并"（Consolidate the JDK Forest into a Single Repository）的重要特性。在此之前，JDK 的源代码分布在多个 Mercurial 代码仓库中，而 JDK 10 将这些代码仓库合并为一个单一的 Git 代码仓库。 JDK 库的合并旨在简化 JDK 开发和维护过程，提高开发效率和代码管理的一致性。这项特性将 JDK 代码库从 Mercurial 迁移到 Git，并将所有相关代码合并到一个统一的 Git 仓库中，以便更方便地进行代码的版本控制、分支管理和协作开发。 通过将 JDK 代码库合并为一个 Git 仓库，开发者可以更轻松地浏览和查找 JDK 的源代码，同时更容易参与 JDK 的开发和贡献。此外，这也为社区提供了更便利的方式来提交错误报告、贡献补丁和参与 JDK 开发的讨论。 JDK 库的合并是 JDK 10 中一个重要的基础设施变更，对于 JDK 的开发者和维护者来说具有重要的影响。这项特性的引入标志着 JDK 开发过程中的一项重要改进，并为未来的 JDK 版本提供了更灵活和高效的开发基础。 请注意，以上信息基于 JDK 10 的版本。在更高版本的 JDK 中，可能会有一些变化和进一步的改进。建议查阅官方文档或相关资源以获取最新的信息和详细的说明。

3.6 实验型的垃圾回收接口​

JDK 10 的主要特性之一是引入了一种实验性的垃圾回收器接口，称为 "GC 接口"（GC Interface）。该接口的目标是提供一种标准化的方式，使得开发者可以更方便地实现自定义的垃圾回收器。 GC 接口允许开发者基于 JDK 的垃圾回收框架构建自定义的垃圾回收器。通过实现 GC 接口，开发者可以插入自己的垃圾回收算法和策略，并与 JDK 的其他部分进行集成。 然而，需要注意的是，GC 接口在 JDK 10 中仍然是一个实验性的功能，并且不建议在生产环境中使用。这个接口可能在未来的 JDK 版本中进行改进或变化，或者可能被更稳定的替代方案所取代。

3.7 移除JDK中附带的javah工具​

这个工具已经被 javac 中的高级功能所取代，这些功能是在 JDK 8(JDK-7150368)中添加的。此功能提供了在编译 Java 源代码时编写本机头文件的能力，从而消除了对单独工具的需求。

3.8 备⽤内存设备上的堆分配​

Java 的堆内存通常是分配在主内存中的，并由 JVM 进行管理。备用内存设备（如 SSD、NVMe 等）通常用于存储持久化数据或作为辅助存储设备，而不是用于直接的堆内存分配。 然而，对于大型数据处理、高性能计算等特定场景，可以使用一些特殊的技术和工具，例如使用内存映射文件（Memory-mapped Files）将部分堆内存映射到备用存储设备上，以扩展可用的堆内存空间。这种方法可以提供更大的内存容量，但需要谨慎考虑性能和数据访问的开销。

3.9 基于 Java 的实验性 JIT 编译器​

Java 10 引入了一个实验性的 JIT（Just-In-Time）编译器，称为 Graal 编译器。Graal 编译器是基于 Java 实现的，它提供了一种替代 HotSpot JIT 编译器的选择。 Graal 编译器具有以下一些特点和优势：

1. 高性能：Graal 编译器通过优化和即时编译技术提供了更好的性能表现，尤其在特定类型的工作负载上可能比 HotSpot JIT 编译器更快。
2. 低延迟：Graal 编译器的即时编译能力可以减少应用程序的停顿时间，从而提供更低的延迟和更高的响应性。
3. 兼容性：Graal 编译器与现有的 Java 代码和库兼容，并支持在现有的 JVM 环境中使用。

需要注意的是，尽管 Graal 编译器在性能和延迟方面可能带来优势，但它仍然是一个实验性的特性，并且在某些情况下可能与特定的代码或库不兼容。此外，Graal 编译器在编译速度和内存消耗方面可能会有一些权衡，具体取决于应用程序的特点和配置。 为了启用 Graal 编译器，您可以在 JDK 10+ 的启动参数中添加 -XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler。这将激活 Graal 编译器并使用它来编译 Java 代码。

3.10 根证书​

JDK 10 中的根证书库与之前的版本类似，仍然包含在 JDK 安装目录下的 "jre/lib/security" 目录中的 "cacerts" 文件中。 根证书库（cacerts）中包含了一系列受信任的根证书，用于验证 SSL/TLS 连接和其他安全通信。这些根证书由各种受信任的证书颁发机构（CA）签发，包括常见的公共 CA 如 VeriSign、Thawte、DigiCert 等。 在 JDK 10 中，根证书库可能会有更新，以反映最新的根证书颁发机构和信任链。由于根证书库的安全性至关重要，因此 Oracle 公司会定期更新 JDK 发布版本中的根证书库，以确保其中包含最新的根证书。 可以使用 JDK 提供的 "keytool" 工具来执行与根证书库相关的操作，例如查看证书、添加新的根证书、删除根证书等。这可以用于管理 JDK 10 中的根证书库，并确保其与最新的证书颁发机构保持同步。 需要注意的是，根证书库的管理需要谨慎操作，确保只信任可靠和受信任的证书颁发机构，并避免操纵根证书库以防止安全风险。

四 JDK11 新特性

参考官网：https://openjdk.org/projects/jdk/11/

181: Nest-Based Access Control
181: 基于嵌套的访问控制
309: Dynamic Class-File Constants
309: 动态类文件常数
315: Improve Aarch64 Intrinsics
315: 改进 Aarch64内部结构
318: Epsilon: A No-Op Garbage Collector
318: Epsilon: 一个不可操作的垃圾收集器
320: Remove the Java EE and CORBA Modules
320: 删除 JavaEE 和 CORBA 模块
321: HTTP Client (Standard)
321: HTTP 客户端(标准)
323: Local-Variable Syntax for Lambda Parameters
323: Lambda 参数的局部变量语法
324: Key Agreement with Curve25519 and Curve448
324: 与 Curve25519和 Curve448的关键协议
327: Unicode 10
328: Flight Recorder
328: 飞行记录器
329: ChaCha20 and Poly1305 Cryptographic Algorithms
329: ChaCha20和 Poly1305密码算法
330: Launch Single-File Source-Code Programs
330: 启动单文件源代码程序
331: Low-Overhead Heap Profiling
331: 低开销堆分析
332: Transport Layer Security (TLS) 1.3
332: 传输层安全(TLS)1.3
333: ZGC: A Scalable Low-Latency Garbage Collector
   (Experimental)
333: ZGC: 一个可伸缩的低延迟垃圾收集器(实验)
335: Deprecate the Nashorn JavaScript Engine
335: 废弃 Nashorn JavaScript 引擎
336:
Deprecate the Pack200 Tools and API废弃 Pack200工具和 API

4.1 Lambda 参数的局部变量语法​

在JDK 11及更高版本中，Lambda表达式的参数可以使用var关键字来声明局部变量。使用var关键字可以让编译器根据上下文推断参数的类型。以下是Lambda参数的局部变量语法示例：

interface MyInterface {
    void myMethod(String name, int age);
}

public class Main {
    public static void main(String[] args) {
        MyInterface myLambda = (var name, var age) -> {
            System.out.println("Name: " + name);
            System.out.println("Age: " + age);
        };

        myLambda.myMethod("John", 25);
    }
}