正数：-1.401298E-45到3.402823E+38 | | | **double（默认）** | 8字节 | 负数：-1.797693E+308到-4.9000000E-324
正数：4.9000000E到1.797693E+308 | | **字符** | **char** | 2字节 | 0-65535 | | **布尔** | **boolean** | 1字节 | true，false | 说明：E+38表示是乘以10的38次方，同样，E-45表示乘以10的-45次方。 ### 类型转换 在 java 程序中，不同的基本类型的值经常需要进行相互类型转换，类型转换分为**自动类型转换**和**强制类型转换**。  **自动类型转换**： 把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。 * 例如：`double a = 10；` * **规律** - 小的类型自动转化为大的类型 - 整数类型可以自动转化为浮点类型，可能会产生舍入误差 - 字符可以自动提升为整数 **强制类型转换**：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。 * 例如：`int j = (int) 99.99;` * 在要强制类型转换的前面加上括号，然后在括号里面加上你要转换的类型（强制转换需要程序员手动处理） ### 运算符 * **运算符**：对常量或者变量进行操作的符号 * **表达式**：用运算符吧常量或者变量连接起来的符号 #### 算术运算符 | **操作符** | **说明** | **举例** | | ------- | ------ | --------------- | | **+** | **加** | **加法** | | **-** | **减** | **减法** | | **\*** | **乘** | **乘法** | | **/** | **除** | **除法** | | **%** | **取余** | **得到两个数做除法的余数** | | **++** | **自增** | **变量的值+1** | | **--** | **自减** | **变量的值-1** | **搞清楚`i++`，`++i`，`i--`，`--i`的区别?** * `++i`，表示参与运算之前先自加1. * `i++`，表示参与运算以后再加1. * `--i`，`i--` 类似。 #### 关系运算符 | **操作符** | **说明** | | ------- | ------------------------------------ | | **==** | **检查如果两个操作数的值是否相等，如果相等则条件为真。** | | **!=** | **检查如果两个操作数的值是否相等，如果值不相等则条件为真。** | | **>** | **检查左操作数的值是否大于右操作数的值，如果是那么条件为真。** | | **<** | **检查左操作数的值是否小于右操作数的值，如果是那么条件为真。** | | **>=** | **检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。** | | **<=** | **检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。** | * 注意事项：关系运算符的结果都是boolean类型，要么是true，要么是false。 * 千万不要把“==”误写成“=”，“==”是判断是否相等的关系，“=”是赋值。 #### 位运算符 | **操作符** | **说明** | | ------- | -------------------------------------- | | **＆** | 如果相对应位都是1，则结果为1，否则为0 | | \| | 如果相对应位都是 0，则结果为 0，否则为 1 | | **〜** | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | | **^** | 如果相对应位值相同，则结果为0，否则为1 | | **<<** | 按位左移运算符。左操作数按位左移右操作数指定的位数。左移一位相当于将原数*2 | | **>>** | 按位右移运算符。左操作数按位右移右操作数指定的位数。右移一位相当于将原数/2 | #### 逻辑运算符 逻辑运算符把各个运算的关系表达式联系起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断结果是`true`或`false`。 | **操作符** | **说明** | **举例** | | ------- | --------- | --------------------------------------- | | **＆&** | 逻辑与 运算符。 | 当且仅当两个操作数都为真，条件才为真。 | | \|\| | 逻辑或 操作符。 | 如果任何两个操作数任何一个为真，条件为真。 | | **^** | 逻辑异或 操作符。 | 如果任意两个操作数结构不相同，条件为真，否则条件假 | | **!** | 逻辑非 运算符。 | 用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | #### 短路运算符 | **操作符** | **说明** | **举例** | | ------- | ------ | ----------------- | | **＆&** | 短路与 | 作用和 & 相同，但是有短路效果 | | \|\| | 短路或 | 作用和 \| 相同，但是有短路效果 | * 短路与 &&：如果左边为真，右边执行；如果左边为假，右边不执行。 * 短路或 ||：如果左边为假，右边执行；如果左边为真，右边不执行。 #### 三元运算符 ( ? : ) * **语法是：“条件表达式 ? 表达式1 : 表达式2”；** * `?`前面的位置是判断的条件，判断结果为`boolean`型 * 为`true`时调用**表达式1**，为`false`时调用**表达式2**  ### Scanner打印机用法 ```java import java.util.Scanner; // ① 导包 public class ScannerDemo { public static void main(String[] args) { // ② 创建对象 Scanner scan = new Scanner(System.in); // ③ 接收数据 System.out.print("请输入你的名字："); String name = scan.nextLine(); // 接收字符串 System.out.print("请输入你的年龄："); int age = scan.nextInt(); // 接收整数 System.out.print("请输入你的身高(米)："); double height = scan.nextDouble(); // 接收小数 // 输出结果 System.out.println("------ 信息展示 ------"); System.out.println("姓名：" + name); System.out.println("年龄：" + age); System.out.println("身高：" + height + " 米"); // 关闭Scanner（养成好习惯） scan.close(); } } ``` ### 流程控制语句 #### 顺序结构 是程序中最简单的流程控制，按照代码执行的先后顺序，依次执行，程序中的大多数代码都是这样执行的。  #### 分支结构（if，switch） 选择结构也被称为分支结构。选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。 ##### if语句 ```java // 语法 if(布尔表达式){ 语句体 } ```  ##### if-else语句 ```java // 语法 f(关系表达式) { 语句体1; } else { 语句体2; } ```  ##### 多重if-else语句 ```java // 语法 if (判断条件1) { 执行语句1 } else if (判断条件2) { 执行语句2 } ... else if (判断条件n) { 执行语句n } else { 执行语句n+1 } ```  ##### switch语句 ```java // 语法 switch(表达式) { case目标值1: 语句体1; break; case目标值2: 语句体2; break; … default: 语句体n+1; break; } ```  #### 循环结构（for，while，do..while） 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。 ##### for循环 ```java // 语法 for(初始化表达式;布尔表达式;步进表达式){ 循环体 } ```  ##### **while循环** ```java // 语法 while(布尔表达式) { 循环体语句; } // 扩展格式 初始化表达式① while(布尔表达式②){ 循环体③ 步进表达式④ } ```  ##### **do while循环** ```java // 语法 do{ 循环体语句; }while(布尔表达式); // 扩展格式 初始化表达式① do{ 循环体③ 步进表达式④ }while(布尔表达式②); ```  ##### 三种不同循环的区别 * `do…while`循环至少会执行一次循环体。 * `for`循环和`while`循环只有在条件成立的时候才会去执行循环体 * `for`循环语句和while循环语句的小区别： **使用区别：** 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。 #### break和contiune区别 * `break`直接中断当前的整个循环，`continue`跳出本次的循环进入下一次。 * `continue`只能在循环中进行使用。 #### 嵌套for循环语句 可以通过带**标记**的`break`和`continue`结束或跳出多重循环。  ## 4.Java 方法 ### 什么是方法？ 方法的本意是**功能块**，就是实现某个功能的语句块的集合。 ### 方法的定义与调用 ```java // 语法 修饰符 返回类型 方法名(参数列表) { // 方法体：具体执行的代码 return 返回值; // 如果有返回类型，必须返回相应类型的值 } ``` 各部分解释： 1. 修饰符（modifier）：如 `public`, `private`, `static`，控制方法的访问范围和行为 2. 返回类型（return type）：方法执行后返回的数据类型，如果不返回值则写 `void` 3. 方法名（method name）：方法的名字，命名规则和变量名类似 4. 参数列表（parameters）：方法执行所需的外部数据，可以没有参数 5. 方法体（body）：实际执行的操作 6. 返回值（return）：方法执行后返回的结果，如果返回类型是 `void`，则无需 `return` **方法的调用** ```java public class MethodInvoke { // 静态方法 public static void staticMethod() { System.out.println("这是静态方法"); } // 无参数、无返回值 public void sayHello() { System.out.println("Hello, Java!"); } // 有参数 public void greet(String name) { System.out.println("Hello, " + name + "!"); } // 有返回值 public int add(int a, int b) { return a + b; } public static void main(String[] args) { // 调用静态方法 MethodInvoke.staticMethod(); // 创建对象，调用非静态方法 MethodInvoke invoke = new MethodInvoke(); invoke.sayHello(); // 输出问候 invoke.greet("Alice"); // 输出个性化问候 System.out.println(invoke.add(5, 7)); // 输出 12 } } ``` ### 方法的重载 **定义：** 重载就是在一个类中，有相同的函数名称，但形参不同的函数。 * 返回类型可以相同，也可以不同 * **仅靠返回类型不同不能构成重载** ```java public class OverloadDemo { public void show() { System.out.println("无参数方法"); } public void show(String name) { System.out.println("一个参数：" + name); } public void show(String name, int age) { System.out.println("两个参数：" + name + ", " + age); } public static void main(String[] args) { OverloadDemo demo = new OverloadDemo(); demo.show(); // 调用无参数方法 demo.show("Alice"); // 调用一个参数方法 demo.show("Bob", 25); // 调用两个参数方法 } } 输出： 无参数方法 一个参数：Alice 两个参数：Bob, 25 ``` ### 命令行传参 有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给`main()`函数实现。 ```java public class CommandLine { public static void main(String[] args) { for (int i = 0; i < args.length; i++) { System.out.println("args[" + i + "]: " + args[i]); } } } ``` 运行方式（文件名为 `CommandLine.java`）： ```shell javac CommandLine.java java CommandLine hello world 123 输出结果： args[0]: hello args[1]: world args[2]: 123 ``` ### 可变参数(...) 在 Java 里，**可变参数（varargs）** 用来让方法接收不定数量的参数。 ```java // 语法 返回类型 方法名(参数类型... 参数名) { } ``` **可变参数求最大值案例：** ```java public class VarArgsMax { // 使用可变参数求最大值 public static void printMax(double... numbers) { if (numbers.length == 0) { System.out.println("未传递参数"); return; } double result = numbers[0]; for (int i = 1; i < numbers.length; i++) { if (numbers[i] > result) { result = numbers[i]; } } System.out.println("最大值是 " + result); } public static void main(String[] args) { printMax(1.2, 3.4, 0.5); // 多个参数 printMax(10); // 单个参数 printMax(); // 没有参数 printMax(new double[]{7.7, 9.9, 8.8}); // 传数组 } } ``` ### 递归（recursion） 👉 递归本质就是就是：**方法自己调用自己**。 递归结构包含两个部分： - **递归头**：终止条件（避免无限调用） - **递归体**：继续调用自身（问题规模要缩小） #### 阶乘（Factorial） ```java public class RecursionDemo { // 计算 n 的阶乘：n! = n * (n-1) * (n-2) * ... * 1 public static int factorial(int n) { if (n == 1) return 1; // 递归头 return n * factorial(n - 1); // 递归体 } public static void main(String[] args) { System.out.println("5! = " + factorial(5)); // 输出 120 } } ``` #### 斐波那契（Fibonacci Sequence） ```java public class FibonacciDemo { /** * 斐波那契数列（Fibonacci Sequence） * 特点： * 1. 第1项 = 1，第2项 = 1（固定） * 2. 从第3项开始，每一项 = 前两项之和 * 数学公式： * F(1) = 1 * F(2) = 1 * F(n) = F(n-1) + F(n-2) (n >= 3) * * 示例： * 第1项：1 * 第2项：1 * 第3项：2 (1+1) * 第4项：3 (2+1) * 第5项：5 (3+2) * 数列：1, 1, 2, 3, 5, 8, 13, 21, 34, ... */ // 使用递归实现斐波那契 public static int fib(int n) { // 递归出口：第1项或第2项，直接返回1 if (n == 1 || n == 2) return 1; // 递归体：第n项 = 前两项之和 return fib(n - 1) + fib(n - 2); } public static void main(String[] args) { // 输出前10项 for (int i = 1; i <= 10; i++) { System.out.print(fib(i) + " "); } } } ``` ## 5.Java 数组（Array） ### 什么是数组？ 定义：数组是**相同数据类型元素**的有序集合，具有以下特点： - **连续存储**：数组在内存中占用连续的存储空间。 - **下标访问**：每个元素通过唯一索引访问，下标从0开始。 - **长度固定**：一旦创建，长度不可改变。 - **类型统一**：数组中的所有元素必须是相同类型，可以是基本类型或引用类型。 - **数组是对象**：在Java中，数组属于引用类型，存储在堆内存中，数组元素类似对象的成员变量。 ### 数组声明与创建 **声明** ```java // 声明，以 int 为例 int[] numbers; // ✅ 推荐写法 int numbers2[]; ``` **创建** ```java int[] numbers = new int[5]; // 创建一个长度为5的int数组 ``` **访问元素** * 数组索引从 0 开始，到 length - 1 结束。 * 使用 `数组名[索引]` 访问元素。 ```java numbers[0] = 10; // 修改第一个元素 int first = numbers[0]; // 访问第一个元素 System.out.println(numbers[0]); ``` 注意：数组下标范围 `[0, length-1]`，越界会抛出 `ArrayIndexOutOfBoundsException`。 ### 数组初始化方式 ```java ① 静态初始化 int[] a = {1, 2, 3}; Man[] mans = {new Man(1,1),new Man(2,2)}; ② 动态初始化 int[] a = new int[2]; a[0] = 1; a[1] = 2; ③ 数组的默认初始化 当使用动态初始化时，数组元素会自动被赋予该类型的默认值 ``` ### 数组内存分析 **先了解Java 内存模型**  数组对象存储在**堆内存**中。 数组变量本身在栈内存中保存**堆地址引用**。 每个线程都有独立的程序计数器（PC），控制执行流程。  ### 反转数组 ```java public void reverse(int[] nums) { int left = 0, right = nums.length - 1; while (left < right) { int temp = nums[left]; nums[left] = nums[right]; nums[right] = temp; left++; right--; } } ``` ### java.util.Arrays 类 ```java import java.util.Arrays; public class ArraysDemo { public static void main(String[] args) { // 初始化一个数组 int[] a = {1, 6, 8, 19, 1000, 999, 178, -1, 0, 5}; System.out.println("原始数组: " + Arrays.toString(a)); // 1. 排序（升序） Arrays.sort(a); System.out.println("排序后: " + Arrays.toString(a)); // 2. 二分查找（前提是数组已排序） int index = Arrays.binarySearch(a, 19); System.out.println("数字 19 的索引: " + index); // 3. 填充数组 int[] b = new int[5]; Arrays.fill(b, 7); System.out.println("填充后的数组: " + Arrays.toString(b)); // 4. 数组复制（扩容） int[] c = Arrays.copyOf(a, 15); System.out.println("扩容后的数组: " + Arrays.toString(c)); // 5. 部分复制 int[] d = Arrays.copyOfRange(a, 2, 6); // 下标 [2,6) System.out.println("部分复制: " + Arrays.toString(d)); // 6. 比较数组是否相等 int[] e = { -1, 0, 1, 5, 6, 8, 19, 178, 999, 1000 }; Arrays.sort(e); // 确保顺序一致 System.out.println("数组a与数组e是否相等: " + Arrays.equals(a, e)); // 7. 多维数组打印 int[][] f = {{1, 2}, {3, 4, 5}}; System.out.println("二维数组: " + Arrays.deepToString(f)); // 8. 并行排序（大数组时更快） int[] g = {10, 9, 8, 7, 6, 5}; Arrays.parallelSort(g); System.out.println("并行排序结果: " + Arrays.toString(g)); } } ``` ### 冒泡排序 冒泡的代码还是相当简单的。两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。 ```java import java.util.Arrays; // 冒泡排序 public class BubbleSortDemo { public static void main(String[] args) { int[] a = {1, 6, 8, 19, 1000, 999, 178, -1, 0, 5}; bubbleSort(a); System.out.println("冒泡排序后: " + Arrays.toString(a)); } public static void bubbleSort(int[] array) { // 外层循环控制轮数 for (int i = 0; i < array.length - 1; i++) { boolean swapped = false; // 标记本轮是否发生过交换 // 内层循环控制比较和交换 for (int j = 0; j < array.length - 1 - i; j++) { if (array[j] > array[j + 1]) { int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; swapped = true; } } if (!swapped) break; } } } ``` ================================================ FILE: src/md/java/datetime/README.md ================================================ --- title: Java 日期时间 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-03 category: Java Dates tags: - date-time --- # Java 日期时间 > 此文参考文献：[【howtodoinjava】-Java 日期时间教程](https://howtodoinjava.com/java/date-time/guides-java-date-time/) 长期以来，传统的 Java API 一直是 Java 开发人员的一大痛点。随着[Java 8](https://howtodoinjava.com/java-8-tutorial/)版本（[JSR-310](https://jcp.org/en/jsr/detail?id=310) ）的发布，`java.time`包引入了新的[不可变](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)类，解决了原有类存在的问题。 以下文章旨在帮助您开始使用[新的日期时间 API ](/md/java/date-time/intro-to-date-time-api)的一些常见任务。 ## 1. 获取当前日期和时间 - [获取当前日期和时间](/md/java/datetime/datetime) - [获取当前时间戳](/md/java/datetime/timestamp) - [获取当前用户区域设置、国际化](/md/java/datetime/locale) ## 2. 比较日期和时间 - [日期比较](/md/java/datetime/compare-dates) - [ZonedDateTime 和 OffsetDateTime 的区别](/md/java/datetime/zoneddatetime-vs-offsetdatetime) ## 3. 转换日期和时间 - [转换日期时间实例](/md/java/datetime/convert-dates) ## 4. 将字符串解析为日期 - [Java 日期格式验证](https://howtodoinjava.com/java/date-time/date-validation/) - [将字符串转换为 UTC 日期时间](https://howtodoinjava.com/java/date-time/parse-string-to-date-time-utc-gmt/) - [将字符串转换为 ZonedDateTime](https://howtodoinjava.com/java/date-time/zoneddatetime-parse/) - [将字符串转换为本地日期时间](https://howtodoinjava.com/java/date-time/localdatetime-parse/) - [将字符串转换为本地日期](https://howtodoinjava.com/java/date-time/localdate-parse-string/) - [将字符串解析为 java.util.Date](https://howtodoinjava.com/java/date-time/java-date-examples/) - [Java 严格、智能和宽松的日期解析](https://howtodoinjava.com/java/date-time/resolverstyle-strict-date-parsing/) - Spring Boot 日期格式验证注解（_待办事项_） - 验证多种日期格式（_待办事项_） ## 5. 将日期格式化为字符串 - [在 Java 中将日期格式化为字符串](https://howtodoinjava.com/java/date-time/java-date-formatting/) - [格式化分区日期时间](https://howtodoinjava.com/java/date-time/format-zoneddatetime/) - [格式化本地日期时间](https://howtodoinjava.com/java/date-time/format-localdatetime-to-string/) - [格式化本地日期](https://howtodoinjava.com/java/date-time/localdate-format-example/) - [格式 XMLGregorianCalendar](https://howtodoinjava.com/java/date-time/format-xmlgregoriancalendar-to-date-pattern/) - [基于位置的货币格式](https://howtodoinjava.com/java/date-time/location-based-currency-formatting-in-java/) - [基于位置的日期时间格式](https://howtodoinjava.com/java/date-time/locale-based-date-formatting/) - [以用户时区显示本地化时间戳](https://howtodoinjava.com/java/date-time/display-localized-timestamps/) - [以 12 小时制格式格式化日期/时间戳](https://howtodoinjava.com/java/date-time/format-time-12-hours-pattern/) - [将毫秒级持续时间格式化为小时、分钟和秒](https://howtodoinjava.com/java/date-time/format-millis-to-hh-mm-ss/) ## 6. 日期和时间提取与处理 - [测量经过时间](https://howtodoinjava.com/java/date-time/execution-elapsed-time/) - [两个日期之间的差异](/md/java/datetime/date-diff) - [计算两个日期之间的天数](https://howtodoinjava.com/java/date-time/calculate-days-between-dates/) - [获取两个日期之间的所有日期](https://howtodoinjava.com/java/date-time/dates-between-two-dates/) - [检查日期或本地日期是否为周末。](https://howtodoinjava.com/java/date-time/check-weekend/) - [计算两个日期之间的工作日](https://howtodoinjava.com/java/date-time/calculate-business-days/) - [增加或减少工作日](https://howtodoinjava.com/java/date-time/add-subtract-business-days/) - [获取下一个和上一个日期](https://howtodoinjava.com/java/date-time/java8-next-previous-date/) - [请检查给定年份是否为闰年？](https://howtodoinjava.com/java/date-time/check-leap-year/) - [增加或减少天数、月份和年份](https://howtodoinjava.com/java/date-time/add-days-months-years/) - [增加或减少小时、分钟和秒](https://howtodoinjava.com/java/date-time/add-subtract-hours-minutes-seconds/) - [从日期中获取年、月和日](https://howtodoinjava.com/java/date-time/get-year-month-day-from-date/) - [确定约会的星期几](https://howtodoinjava.com/java/date-time/finding-day-of-week/) - [用于匹配日期模式的正则表达式](https://howtodoinjava.com/java/regex/java-regex-date-format-validation/) - [如何设置 JVM 时区](https://howtodoinjava.com/java/date-time/setting-jvm-timezone/) - [一天的开始和结束](https://howtodoinjava.com/java/date-time/start-and-end-of-day/) ## 7. 日期时间 API - [Java 本地化类](https://howtodoinjava.com/java/date-time/java-locale-api-examples/) - [Java 类 LocalTime](https://howtodoinjava.com/java/date-time/java-localtime/) - [Java 类 LocalDate](https://howtodoinjava.com/java/date-time/java-time-localdate-class/) - [Java 类 LocalDateTime](https://howtodoinjava.com/java/date-time/java-localdatetime-class/) - [Java ZonedDateTime 类](https://howtodoinjava.com/java/date-time/zoneddatetime-class/) - Java OffsetDateTime（_待办事项_） - [Java XMLGregorianCalendar](https://howtodoinjava.com/java/date-time/xmlgregoriancalendar-date-string-example/) - Java SimpleDateFormat (_TODO_) - [Java DateTimeFormatter](https://howtodoinjava.com/java/date-time/java8-datetimeformatter-example/) - [爪哇时期](https://howtodoinjava.com/java/date-time/java8-period/) - Java 持续时间（_待办事项_） - [Java 星期几](https://howtodoinjava.com/java/date-time/find-dayofweek/) - [Java 时间调整器](https://howtodoinjava.com/java/date-time/java8-temporal-adjusters/) - [Java TemporalQuery](https://howtodoinjava.com/java/date-time/temporalquery/) - Java InstantSource（_待办事项_） 快乐学习！ ================================================ FILE: src/md/java/datetime/api.md ================================================ --- title: Java 日期时间 API shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-03 category: Java Dates tags: - date-time --- # Java 日期时间 API > 此文参考文献： > > - [【菜鸟教程】-Java 日期时间](https://www.runoob.com/java/java-date-time.html) > - [【howtodoinjava】- Java 8 日期时间 API](https://howtodoinjava.com/java/date-time/intro-to-date-time-api/) Java 主要使用两个包`java.time`和`java.util`支持日期和时间特性。 `java.time`包是在 Java 8 [JSR-310](https://jcp.org/en/jsr/detail?id=310) 中新增的，解决了旧版 `java.util.Date`和`java.util.Calendar`类的不足之处。 ## 遗留 API Java 8 之前的日期时间处理主要依赖 `Date`、`Calendar`、`SimpleDateFormat` 和 `TimeZone` 等遗留 API，本质上围绕**毫秒时间戳**进行封装、计算、格式化及时区转换。 | 类/方法 | 用途 | |-------------------------------------------------------------------------------------------------------------------------|-----------------------------------| | [System.currentTimeMillis()](https://docs.oracle.com/javase/7/docs/api/java/lang/System.html#currentTimeMillis%5C(%5C)) | 获取当前时间的 **毫秒时间戳** | | [java.util.Date](https://docs.oracle.com/javase/7/docs/api/java/util/Date.html) | 对时间戳进行封装，表示一个具体的 **时间点** | | [java.util.Calendar](https://docs.oracle.com/javase/7/docs/api/java/util/Calendar.html) | 提供按 **年、月、日、时、分、秒** 等字段进行计算和操作的能力 | | [java.text.SimpleDateFormat](https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html) | 负责 **日期与字符串之间的格式化与解析**，受时区和区域设置影响 | | [java.util.TimeZone](https://docs.oracle.com/javase/7/docs/api/java/util/TimeZone.html) | 表示 **时区偏移量**，可计算夏令时 | **核心缺陷**： 旧的日期时间 API 既易出错又不直观，难以安全、清晰地表示日期与时间。 1. _可变性_：`Date` 和 `Calendar` 类是可变的，这可能导致意外的副作用和**线程安全问题**。 2. _设计缺陷_：月份从 0 开始计数，年份从 1900 开始计数，这可能导致混淆。 3. _有限的功能_：这些类缺乏对日期和时间操作的丰富支持，例如处理时区、闰秒等。 因此，其他许多第三方库（例如 [Joda-Time](https://www.joda.org/joda-time/) 或 [Apache Commons](https://commons.apache.org/) 中的类）也更加受欢迎。 ## Java 8 Time API 新的日期 API 尝试解决旧类的上述问题。 它主要包含以下类： | 类/接口 | 用途 | | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------- | | [java.time.LocalDate](https://docs.oracle.com/javase/8/docs/api/java/time/LocalDate.html) | 不带时间的**日期** | | [java.time.LocalTime](https://docs.oracle.com/javase/8/docs/api/java/time/LocalTime.html) | 不带日期的**时间** | | [java.time.Instant](https://docs.oracle.com/javase/8/docs/api/java/time/Instant.html) | 时间线上的一个**瞬间点** | | [java.time.LocalDateTime](https://docs.oracle.com/javase/8/docs/api/java/time/LocalDateTime.html) | **日期和时间** | | [java.time.ZonedDateTime](https://docs.oracle.com/javase/8/docs/api/java/time/ZonedDateTime.html) | 包含**时区**的完整日期和时间 | | [java.time.OffsetDateTime](https://docs.oracle.com/javase/8/docs/api/java/time/OffsetDateTime.html) | 包含**UTC 偏移量**的完整日期和时间 | | [java.time.Duration](https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html) | **时间量**，两个时间点之间的**时间段** | | [java.time.Period](https://docs.oracle.com/javase/8/docs/api/java/time/Period.html) | **时间量**，两个日期之间的**日期段** | | [java.time.format.DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) | **格式化解析器** | | [java.time.ZoneId](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) | **时区标识符**（如 `Asia/Shanghai`） | | [java.time.ZoneOffset](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneOffset.html) | **UTC 偏移量**（如 `+08:00`） | ## 执行常见任务 [🐟代码小抄-Java 日期、时间常用API](https://codecopy.cn/post/suloc9) ```java import java.time.*; import java.time.format.DateTimeFormatter; import java.time.temporal.ChronoUnit; /** * Java8 日期时间API的通用操作 */ public class Java8DateTimeCommonOperations { public static void main(String[] args) throws InterruptedException { // 获取当前日期和时间 // 所有日期时间类都有一个工厂方法 now() 这是在 Java 8 中获取当前日期和时间的首选方法。 LocalTime currentTime = LocalTime.now(); LocalDate currentDate = LocalDate.now(); LocalDateTime currentDateTime = LocalDateTime.now(); System.out.println("当前时间 (LocalTime): " + currentTime); System.out.println("当前日期 (LocalDate): " + currentDate); System.out.println("当前日期时间 (LocalDateTime): " + currentDateTime); // 解析日期和时间 // 日期解析是借助 DateTimeFormatter 类和日期时间类中的 parse() 方法完成的。 String dateString = "2026-02-04 12:30"; DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"); LocalDateTime parsedDateTime = LocalDateTime.parse(dateString, formatter); System.out.println("解析后的日期时间: " + parsedDateTime); // 格式化日期和时间 // 日期格式化是借助 DateTimeFormatter 类和日期时间类中的 format() 方法完成的。 LocalDateTime myDateObj = LocalDateTime.now(); DateTimeFormatter myFormatObj = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm"); String formattedDate = myDateObj.format(myFormatObj); System.out.println("格式化后的日期时间: " + formattedDate); // 测量经过时间 // 要获取不同时间单位的执行时间，可以使用 java.time.Instant 和 java.time.Duration 类中的 // toDays() 、 toHours() 、 toMillis() 、 toMinutes() 、 toNanos() 和 getSeconds() 等方法。 Instant start = Instant.now(); Thread.sleep(1000); // 休眠1s Instant finish = Instant.now(); long timeElapsed = Duration.between(start, finish).toMillis(); System.out.println("执行时间（毫秒）: " + timeElapsed); // 计算两个日期之间的天数 // 在 Java 8 中使用 ChronoUnit.DAYS.between() 和 LocalDate.until() 方法计算两个日期之间的天数 。 LocalDate date1 = LocalDate.now(); LocalDate date2 = date1.plusDays(99); long diffInDays = ChronoUnit.DAYS.between(date1, date2); System.out.println("两个日期之间的天数: " + diffInDays); } } ``` ================================================ FILE: src/md/java/datetime/compare-dates.md ================================================ --- title: 比较两个日期 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-06 category: Java Dates tags: - date-time --- # 比较两个日期 > 此文参考文献： > > - [【howtodoinjava】- 用 Java 比较两个日期](https://howtodoinjava.com/java/date-time/compare-dates/) > - [比较 LocalDate](https://howtodoinjava.com/java/date-time/compare-localdates/) > - [比较 LocalDateTime](https://howtodoinjava.com/java/date-time/compare-localdatetime/) > - [比较 ZonedDateTime](https://howtodoinjava.com/java/date-time/zoneddatetime-comparison/) | 方法 / API | 支持类 / 类型 | Java 版本 | 说明 | | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | ----------------- | | `isBefore / isAfter / isEqual` | [LocalDate](https://howtodoinjava.com/java/date-time/java-time-localdate-class/), [LocalTime](https://howtodoinjava.com/java/date-time/java-localdatetime-class/), [LocalDateTime](https://howtodoinjava.com/java/date-time/zoneddatetime-class/), `ZonedDateTime`, `OffsetDateTime`, `Instant` | Java 8+ | 判断先后或相等，语义清晰、线程安全 | | `compareTo` | `LocalDate`, `LocalTime`, `LocalDateTime`, `ZonedDateTime`, `OffsetDateTime`, `Instant`, `java.util.Date` | 通用 | 排序或比较大小 | | `before / after` | [java.util.Date](https://howtodoinjava.com/java/date-time/java-date-examples/), `java.util.Calendar` | Java 7 以前 | 判断早于或晚于 | | `equals` | `java.util.Date`, `java.util.Calendar` | 通用 | 判断相等 | | `getTime / getTimeInMillis` | `java.util.Date`, `java.util.Calendar` | Java 7 以前 | 获取毫秒时间戳，可直接比较大小 | **Date 日期比较** ```java import java.util.Calendar; import java.util.Date; public class CompareDatePartOnly { public static void main(String[] args) { Date date1 = new Date(); Date date2 = new Date(date1.getTime() + 24 * 60 * 60 * 1000); // 次日 int diff = compareDatePartOnly(date1, date2); if (diff > 0) { System.out.println(date1 + " 大于 " + date2); } else if (diff < 0) { System.out.println(date1 + " 小于 " + date2); } else { System.out.println(date1 + " 等于 " + date2); } } private static int compareDatePartOnly(final Date date1, final Date date2) { Calendar cal1 = Calendar.getInstance(); Calendar cal2 = Calendar.getInstance(); cal1.setTime(date1); cal2.setTime(date2); int result = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR); if (result == 0) { result = cal1.get(Calendar.DAY_OF_YEAR) - cal2.get(Calendar.DAY_OF_YEAR); } return result; } } ``` ================================================ FILE: src/md/java/datetime/convert-dates.md ================================================ --- title: 转换日期时间实例 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-09 category: Java Dates tags: - date-time --- # 转换日期时间实例 本文总结了 Java 中常见的日期时间类之间的转换方法，涵盖了 Java 8 引入的 `java.time` 包中的类（如 `LocalDate`, `LocalDateTime`, `ZonedDateTime`）以及旧版的 `java.util.Date` 和 `java.sql.Date` 等。 * [🐟代码小抄-Java日期转换工具类](https://codecopy.cn/post/q7kdjf) ## 1. LocalDateTime 与 ZonedDateTime 互转 `LocalDateTime` 表示不带时区的日期时间，而 `ZonedDateTime` 是带有时区的日期时间（`LocalDateTime` + `ZoneId`）。 ### LocalDateTime -> ZonedDateTime 要将 `LocalDateTime` 转换为 `ZonedDateTime`，必须添加时区信息（Zone Offset）。 ```java LocalDateTime ldt = LocalDateTime.now(); // 本地日期时间 // 添加时区信息 ZoneId zoneId = ZoneId.of("Asia/Shanghai"); ZonedDateTime zdtAtAsia = ldt.atZone(zoneId); // 转换到另一个时区（保持时间瞬间一致） ZonedDateTime zdtAtET = zdtAtAsia.withZoneSameInstant(ZoneId.of("America/New_York")); ``` ### ZonedDateTime -> LocalDateTime 直接使用 `toLocalDateTime()` 方法，这将丢弃时区信息。 ```java ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("America/New_York")); LocalDateTime ldt = zdt.toLocalDateTime(); ``` ## 2. LocalDate 与 ZonedDateTime 互转 `LocalDate` 仅包含日期信息，转换为 `ZonedDateTime` 需要补充时间和时区。 ### LocalDate -> ZonedDateTime **方法一：使用 `atStartOfDay`（默认时间为 00:00）** ```java LocalDate localDate = LocalDate.now(); // 默认当天开始时间 (00:00) + 指定时区 ZonedDateTime zdt = localDate.atStartOfDay(ZoneId.of("America/New_York")); ``` **方法二：先转 LocalDateTime 再转 ZonedDateTime** ```java LocalDate localDate = LocalDate.now(); // 指定具体时间 LocalDateTime localDateTime = localDate.atTime(14, 30, 0); // 添加时区 ZonedDateTime zdt = localDateTime.atZone(ZoneId.of("Asia/Shanghai")); ``` ### ZonedDateTime -> LocalDate 直接使用 `toLocalDate()`。 ```java ZonedDateTime zdt = ZonedDateTime.now(); LocalDate localDate = zdt.toLocalDate(); ``` ## 3. LocalDate 与 LocalDateTime 互转 `LocalDateTime` = `LocalDate` + `LocalTime`。 ### LocalDate -> LocalDateTime 需要补充时间部分。 ```java LocalDate date = LocalDate.now(); // 1. 当天开始时间 (00:00) LocalDateTime startOfDay = date.atStartOfDay(); // 2. 当前时间 LocalDateTime withCurrentTime = date.atTime(LocalTime.now()); // 3. 指定时间 LocalDateTime specificTime = date.atTime(14, 30, 0); ``` ### LocalDateTime -> LocalDate 直接使用 `toLocalDate()`。 ```java LocalDateTime dateTime = LocalDateTime.now(); LocalDate date = dateTime.toLocalDate(); ``` ## 4. LocalDate 与 java.sql.Date 互转 `java.sql.Date` 是旧版 JDBC API 使用的类，仅包含日期部分（时间设为 00:00:00）。 ### java.sql.Date -> LocalDate ```java java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis()); LocalDate localDate = sqlDate.toLocalDate(); ``` ### LocalDate -> java.sql.Date ```java LocalDate localDate = LocalDate.now(); java.sql.Date sqlDate = java.sql.Date.valueOf(localDate); ``` ## 5. LocalTime 与 java.sql.Time 互转 ### LocalTime -> java.sql.Time 注意：`java.sql.Time` 不包含纳秒精度。 ```java LocalTime localTime = LocalTime.now(); java.sql.Time sqlTime = java.sql.Time.valueOf(localTime); ``` ### java.sql.Time -> LocalTime ```java java.sql.Time sqlTime = new java.sql.Time(System.currentTimeMillis()); LocalTime localTime = sqlTime.toLocalTime(); ``` ## 6. LocalDate 与 java.util.Date 互转 `java.util.Date` 包含日期和时间，且基于 Epoch 毫秒数。转换时通常需要借助 `Instant` 和系统默认时区。 ### java.util.Date -> LocalDate ```java Date date = new Date(); LocalDate localDate = Instant.ofEpochMilli(date.getTime()) .atZone(ZoneId.systemDefault()) .toLocalDate(); ``` ### LocalDate -> java.util.Date 需要先转为当天开始时间的 `ZonedDateTime` 或 `Instant`。 ```java LocalDate localDate = LocalDate.now(); Date date = Date.from(localDate.atStartOfDay() .atZone(ZoneId.systemDefault()) .toInstant()); ``` ## 7. LocalDateTime 与 java.util.Date 互转 ### java.util.Date -> LocalDateTime ```java Date date = new Date(); LocalDateTime ldt = Instant.ofEpochMilli(date.getTime()) .atZone(ZoneId.systemDefault()) .toLocalDateTime(); ``` ### LocalDateTime -> java.util.Date ```java LocalDateTime ldt = LocalDateTime.now(); Date date = Date.from(ldt.atZone(ZoneId.systemDefault()).toInstant()); ``` ## 8. 时区转换与 EST/EDT 处理 ### ZonedDateTime 时区转换 使用 `withZoneSameInstant` 方法将同一时刻转换为另一时区的表达。 ```java ZonedDateTime now = ZonedDateTime.now(); // 当前时区 ZonedDateTime utc = now.withZoneSameInstant(ZoneId.of("UTC")); ZonedDateTime ny = now.withZoneSameInstant(ZoneId.of("America/New_York")); ``` ### OffsetDateTime 时区转换 类似地，使用 `withOffsetSameInstant`。 ```java OffsetDateTime now = OffsetDateTime.now(); OffsetDateTime utc = now.withOffsetSameInstant(ZoneOffset.UTC); ``` ### java.util.Date 时区格式化 java.util.Date 表示一个时间点（UTC），但在格式化时会根据默认时区进行展示。可以通过设置 `SimpleDateFormat` 的时区来控制输出。 - [如何设置java.util.Date的时间区域？ - Stack Overflow](https://stackoverflow.com/questions/2891361/how-to-set-time-zone-of-a-java-util-date/30403673#30403673). ```java SimpleDateFormat FORMATTER = new SimpleDateFormat("MM/dd/yyyy 'at' hh:mma z"); Date currentDate = new Date(); // 默认系统时区（东八区） System.out.println(FORMATTER.format(currentDate)); //02/12/2026 at 02:08上午 CST // 指定 UTC 时区 FORMATTER.setTimeZone(TimeZone.getTimeZone("UTC")); System.out.println(FORMATTER.format(currentDate)); //02/11/2026 at 06:08下午 UTC ``` ### EST, EDT 与 "America/New_York" * **EST**: Eastern Standard Time (UTC-5)，不包含夏令时。 * **EDT**: Eastern Daylight Time (UTC-4)，夏令时。 * **EST5EDT**: 自动切换 EST 和 EDT。 * **America/New_York**: 推荐使用，涵盖了 1966 年以后的所有规则，自动处理夏令时。 转换示例： ```java // 将 ZonedDateTime 转换为 ET 时区 ZonedDateTime ist = ZonedDateTime.now(ZoneId.of("Asia/Shanghai")); ZonedDateTime et = ist.withZoneSameInstant(ZoneId.of("America/New_York")); //推荐 ``` ## 9. Instant 与 LocalDateTime 互转 `Instant` 代表时间轴上的一个点（UTC）。 ### Instant -> LocalDateTime 需要指定时区偏移。 ```java Instant instant = Instant.now(); LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault()); LocalDate ld = LocalDate.ofInstant(instant, ZoneOffset.systemDefault()); LocalTime lt = LocalTime.ofInstant(instant, ZoneOffset.systemDefault()); // 或者 LocalDateTime ldt2 = instant.atZone(ZoneId.systemDefault()).toLocalDateTime(); LocalDate ld2 = instant.atZone(ZoneOffset.systemDefault()).toLocalDate(); LocalTime lt2 = instant.atZone(ZoneOffset.systemDefault()).toLocalTime(); ``` ### LocalDateTime -> Instant 需要指定时区偏移。 ```java LocalDateTime ldt = LocalDateTime.now(); Instant instant = ldt.atZone(ZoneId.systemDefault()).toInstant(); ``` ================================================ FILE: src/md/java/datetime/date-diff.md ================================================ --- title: 获取两个日期之间的时间差 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-05 category: Java Dates tags: - date-time --- # 获取两个日期之间的时间差 ## 1. Java 8 推荐 传统的 Java 类一直缺乏足够的支持来有效地表达日期和时间段。Java 8 首次尝试升级此日期/时间 API。 ### 1.1 ChronoUnit **用于计算所有时间单位之间的差值** - 获取两个日期或时间之间的绝对差值（按**单位**），适用所有`Temporal`类型（如 `LocalDate`,`LocalDateTime`,`ZonedDateTime` 等）。 ```java // 日期级单位（仅依赖日期） long years = ChronoUnit.YEARS.between(startDate, endDate); long months = ChronoUnit.MONTHS.between(startDate, endDate); long days = ChronoUnit.DAYS.between(startDate, endDate); // 时间级单位（需包含时间部分，如 LocalDateTime） long hours = ChronoUnit.HOURS.between(startDateTime, endDateTime); long minutes = ChronoUnit.MINUTES.between(startDateTime, endDateTime); long seconds = ChronoUnit.SECONDS.between(startDateTime, endDateTime); long millis = ChronoUnit.MILLIS.between(startDateTime, endDateTime); long micros = ChronoUnit.MICROS.between(startDateTime, endDateTime); long nanos = ChronoUnit.NANOS.between(startDateTime, endDateTime); ``` ### 1.2 Period-日期段 **用于计算天数、月数和年数的差值** ```java // 包含开始日期，不包含结束日期 Period diff = Period.between(startDate, endDate); int years = diff.getYears(); // 完整年数 int months = diff.getMonths(); // 剩余月数 int days = diff.getDays(); // 剩余天数 // ⚠️ 仅为近似值，不推荐用于精确计算 int totalDays = years * 365 + months * 30 + days; ``` ⚠️ 注意事项 - `Period` 以 “x 年 y 月 z 日” 的形式表示时间差 - `getDays()` 返回的是剩余天数，并非两个日期之间的总天数 - 结果可能为负值（当结束日期早于开始日期） ### 1.3 Duration-时间段 **计算基于时间线的精确时间差** **Duration**表示以小时、分钟、秒、纳秒等较小时间单位表示的时间差。 ```java Duration duration = Duration.between(dateTime, dateTime2); long hours = duration.toHours(); // 总小时数 long minutes = duration.toMinutes(); // 总分钟数 long seconds = duration.getSeconds(); // 总秒数 long millis = duration.toMillis(); // 总毫秒数 long micros = duration.toNanos() / 1_000; // 总微秒数 int nanos = duration.getNano(); // 剩余纳秒（非总纳秒） ``` ⚠️ 仅对包含时间部分的日期时间对象有效（如 `LocalDateTime`、`Instant`）。 ## 2. Joda‑Time 库 对于Java8之前的旧项目，还可以用 [Joda‑Time](https://www.joda.org/joda-time/)。  由于我们都更喜欢可读性，我建议使用 Jodatime 库（它实际上启发了 Java 8 日期/时间 API）。 1. 导入依赖`joda-time`依赖 2. 演示代码 ```java DateTime dateOfBirth = new DateTime(1988, 7, 4, 0, 0, GregorianChronology.getInstance()); DateTime currentDate = new DateTime(); // 当前时间 Days diffInDays = Days.daysBetween(dateOfBirth, currentDate); // 计算天数差 Hours diffInHours = Hours.hoursBetween(dateOfBirth, currentDate); // 计算小时差 Minutes diffInMinutes = Minutes.minutesBetween(dateOfBirth, currentDate); // 计算分钟差 Seconds diffInSeconds = Seconds.secondsBetween(dateOfBirth, currentDate); // 计算秒数差 ``` ## 3. Legacy API 方法（不推荐） 为了便于参考，我们来看一个使用 `java.util.Date` 和 `TimeUnit` 类查找日期差的示例。 ```java import java.util.Date; import java.util.concurrent.TimeUnit; public class DateDifference { public static void main(final String[] args) { // 第一个日期：今天 Date today = new Date(); // 第二个日期：下个月同一天 Date sameDayNextMonth = new Date(); sameDayNextMonth.setMonth(today.getMonth() + 1); // 注意：月份从0开始 // 计算两个日期的时间差 long days = getDateDiff(today, sameDayNextMonth, TimeUnit.DAYS); long hours = getDateDiff(today, sameDayNextMonth, TimeUnit.HOURS); long minutes = getDateDiff(today, sameDayNextMonth, TimeUnit.MINUTES); long seconds = getDateDiff(today, sameDayNextMonth, TimeUnit.SECONDS); long mills = getDateDiff(today, sameDayNextMonth, TimeUnit.MILLISECONDS); } /** * 计算两个日期之间的差值，并以指定的时间单位返回 * * @param date1 起始日期 * @param date2 结束日期 * @param timeUnit 返回的时间单位（天、小时、分钟等） * @return 两个日期之间的差值 */ public static long getDateDiff(final Date date1, final Date date2, final TimeUnit timeUnit) { long diffInMillies = date2.getTime() - date1.getTime(); // 毫秒差 // 将毫秒差转换成指定时间单位 return timeUnit.convert(diffInMillies, TimeUnit.MILLISECONDS); } } ``` ================================================ FILE: src/md/java/datetime/datetime.md ================================================ --- title: 获取当前日期和时间 shortTitle: description: Java 提供了许多有用的方法来获取当前日期或当前时间，可以使用 `Date`、`Calendar` 以及 Java 8 Date/Time API 类中新引入的 `LocalDate`、`LocalDateTime` 和 `ZonedDateTime` 类。 icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-04 category: Java Dates tags: - date-time --- # 获取当前日期和时间 介绍在 Java 中获取当前 **日期 / 时间 / 日期时间** 的不同方式，分 Java 8 及更高版本和旧版本来讲解。 - 对于 JDK 8 或更高版本，推荐使用 [LocalDate](https://www.runoob.com/java/java-localdate-class.html) 和 [LocalTime](https://www.runoob.com/java/java-localtime-class.html) 类。 - 对于 JDK 7 或更早版本，我们只能使用 [Date](https://www.runoob.com/java/java-date-class.html) 和 [Calendar](https://www.runoob.com/java/java-calendar-class.html) 类。 ## 1. Java 8 及以后（推荐方式） ### 1.1 核心 API（java.time 包） - [java.time.LocalDate](https://howtodoinjava.com/java/date-time/java-time-localdate-class/) – **仅**表示 _yyyy-MM-dd_ 格式的日期信息。 - [java.time.LocalTime](https://howtodoinjava.com/java/date-time/java-localtime/) – 表示 _HH:mm:ss.SSSSSSSS_ 格式的时间信息 。 - [java.time.LocalDateTime](https://howtodoinjava.com/java/date-time/java-localdatetime-class/) – 表示**日期和时间信息，不包含任何时区信息** 。其模式是本地日期和时间信息的组合。 要获取**其他时区/语言环境下的当前日期和时间信息** ，我们可以使用以下类。 - [java.time.ZonedDateTime](https://howtodoinjava.com/java/date-time/zoneddatetime-class/) – 表示**给定时区的日期和时间信息** 。 ### 1.2 示例代码 ```java LocalDate today = LocalDate.now(); //2026-02-04 LocalTime currentTime = LocalTime.now(); //13:05:55.540946 LocalDateTime now = LocalDateTime.now(); //2026-02-04T13:05:55.540982 ``` 若需要带时区： ```java ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("GMT")); //2026-02-04T05:06:28.188180Z[GMT] ``` 默认的 `now()` 返回当前系统时区的日期/时间。 ### 1.3 自定义格式化输出 如果希望控制显示格式（比如 `dd‑MM‑yyyy hh:mm`），可以用 **DateTimeFormatter**： ```java DateTimeFormatter fmt = DateTimeFormatter.ofPattern("dd-MM-yyyy hh:mm"); String formatted = fmt.format(LocalDateTime.now()); // 04-02-2026 01:06 ``` 这样可以输出自定义样式的字符串。 ## 2. 旧版 Java（JDK 7 及更早） 在 Java 8 之前，没有 `java.time` 包，需要用旧类： - **java.util.Date** - **java.util.Calendar** ### 2.1 代码示例 ```java Date date = new Date(); //Wed Feb 04 13:07:38 CST 2026 Calendar cal = Calendar.getInstance(); //Wed Feb 04 13:08:13 CST 2026 ``` ### 2.2 自定义格式化输出 并通过 **SimpleDateFormat** 做格式化输出。 ```java SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy hh:mm"); System.out.println(sdf.format(date)); //04-02-2026 01:10 System.out.println(sdf.format(cal.getTime())); //04-02-2026 01:10 ``` ⚠️ 这种方式的类设计较旧且非线程安全，因此不推荐在新代码中使用。 ================================================ FILE: src/md/java/datetime/locale.md ================================================ --- title: 获取用户的区域设置、国际化 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-04 category: Java Dates tags: - date-time - 国际化 --- # 获取用户的区域设置、国际化 > 此文参考文献： > > * [【howtodoinjava】- 在 Java 中获取当前区域设置](https://howtodoinjava.com/java/date-time/how-to-get-current-user-locale-in-java/) > * [【howtodoinjava】- Java 本地化：一份全面的指南](https://howtodoinjava.com/java/date-time/java-locale-api-examples/) ## 1. Locale 简介 `java.util.Locale` 是 Java 国际化 (i18n) 的核心类，用于标识特定的**语言**和**地区**。它是所有**区域设置敏感**类（如 `DateFormat`, `NumberFormat`, `MessageFormat`）的基础配置对象。 ### 1.1 核心组成 `Locale` 对象在逻辑上由语言、国家、脚本、变体和扩展等字段组成（遵循 [IETF BCP 47](https://www.rfc-editor.org/info/bcp47) 标准） | 组成部分 | 描述 | 示例 | | :------------------ | :---------------------- | :------------------------------------------------ | | **语言** (Language) | ISO 639-1 两字母代码 | `en` (英语), `zh` (中文) | | **国家/地区** (Country) | ISO 3166-1 两字母代码 | `US` (美国), `CN` (中国) | | 脚本（Script） | ISO 15924 四字母代码 | `"Latn"` (拉丁字母), `"Hans"` (简体中文), `"Hant"` (繁体中文) | | 变体 (Variant) | 特定方言或版本 (可选) | `Traditional_WIN`, `POSIX` | | 扩展（Extensions） | 额外信息，遵循 BCP 47 扩展语法（可选） | `u-ca-gregory`（使用公历）, `x-lvariant-POSIX`（私有扩展） | ### 1.2 获取用户区域设置  **Web 应用**：通常根据 HTTP 请求头 `Accept-Language` 获取用户偏好： ```java Locale locale = request.getLocale(); System.out.println(locale.getDisplayName()); // 例如: 中文 (中国) ``` **桌面/服务端应用**：默认使用 JVM 或操作系统的设置： ```java // 获取默认 Locale Locale defaultLocale = Locale.getDefault(); // 或者通过系统属性 String lang = System.getProperty("user.language"); String region = System.getProperty("user.country"); ``` ## 2. 创建 Locale 实例 ### 2.1 推荐方式 (Java 19+) 从 Java 19 开始，推荐使用静态工厂方法 `Locale.of()`： ```java Locale us = Locale.of("en", "US"); Locale zh = Locale.of("zh", "CN"); ``` > **注意**：`new Locale("en", "US")` 构造函数在 Java 19 中已被弃用，建议改用 `Locale.of()`。 ### 2.2 内置常量 对于主要国家和语言，直接使用内置常量： ```java Locale us = Locale.US; Locale china = Locale.CHINA; Locale simplifiedChinese = Locale.SIMPLIFIED_CHINESE; ``` ### 2.3 构建器与标签解析 针对复杂场景或标准标签： ```java // 1. 使用 Builder (更灵活，自带校验) Locale locale = new Locale.Builder() .setLanguage("en") .setRegion("US") .build(); // 2. 解析 BCP 47 语言标签 Locale usLocale = Locale.forLanguageTag("en-US"); Locale fromTag = Locale.forLanguageTag("zh-cmn-Hans-CN"); ``` ## 3. 设置默认 Locale 虽然通常**不建议**修改全局默认值，但在某些特定场景下需要强制指定： ```java // 全局设置 Locale.setDefault(Locale.US); // 分类设置 (Java 7+)：独立控制显示与格式化 Locale.setDefault(Locale.Category.DISPLAY, Locale.US); // 影响 UI 界面/日志语言 Locale.setDefault(Locale.Category.FORMAT, Locale.FRANCE); // 影响 日期/货币格式 ``` ## 4. 常见应用场景 ### 4.1 格式化 (日期/数字/货币) `Locale` 决定了数据的展示格式： ```java Locale us = Locale.US; double num = 123456.789; // 1. 数字格式化 System.out.println(NumberFormat.getInstance(us).format(num)); // 输出: 123,456.789 // 2. 货币格式化 System.out.println(NumberFormat.getCurrencyInstance(us).format(num)); // 输出: $123,456.79 // 3. 日期格式化 System.out.println(DateFormat.getDateInstance(DateFormat.LONG, us).format(new Date())); // 输出示例: February 5, 2026 ``` ### 4.2 国际化消息 (ResourceBundle) 根据 `Locale` 加载对应的资源文件（如 `msg_en.properties`, `msg_zh.properties`）： ```java Locale zhCN = Locale.SIMPLIFIED_CHINESE; //简化中文 Locale enUS = Locale.US; //美式英语 // 加载 resources/i18n 包下的 // messages_zh_CN.properties 和 messages_en_US.properties ResourceBundle bundleZh = ResourceBundle.getBundle("i18n.messages", zhCN); ResourceBundle bundleEn = ResourceBundle.getBundle("i18n.messages", enUS); System.out.println("中文消息: " + bundleZh.getString("greeting")); System.out.println("英文消息: " + bundleEn.getString("greeting")); ``` --- **参考资料：** * [Java国际化实践实现多语言及日期货币本地化-开发者社区-阿里云](https://developer.aliyun.com/article/1556409) * [Java学习路线-21：国际化Locale、ResourceBundle、MessageFormat-阿里云开发者社区](https://developer.aliyun.com/article/1008126) **资源：** * [ISO 国家代码](https://www.iso.org/obp/ui/#search) * [ISO 语言代码](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) ================================================ FILE: src/md/java/datetime/timestamp.md ================================================ --- title: 获取当前时间戳 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-04 category: Java Dates tags: - date-time --- # 获取当前时间戳 > 在Java中，**时间戳**（Timestamp）用来表示一个特定的**时间点**（`Instant`），本质上是一个与时区无关的时间线坐标。 > 它通常表示自 **1970-01-01 00:00:00 UTC**（Unix 纪元） 起经过的时间长度。精度到**纳秒**。 ## 1. 获取当前时间戳 在Java中，时间戳用以下类表示： - [java.time.Instant](https://www.runoob.com/java/java-instant-class.html) - `java.sql.Timestamp`（Java 7 及以前） ### 1.1 Instant `Instant`表示从 **系统 UTC 时钟** 获取的 **当前时间点**。 ```java Instant instant = Instant.now(); //2026-02-04T14:19:17.793293Z ``` ⚠️ 思考 [Java 17 中 Instant.now 的精度改变了吗？](https://www.reddit.com/r/java/comments/1ffwkc7/has_the_precision_of_instantnow_changed_in_java_17/?tl=zh-hans) ### 1.2 Timestamp `Timestamp`是`java.util.Date`的子类，表示一个具体的时间点，精确到**毫秒**。 ```java // 基于系统毫秒时间戳 Timestamp timestamp1 = new Timestamp(System.currentTimeMillis()); //2026-02-04 22:47:47.582 // 通过 Date 转换 Date date = new Date(); Timestamp timestamp2 = new Timestamp(date.getTime()); //2026-02-04 22:47:47.586 ``` 如果你需要兼容旧 API（比如 JDBC），可以用 `java.sql.Timestamp`： ## 2. Instant vs ZonedDateTime 从表面上看， _Instant 类_ 和 [ZonedDateTime](https://howtodoinjava.com/java/date-time/zoneddatetime-class/) 类似乎很相似，但实际上并非如此。 - `Instant` 是 UTC时间的一个时间点。 - `ZonedDateTime` 是一个**特定时区**的实际时间点。  [【howtodoinjava】- 了解 java.time.ZonedDateTime](https://howtodoinjava.com/java/date-time/zoneddatetime-class/) ================================================ FILE: src/md/java/datetime/zoneddatetime-vs-offsetdatetime.md ================================================ --- title: ZonedDateTime 和 OffsetDateTime 的区别 shortTitle: description: 详解 Java 8 日期时间 API 中 ZonedDateTime 和 OffsetDateTime 的核心区别、使用场景及代码示例。 icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2026-02-07 category: Java Dates tags: - date-time --- # ZonedDateTime 和 OffsetDateTime 的区别 > 此文参考文献：1 > > * [【howtodoinjava】- ZonedDateTime 和 OffsetDateTime 的区别](https://howtodoinjava.com/java/date-time/zoneddatetime-vs-offsetdatetime/) > * [【Baeldung】- ZonedDateTime 和 OffsetDateTime 的区别](https://www.baeldung.com/java-zoneddatetime-offsetdatetime) 先了解两个所依赖的两个核心概念： - [ZoneOffset](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneOffset.html)：**UTC 偏移量**（如 `+08:00`） - [ZoneId](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html)：**时区标识符**（如 `Asia/Shanghai`），包含该区域的所有时间规则（**夏令时**切换等）。 ## 1. 核心定义 | 特性 | OffsetDateTime | ZonedDateTime | |:--------------|:-------------------------------|:--------------------------------------------| | **组成** | `LocalDateTime` + `ZoneOffset` | `LocalDateTime` + `ZoneId` (+ `ZoneOffset`) | | **时区感知** | 仅知道偏移量（Offset），不知道地理时区 | 知道具体的地理时区（Zone ID） | | **夏令时 (DST)** | **不处理**。偏移量是固定的。 | **自动处理**。根据规则调整偏移量。 | | **使用场景** | 数据库存储、网络通信、日志记录 | 用户界面显示、复杂的日期计算（如日历应用） | | **复杂度** | 较低 | 较高 | ### 1.1 OffsetDateTime `OffsetDateTime` 表示一个**不可变的日期时间**，精确到纳秒，并携带相对于 UTC 的**固定偏移量**（ISO-8601）。 - 每个实例都对应**时间线上的唯一时刻** - 非常适合**与时区无关的时间戳**场景（数据库存储，网络传输 / XML / API 时间戳） ```java // 本质上：OffsetDateTime = LocalDateTime + ZoneOffset OffsetDateTime now = OffsetDateTime.now(ZoneOffset.of("UTC")); ``` ### 1.2 ZonedDateTime `ZonedDateTime` 也是带时区的日期时间表示，但它基于**完整的时区规则**。 - 使用 **ZoneId** - **会自动处理夏令时（DST）** - 同一地区在不同时间点，**偏移量可能不同** ```java // 本质上：ZonedDateTime = LocalDateTime + ZoneId ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/Los_Angeles")); ``` 内置方法，用于将给定日期从一个时区转换为另一个时区： ```java ```java ZonedDateTime destZonedDateTime = sourceZonedDateTime.withZoneSameInstant(destZoneId); ``` ## 2. 代码示例 ### 2.1 创建实例 ```java // 获取当前时间 OffsetDateTime odt = OffsetDateTime.now(); ZonedDateTime zdt = ZonedDateTime.now(); System.out.println("OffsetDateTime: "+odt); // 输出示例: 2026-02-07T23:30:00.132+08:00 System.out.println("ZonedDateTime: "+zdt); // 输出示例: 2026-02-07T23:32:53.132632+08:00[Asia/Shanghai] ``` ⚠️注意 `ZonedDateTime` 的输出末尾包含 `[Asia/Shanghai]` 这样的时区 ID。 ### 2.2 相互转换 可以轻松地在两者之间进行转换： ```java // ZonedDateTime -> OffsetDateTime OffsetDateTime odtFromZdt = zdt.toOffsetDateTime(); // OffsetDateTime -> ZonedDateTime (需要提供 ZoneId) ZonedDateTime zdtFromOdt = odt.atZoneSameInstant(ZoneId.of("America/New_York")); ``` ### 2.3 夏令时处理差异 假设我们要给当前时间加上 6 个月。如果跨越了夏令时切换点： - `OffsetDateTime` 会简单地增加时间，**保持偏移量不变**。 - `ZonedDateTime` 会增加时间，并**检查新日期的时区规则**，如果该日期处于夏令时（或退出了夏令时），它会自动调整偏移量。 ```java // 使用纽约时区，2026 年美国夏令时切换是在 3月8日（第二个周日） ZoneId zoneId = ZoneId.of("America/New_York"); // LocalDateTime（本地时间不包含时区信息） LocalDateTime localDateTime = LocalDateTime.of(2026, 3, 7, 10, 0); System.out.println("LocalDateTime (未关联时区): " + localDateTime); // ZonedDateTime（会关联时区并自动考虑夏令时规则） ZonedDateTime zdt = ZonedDateTime.of(localDateTime, zoneId); System.out.println("ZonedDateTime (关联时区): " + zdt); ZonedDateTime zdtNextDay = zdt.plusDays(1); System.out.println("ZonedDateTime (DST感知 +1天): " + zdtNextDay); // OffsetDateTime（固定偏移量，不受夏令时影响） OffsetDateTime odt = OffsetDateTime.of(localDateTime, ZoneOffset.of("-05:00")); System.out.println("OffsetDateTime (固定偏移): " + odt); OffsetDateTime odtNextDay = odt.plusDays(1); System.out.println("OffsetDateTime (固定偏移 +1天): " + odtNextDay); ``` ================================================ FILE: src/md/java/features/Java10/jep286-local-variable-type-inference.md ================================================ --- title: Java 10 新特性：局部变量类型推断 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true date: 2023-12-23 sticky: false star: false category: Java Features tag: - java order: 286 --- # Java 10 新特性：局部变量类型推断 Java 10 引入了一项新的语言特性，即**局部变量类型推断**（Local-Variable Type Inference）， 它允许在局部变量声明时，根据变量的初始值，推断出变量的数据类型。 ## 语法 局部变量类型推断的语法非常简单，只需要将 `var` 关键字作为局部变量的类型即可。 ```java var list = new ArrayList
Hello, world
\n" + " \n" + "\n"; // 使用“二维”文本块 String html = """Hello, world
"""; ``` **SQL示例** ```sql // 使用“一维”字符串文字 String query = "SELECT \"EMP_ID\", \"LAST_NAME\" FROM \"EMPLOYEE_TB\"\n" + "WHERE \"CITY\" = 'INDIANAPOLIS'\n" + "ORDER BY \"EMP_ID\", \"LAST_NAME\";\n"; // 使用“二维”文本块 String query = """ SELECT "EMP_ID", "LAST_NAME" FROM "EMPLOYEE_TB" WHERE "CITY" = 'INDIANAPOLIS' ORDER BY "EMP_ID", "LAST_NAME"; """; ``` **Polyglot语言示例** ```polyglot // 使用“一维”字符串文字 ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval("function hello() {\n" + " print('\"Hello, world\"');\n" + "}\n" + "\n" + "hello();\n"); // 使用“二维”文本块 ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval("function hello() {\n" + " print('\"Hello, world\"');\n" + "}\n" + "\n" + "hello();\n"); ``` ## 编译时处理 文本块是String类型的常量表达式，类似于字符串字面量。然而，与字符串字面值不同，文本块的内容在编译时经历三个步骤的处理：==行终止符的规范化==、==附带白色空间的移除==和==解释转义序列==： 1. 转换内容的行终止符 * 行终止符从CR（\u000D）和CRLF（\u000D\u000A）规范化为`LF（\u000A）` 2. 删除内容周围附带的白色空间（用于匹配Java源代码的缩进） 3. 解释内容中的转义序列，执行解释作为最后一步开发人员可以编写转义序列，如\n，而不会被前面的步骤修改或删除 处理后的内容以`CONSTANT_String_info`形式记录在**类文件的常量池**中，运行时，文本块被计算为String的实例。 ## 新增转义序列 为了更精细地控制==换行符==和==空格==的处理，引入了两个新的转义序列：\{@code
* 源代码行1
* ...
* 源代码行n
* }
```
## 引入@snippet标签
解决了`@code`标签的不足，允许在API文档中直接嵌入代码片段，以便更好地展示API的使用方法。
```java
/**
* 以下代码显示了如何使用 {@code Optional.isPresent}:
* {@snippet :
* if (v.isPresent()) {
* System.out.println("v: " + v.get());
* }
* }
*/
```
作为外部片段导入
```java
/**
* 以下代码显示了如何使用 {@code Optional.isPresent}:
* {@snippet file="ShowOptional.java" region="example"}
*/
```
其中`ShowOptional.java`是一个包含以下内容的文件：
```java
public class ShowOptional {
void show(Optional\{text}
"""; | 输出结果： | """ | | |Hello, world
| | | """ // 多行模板表达式示例：JSON文档 String name = "Joan Smith"; String phone = "555-123-4567"; String address = "1 Maple Drive, Anytown"; String json = STR.""" { "name": "\{name}", "phone": "\{phone}", "address": "\{address}" } """; | 输出结果： | """ | { | "name": "Joan Smith", | "phone": "555-123-4567", | "address": "1 Maple Drive, Anytown" | } | """ record Rectangle(String name, double width, double height) { double area() { return width * height; } } Rectangle[] zone = new Rectangle[] { new Rectangle("Alfa", 17.8, 31.4), new Rectangle("Bravo", 9.6, 12.4), new Rectangle("Charlie", 7.1, 11.23), }; // 多行模板表达式示例：表格 String table = STR.""" Description Width Height Area \{zone[0].name} \{zone[0].width} \{zone[0].height} \{zone[0].area()} \{zone[1].name} \{zone[1].width} \{zone[1].height} \{zone[1].area()} \{zone[2].name} \{zone[2].width} \{zone[2].height} \{zone[2].area()} Total \{zone[0].area() + zone[1].area() + zone[2].area()} """; | 输出结果： | """ | Description Width Height Area | Alfa 17.8 31.4 558.92 | Bravo 9.6 12.4 119.03999999999999 | Charlie 7.1 11.23 79.733 | Total 757.693 | """ ``` ## FMT模板处理器 除了STR模版处理器之外，Java中还提供了另外一个模版处理器：FMT。 FMT与STR相似之处在于它执行插值，但还提供了==格式化处理==能力。 * 格式说明符与`java.util.Formatter`中定义的格式说明符相同 ```java record Rectangle(String name, double width, double height) { double area() { return width * height; } } Rectangle[] zone = new Rectangle[] { new Rectangle("Alfa", 17.8, 31.4), new Rectangle("Bravo", 9.6, 12.4), new Rectangle("Charlie", 7.1, 11.23), }; // 多行模板表达式示例：表格 String table = FMT.""" Description Width Height Area %-12s\{zone[0].name} %7.2f\{zone[0].width} %7.2f\{zone[0].height} %7.2f\{zone[0].area()} %-12s\{zone[1].name} %7.2f\{zone[1].width} %7.2f\{zone[1].height} %7.2f\{zone[1].area()} %-12s\{zone[2].name} %7.2f\{zone[2].width} %7.2f\{zone[2].height} %7.2f\{zone[2].area()} \{" ".repeat(28)} Total %7.2f\{zone[0].area() + zone[1].area() + zone[2].area()} """; | 输出结果： | """ | Description Width Height Area | Alfa 17.80 31.40 558.92 | Bravo 9.60 12.40 119.04 | Charlie 7.10 11.23 79.73 | Total 757.69 | """ ``` ================================================ FILE: src/md/java/features/Java21/jep431-sequenced-collections.md ================================================ --- title: Java 21 新特性：有序集合 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2024-01-07 category: Java Features tag: - java order: 431 --- # Java 21 新特性：有序集合（Sequenced Collections） 在JDK 21中，**有序集合**（Sequenced Collections）引入了新的接口和方法来简化集合处理。 > 此增强功能旨在解决访问Java中各种集合类型的第一个和最后一个元素需要非统一且麻烦处理场景 `Sequenced Collections` 引入如下 3 个新接口，用于处理顺序`List`、`Set`和`Map`， 并将它们整合到现有的集合类型中。这些新接口中的方法都具有默认实现。 1. SequencedCollection 2. SequencedSet 3. SequencedMap ## SequencedCollection 提供了在集合两端添加、检索和移除元素的方法，沿着`reversed()`方法提供了该集合的逆序视图。 ```java interface SequencedCollection资源有限 (例如单核)
暂停时间短 | | Parallel | 多核系统上的峰值性能
非常适合高计算负载
暂停时间 > 1秒是可以接受的 | | G1
CMS | 响应时间 > 吞吐量
堆内存较大
暂停时间 < 1秒 | | Shenandoah | 尽量减少暂停时间
可预测的延迟 | | ZGC | 响应时间是高优先级的，和/或
非常大的堆内存 | | Epsilon GC | 性能测试和故障排除 | 每种方法都有自己的优点和缺点，这在很大程度上取决于应用程序的需求和可用资源。 ## 分代ZGC Java 11引入的实验性功能**ZGC**是一种**非分代**的垃圾收集方法。 尽管如此，它在**GC暂停**时间方面仍然带来了显著改进，至少在资源足够的情况下，可以比并发线程消耗内存更快地回收内存。 缺点是，它将所有对象存储在一起，而不考虑年龄，因此每个周期都会收集所有对象。 [generational hypothesis](https://www.memorymanagement.org/glossary/g.html#generational.hypothesis) 观察到==年轻对象==比==年长对象==更有可能“**早逝**”，于是产生了分代假设。 Java 21 中，**分代 ZGC** 将堆分为两个逻辑代：一个用于最近分配的对象，另一个用于长期存活对象。 GC 可以专注于更频繁地收集**年轻**(最近分配)且更有**前途**(可能长期存在)的对象，而不会增加GC暂停时间，将其保持在 1 毫秒以下。 **分代ZGC**与非分代ZGC相比的关键优势： * 减少分配停滞的风险 * 降低堆内存开销要求 * 减少垃圾回收CPU开销 此外，目标是在保留非分代方法已有优势的基础上实现这些优势： * 暂停时间保持在在 1 毫秒以下 * 支持多达数万TB的堆大小 * 最少的手动配置 为了保持最后一点，新的GC不需要手动配置代的大小、GC使用的线程数，或对象在年轻代中停留的时间。 ## 如何使用 JVM GC 在Java 21中，分代ZGC是默认的垃圾收集器。为了顺利过渡，分代ZGC将与非分代ZGC一起提供，您可以通过以下方式进行配置： ```shell # 启用ZGC(默认为非分代) $ java -XX:+UseZGC # 使用分代ZGC $ java -XX:+UseZGC -XX:+ZGenerational ``` 如果您需要关闭分代ZGC，可以通过将加号（+）替换为减号（-）来实现： ```shell # 不使用分代ZGC $ java -XX:+UseZGC -XX:-ZGenerational ``` 计划在更晚的版本中完全删除非分代ZGC。 ================================================ FILE: src/md/java/features/Java21/jep440-record-partterns.md ================================================ --- title: Java 21 新特性：记录模式 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2024-01-09 category: Java Features tag: - java order: 440 --- # Java 21 新特性：记录模式（Record Patterns） Java 21 中的**记录模式**（Record Patterns）是对模式匹配的扩展，它允许在模式匹配中使用**记录**（Records）类型。 同时，记录模式还支持嵌套，可以实现更复杂的数据查询和处理。 ## 仅仅是类型匹配 到目前为止，Java中的模式匹配主要局限于匹配类型：[instanceof类型匹配](/java-features/Java16/jep394-pattern-matching-for-instanceof) ```java // Java 16 之前 if (obj instanceof String) { String str = (String) obj; System.out.println(str); } // JAVA 16+ if (obj instanceof String str) { System.out.println(str); } ``` Java 21扩展了这个概念，使其可用于switch语句和表达式: [switch的模式匹配](/java-features/Java21/jep441-pattern-matching-for-switch) ```java // JAVA 21之前 static String asStringValue(Object anyValue) { String result = null; if (anyValue instanceof String str) { result = str; } else if (anyValue instanceof BigDecimal bd) { result = bd.toEngineeringString(); } else if (anyValue instance Integer i) { result = Integer.toString(i); } else { result = "n/a"; } return result; } // JAVA 21+ static String asStringValue(Object anyValue) { return switch (anyValue) { case String str -> str; case BigDecimal bd -> bd.toEngineeringString(); case Integer i -> Integer.toString(i); default -> "n/a"; }; } ``` 代码比之前更加简洁，同时也更加易读。但是，这种模式匹配仍然局限于类型匹配。 ## record模式 当我们将模式匹配与记录类型结合使用时，我们称之为**记录模式**。这意味着我们可以在模式匹配中使用记录类型，以及记录类型的属性。 ```java record Point(int x, int y) {} // Java 16 之前 static void printSum(Object obj) { if (obj instanceof Point p) { int x = p.x(); int y = p.y(); System.out.println(x+y); } } // JAVA 21+ static void printSum(Object obj) { if (obj instanceof Point(int x, int y)) { System.out.println(x+y); } } ``` 其中`Point(int x, int y)`就是记录模式，它匹配`Point`类型的对象，将记录的实例（obj）分解到它的组件（`x`和`y`）。 ## 嵌套record的解构 假设我们设计了一个记录，表示一个矩形，其中包含左上角和右下角的颜色点。 如果我们想要获取左上角点的颜色，我们可以这样写： ```java record Point(int x, int y) {} enum Color { RED, GREEN, BLUE } record ColoredPoint(Point p, Color c) {} record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {} Rectangle r = new Rectangle(new ColoredPoint(new Point(x1, y1), c1), new ColoredPoint(new Point(x2, y2), c2)); // Java 16 之前 static void printUpperLeftColoredPoint(Rectangle r) { if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) { System.out.println(ul.c()); } } // JAVA 21+ static void printUpperLeftColoredPoint(Rectangle r) { if (r instanceof Rectangle(ColoredPoint(Point ul, Color c), ColoredPoint lr)) { System.out.println(c); } } ``` 嵌套模式允许我们使用与将其组合的代码一样清晰简洁的代码来拆解聚合。 ## 发展脉络 该功能最初作为预览功能在Java 19（JEP 405）中首次亮相，随后经过Java 20（JEP 432）的迭代，最终在Java 21中定稿（JEP 440）。 此功能与模式匹配的switch语句（JEP 441）共同演进，并且它们之间存在相当大的互动。 ================================================ FILE: src/md/java/features/Java21/jep441-pattern-matching-for-switch.md ================================================ --- title: Java 21 新特性：switch模式匹配 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2024-01-10 category: Java Features tag: - java order: 441 --- # Java 21 新特性：switch模式匹配 Java 21 引入了 switch 模式匹配功能，它增强了 switch 语句的功能，允许使用更简洁的语法来执行类型检查和数据提取。 该功能与[记录模式（JEP 440）](/java-features/Java21/jep440-record-partterns)共同发展，并与之有相当大的互动。 ## switch + instanceof 与if条件中的`instanceof`一样，`switch case`现在可以对其值进行类型检查，并创建一个case作用域变量: ```java static String asStringValue(Object anyValue) { return switch (anyValue) { case String str -> str; case JSONObject json -> json.toCompactString(); case BigDecimal bd -> bd.toEngineeringString(); case Integer i -> Integer.toString(i); case LocalDate ld -> ld.format(DateTimeFormatter.ISO_LOCAL_DATE); default -> "n/a"; }; } ``` ## switch + null ```java static String asStringValue(Object anyValue) { return switch (anyValue) { case null -> "n/a"; case String str -> str; ... }; } ``` ## switch + enum ```java sealed interface CardClassification permits Suit, Tarot {} public enum Suit implements CardClassification { CLUBS, DIAMONDS, HEARTS, SPADES } final class Tarot implements CardClassification {} static void exhaustiveSwitchWithBetterEnumSupport(CardClassification c) { switch (c) { case CLUBS -> System.out.println("梅花"); case DIAMONDS -> System.out.println("方块"); case HEARTS -> System.out.println("红桃"); case SPADES -> System.out.println("黑桃"); case Tarot t -> System.out.println("塔罗牌"); default -> System.out.println("未知的卡片类型"); } } ``` ================================================ FILE: src/md/java/features/Java21/jep444-virtual-threads.md ================================================ --- title: Java 21 新特性：虚拟线程 shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2024-01-11 category: Java Features tag: - java order: 444 --- # Java 21 新特性：虚拟线程（Virtual Threads） Java 21 引入了**虚拟线程**（Virtual Threads）功能，类似于Go语言中的`Goroutines`。 虚拟线程是一种轻量级的线程，它可以极大地减少了编写、维护和管理高吞吐量并发应用程序所需的工作量。 Java平台目前为止有两种类型的线程：**传统线程**，也称为==平台线程==，和**虚拟线程**。 ## 平台线程 在引入虚拟线程之前，我们所使用的线程`java.lang.Thread`是由所谓的平台线程支持的。 这些线程通常是 1:1 映射到操作系统线程的，因此它们是重量级的，创建和销毁线程的开销很大。 且每个请求都需要一个独立的线程，这会导致线程资源的快速耗尽，从而限制了应用程序的可伸缩性。 ### 创建平台线程 ```java Thread thread = new Thread(() -> { // 由平台线程执行的代码 }).start(); ``` 随着[Project Loom](https://openjdk.org/projects/loom/)简化了新的并发方法，它还提供了一种新的方法来创建平台支持的线程： ```java Thread thread = Thread.ofPlatform() .start(runnable); // 或者 Thread thread = Thread.ofPlatform(). .daemon() .name("platform-thread") .unstarted(runnable); ``` ## 虚拟线程 虚拟线程是JDK提供的**轻量级线程**实现，可以在同一个OS线程上运行许多虚拟线程。 虚拟线程为平台线程提供了一种更有效的替代方案，允许开发人员以显著降低的开销处理大量任务。 这些线程提供了与现有Java代码的兼容性和无缝迁移路径，从而从增强的性能和资源利用率中获益。 许多语言中都有某种形式的轻量级线程： * Go语言的[Goroutines](https://go.dev/tour/concurrency/1) * Erlang的[Erlang Processes](https://www.erlang.org/docs/23/efficiency_guide/processes.html) * Haskell的[Haskell Threads](https://wiki.haskell.org/Lightweight_concurrency) * 等等 ### 创建虚拟线程 1. 使用`Thread.startVirtualThread()`方法创建虚拟线程： ```java // 使用静态构建器方法 Thread.startVirtualThread(() -> { // 由虚拟线程执行的代码 }); ``` 也可以使用`Thread.ofVirtual()`来创建，这里还可以设置一些属性，比如：线程名称等。具体如下代码： ```java Thread virtualThread = Thread.ofVirtual() .name("virtual-thread") .start(runnable); ``` 2. 使用`ExecutorService`创建虚拟线程： 从Java 5开始，就推荐开发人员使用`ExecutorServices`而不是直接使用`Thread`类了。 现在，Java 21中引入了使用虚拟线程，所以也有了新的ExecutorService来适配，看看下面的例子： ```java try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { IntStream.range(0, 10_000).forEach(i -> { executor.submit(() -> { Thread.sleep(Duration.ofSeconds(1)); return i; }); }); } // executor.close() 被隐式调用, 然后 waits ``` 3.使用`ThreadFactory`创建虚拟线程： 开发者还可以创建一个生成虚拟线程的工厂来管理，具体看下面的例子例子： ```java ThreadFactory virtualThreadFactory = Thread.ofVirtual() .name("virtual-thread", 0) .factory(); Thread factoryThread = virtualThreadFactory.newThread(() -> { // 由虚拟线程执行的代码 }); factoryThread.start(); ``` 这段代码创建了一个虚拟线程工厂，每个虚拟线程都会以`virtual-thread`为前缀、以数字结尾（从0开始累加）的名称。 ## 虚拟线程如何工作 虚拟线程是一个新的轻量级`java.lang.Thread`变体，由JVM的[Project Loom](https://openjdk.org/projects/loom/)项目实现的。 它使用了一种称为`Continuation`的技术，不受操作系统的管理或调度。相反，JVM负责调度。  应用程序实例化虚拟线程，而 JVM 分配计算资源来处理它们。 与传统线程相对比，传统线程直接映射到操作系统（OS）进程。 传统线程中，应用程序代码负责提供和释放 OS 资源。 而虚拟线程中，应用程序实例化虚拟线程，从而表达并发需求。 但实际上是 JVM 从操作系统获取并释放资源。  所需的平台线程在 FIFO 工作窃取 [ForkJoinPool](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/concurrent/ForkJoinPool.html) 中进行管理，默认情况下使用所有可用处理器， 但可以通过调整系统属性 `jdk.virtualThreadScheduler.parallelism` 来根据您的需求进行修改。 您熟悉的 `ForkJoinPool` 和其他功能（如并行流）使用的公共池的主要区别在于，公共池以 LIFO 模式运行。 ================================================ FILE: src/md/java/features/Java9/jep222-jshell.md ================================================ --- title: Java 9 新特性：交互式编程环境JShell shortTitle: description: icon: cover: author: 流浪码客 isOriginal: true sticky: false star: false date: 2023-12-21 category: Java Features tag: - java order: 222 --- # Java 9 新特性：交互式编程环境JShell JShell 是 Java 9 引入的一个**交互式编程环境**，它是 Java 编程语言的 REPL（Read-Eval-Print Loop）实现。 REPL 是一种编程环境，允许用户输入表达式并立即看到结果，而无需事先编写和编译完整的程序。 JShell 的目标是提供一个轻量级、灵活且易于使用的工具，使得 Java 开发者能够更直观地编写和测试代码。 ## JShell快速入门 ### 启动JShell 打开终端，然后执行命令：`jshell`，执行效果如下： ```java ➜ ~ jshell | 欢迎使用 JShell -- 版本 9 | 要大致了解该版本, 请键入: /help intro jshell> ``` ### 帮助介绍 /help intro 执行 `/help intro` 命令以获取有关 JShell 工具的简要介绍，**intro** 是主题，提供了关于 jshell 工具的核心概念和使用方法的信息。 ``` jshell> /help intro | | intro | ===== | | 使用 jshell 工具可以执行 Java 代码，从而立即获取结果。 | 您可以输入 Java 定义（变量、方法、类等等），例如：int x = 8 | 或 Java 表达式，例如：x + x | 或 Java 语句或导入。 | 这些小块的 Java 代码称为“片段”。 | | 这些 jshell 工具命令还可以让您了解和 | 控制您正在执行的操作，例如：/list | | 有关命令的列表，请执行：/help jshell> ``` ### 定义变量、方法、类 ```java // 定义变量 jshell> int x = 8 x ==> 8 // 定义方法 jshell> int square(int num) { ...> return num * num; ...> } | 已创建 方法 square(int) // 定义类 jshell> public class Message{ ...> private String msg; ...> public Message(String msg){ ...> this.msg = msg; ...> } ...> public String getMessage(){ ...> return msg; ...> } ...> } | 已创建 类 Message jshell> ``` ### 执行表达式、调用方法 ```java // 执行 Java 表达式 jshell> x + x $4 ==> 16 // 调用方法 jshell> square(5) $5 ==> 25 // 创建类实例并调用方法 jshell> Message messageObj = new Message("Hello, JShell!"); messageObj ==> Message@6d4b1c02 jshell> messageObj.getMessage() $7 ==> "Hello, JShell!" ``` ## 查看定义的变量：/vars ```java jshell> /vars | int x = 8 | int $4 = 16 | int $5 = 25 | Message messageObj = Message@6d4b1c02 | String $7 = "Hello, JShell!" ``` ## 查看定义的方法：/methods ```java jshell> /methods | int square(int) ``` ## 查看定义的类：/types ```java jshell> /types | class Message ``` ## 列出输入源条目：/list 执行后，可以看到之前在`jshell`中输入的内容清单： ```java jshell> /list 1 : int x = 8; 2 : int square(int num) { return num * num; } 3 : public class Message{ private String msg; public Message(String msg){ this.msg = msg; } public String getMessage(){ return msg; } } 4 : x + x 5 : square(5) 6 : Message messageObj = new Message("Hello, JShell!"); 7 : messageObj.getMessage() jshell> ``` ## 编辑源条目：/edit 上面通过`/list`列出了输入的条目信息，下面试试通过`/edit`编辑下，比如： ```java jshell> /edit 2 ``` 这将打开编辑器，修改先前定义的 `square` 方法。 修改完成后，点击 **accept** 即可 ## 删除源条目：/drop 使用 `/drop` 命令可以删除之前输入的源代码块。可以通过指定**名称**或 **ID** 删除特定的源代码块。例如： ```java jshell> /drop Message | 已删除 类 Message ``` 这将删除之前定义的 `Message` 类。 ## 保存文件：/save 通过 `/save` 命令，您可以将 JShell 中的源代码保存到文件中，以便将其保留或与他人共享。例如： ```java jshell> /save myCode.java ``` 这将把当前所有的源代码保存到一个名为 `myCode.java` 的文件中。 ## 打开文件：/open 使用 `/open` 命令可以将文件的内容导入到 JShell 中，以便重新使用或修改。例如： ```java jshell> /open myCode.java ``` 这将导入之前保存的 `myCode.java` 文件中的源代码。 ## 重置jshell：/reset 使用 `/reset` 命令可以清空 JShell 的状态，包括所有定义的变量、方法和类。例如： ```java jshell> /reset | 正在重置状态 ``` 这将重置 JShell 并清除所有之前定义的内容。 ## 查看引入的包：/imports 使用 `/imports` 命令可以查看当前已经导入的包。这对于确保您在 JShell 中能够访问所需的类和方法非常有用。例如： ```java jshell> /imports | import java.util.* ``` 这表明已经导入了 `java.util` 包。 ## 退出jshell：/exit 使用 `/exit` 命令可以退出 JShell。如果需要，在命令后可以添加一个整数表达式片段作为退出代码。例如： ```java jshell> /exit 0 ``` 这将以退出代码 0 退出 JShell。 ## 查看命令：/help 最后，使用 `/help` 命令可以随时查看 JShell 的帮助信息，了解各种命令和主题的使用方法。例如： ```java jshell> /help | 键入 Java 语言表达式, 语句或声明。 | 或者键入以下命令之一: | /list [<名称或 id>|-all|-start] | 列出您键入的源 | /edit <名称或 id> | 编辑源条目 | /drop <名称或 id> | 删除源条目 | /save [-all|-history|-start] <文件> | 将片段源保存到文件 | /open
字符串的字节长度
`u1 bytes[length];`
UTF-8编码的字节数据 | | CONSTANT_Integer_info(3) | 整型字面量 | `u4 bytes;` 32位整数值 | | CONSTANT_Float_info(4) | 浮点型字面量 | `u4 bytes;` 32位浮点数值 | | CONSTANT_Long_info(5) | 长整型字面量 | `u4 high_bytes;` 高32位
`u4 low_bytes;` 低32位 | | CONSTANT_Double_info(6) | 双精度浮点型字面量 | `u4 high_bytes;` 高32位
`u4 low_bytes;` 低32位 | | CONSTANT_Class_info(7) | 类或接口的符号引用 | `u2 name_index;`
指向类或接口名称的索引 | | CONSTANT_String_info(8) | 字符串类型字面量 | `u2 string_index;`
指向字符串字面量的索引 | | CONSTANT_Fieldref_info(9) | 字段的符号引用 | `u2 class_index;`
指向字段所在类的索引
`u2 name_and_type_index;`
指向字段名称和描述符的索引 | | CONSTANT_Methodref_info(10) | 类中方法的符号引用 | `u2 class_index;`
指向方法所在类的索引
`u2 name_and_type_index;`
指向方法名称和描述符的索引 | | CONSTANT_InterfaceMethodref_info(11) | 接口中方法的符号引用 | `u2 class_index;`
指向接口所在类的索引
`u2 name_and_type_index;`
指向方法名称和描述符的索引 | | CONSTANT_NameAndType_info(12) | 字段或方法的部分符号引用 | `u2 name_index;`
指向字段或方法名称的索引
`u2 descriptor_index;`
指向字段或方法描述符的索引 | | CONSTANT_MethodHandle_info(15) | 表示方法句柄 | `u1 reference_kind;`
方法句柄的类型
`u2 reference_index;`
指向方法句柄引用的索引 | | CONSTANT_MethodType_info(16) | 表示方法类型 | `u2 descriptor_index;`
指向方法类型描述符的索引 | | CONSTANT_Dynamic_info(17) | 表示一个动态计算常量 | `u2 bootstrap_method_attr_index;`
指向引导方法属性的索引
`u2 name_and_type_index;`
指向名称和描述符的索引 | | CONSTANT_InvokeDynamic_info(18) | 表示一个动态方法调用点 | `u2 bootstrap_method_attr_index;`
指向引导方法属性的索引
`u2 name_and_type_index;`
指向名称和描述符的索引 | | CONSTANT_Module_info(19) | 表示一个模块 | `u2 name_index;`
指向模块名称的索引 | | CONSTANT_Package_info(20) | 表示一个模块中开放或者导出的包 | `u2 name_index;`
指向包名称的索引 | 常量池的数据结构复杂，因为包含17种独立的常量类型，彼此没有共性，因此需要逐项讲解。 ### 4.访问标志 > **访问标志：** 紧随常量池之后，占2个字节，表示类或接口的访问权限和属性，如是否为`public`、`abstract`、`final`等。 * 访问标志不仅用于描述类或接口，在字段表和方法表中也存在各自的访问标志。 **类和接口的访问标志（access_flags）** | 标志名称 | 标志值 | 含义 | |----------------|--------|--------------------------------------------------------------------------------------------------------------------| | ACC_PUBLIC | 0x0001 | 是否为 `public` 类型 | | ACC_FINAL | 0x0010 | 是否被声明为 `final`，只有类可设置 | | ACC_SUPER | 0x0020 | 是否允许使用 `invokespecial` 字节码指令的新语义，`invokespecial` 指令的语义在 JDK 1.0.2 发生过改变，为了区别该指令使用哪种语义，JDK 1.0.2 之后编译出来的类的这个标志都必须为真 | | ACC_INTERFACE | 0x0200 | 标识这是一个接口 | | ACC_ABSTRACT | 0x0400 | 是否为 `abstract` 类型，对于接口或抽象类来说，此标志值为真，其他类型值为假 | | ACC_SYNTHETIC | 0x1000 | 标识这个类并非由用户代码产生的 | | ACC_ANNOTATION | 0x2000 | 标识这是一个注解 | | ACC_ENUM | 0x4000 | 标识这是一个枚举 | | ACC_MODULE | 0x8000 | 标识这是一个模块 | 总共有 16 个标记位可供使用，但常用的只有其中 7 个，见下图：  ### 5.类索引、父类索引与接口索引集合 > **类索引、父类索引与接口索引集合：** 用于确定类的继承和实现关系，分别指出当前类，父类，以及所实现的接口。 * **类索引（`this_class`）：** 当前类的全限定名 * **父类索引（`super_class`）：** 父类的全限定名 * **接口索引集合（`interfaces`）：** 当前类实现的所有接口 对于接口索引集合，首项为`u2`类型的接口计数器`interfaces_count`，表示索引表的容量。 如果该类没有实现任何接口，则该计数器值为0，后面接口的索引表不再占用任何字节。 否则每个索引指向常量池中的一个`CONSTANT_Class_info`类型的接口名称 **类索引查找全限定名的过程** 类索引和父类索引都是`u2`类型的索引值，指向`CONSTANT_Class_info`常量，再通过`CONSTANT_Class_info`常量中的索引值，找到定义在`CONSTANT_Utf8_info`中的全限定名字符串  ### 6.字段表集合 > **字段表（`field_info`）：** 描述类或接口中声明的字段。 [JVM虚拟机规范第四章-字段表](https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.5) 定义了结构： ```java field_info { u2 access_flags; u2 name_index; u2 descriptor_index; u2 attributes_count; attribute_info attributes[attributes_count]; } ``` **1、字段访问标志（`access_flags`）** 与类中的`access_flags`类似，都是一个`u2`的数据类型，取值如下表： | 标志名称 | 标志值 | 含义 | |---------------|--------|------------------| | ACC_PUBLIC | 0x0001 | 字段是否 `public` | | ACC_PRIVATE | 0x0002 | 字段是否 `private` | | ACC_PROTECTED | 0x0004 | 字段是否 `protected` | | ACC_STATIC | 0x0008 | 字段是否 `static` | | ACC_FINAL | 0x0010 | 字段是否 `final` | | ACC_VOLATILE | 0x0040 | 字段是否 `volatile` | | ACC_TRANSIENT | 0x0080 | 字段是否 `transient` | | ACC_SYNTHETIC | 0x1000 | 字段是编译器自动产生 | | ACC_ENUM | 0x4000 | 字段是否 `enum` | 受Java语法规则的约束： * `public`、`private`、`protected` 只能三选一 * `final`、`volatile`不能同时选择 * 接口中的字段必须有 `public`、`static`和`final` **2、简单名称（`name_index`）和描述符（`descriptor_index`）** 跟随`access_flags`标志之后的两项索引值；以及**全限定名**这三种特殊字符串的概念解释： * 全限定名：表示字段或方法在类中的完整路径，包括包名和类名。例如`java.lang.String` * 简单名称：表示字段或方法的名称。例如`name`是字段的简单名称，`toString`是方法的简单名称 * 描述符：表示字段或方法的类型信息 * 对于字段，描述符表示字段的类型，例如`I`表示`int`类型 * 对于方法，描述符表示方法的参数和返回类型，例如`(I)V`表示接受`int`参数且无返回值的方法 **描述符标识字符含义** | 标识字符 | 含义 | |------|------------------------------| | B | 基本类型 `byte` | | C | 基本类型 `char` | | D | 基本类型 `double` | | F | 基本类型 `float` | | I | 基本类型 `int` | | J | 基本类型 `long` | | S | 基本类型 `short` | | Z | 基本类型 `boolean` | | V | 特殊类型 `void` | | L | 对象类型，例如 `Ljava/lang/Object;` | **3、属性表集合** Class文件、字段表、和方法表都包含各自的属性表集合，用于记录特定场景下的附加信息。 每个属性表集合由属性计数（`attributes_count`）和若干属性信息（`attribute_info`）组成。 * **属性计数 (`attributes_count`)：** 表示该集合中包含的属性个数 * **属性信息 (`attribute_info`)：** 每个属性的信息结构，提供详细的元数据 ### 9.方法表集合 > **方法表（`method_info`）：** 描述类或接口中声明的方法。 [JVM虚拟机规范第四章-方法表](https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.6) 定义了结构，与属性表相似： ```java method_info { u2 access_flags; u2 name_index; u2 descriptor_index; u2 attributes_count; attribute_info attributes[attributes_count]; } ``` **1、方法访问标志（`access_flags`）** * 去除`volatile`和`transient`关键字，不能修饰方法 * 新增`synchronized`、`native`、`strictfp`和`abstract`关键字 | 标志名称 | 标志值 | 含义 | |------------------|--------|----------------------| | ACC_PUBLIC | 0x0001 | 方法是否为 `public` | | ACC_PRIVATE | 0x0002 | 方法是否为 `private` | | ACC_PROTECTED | 0x0004 | 方法是否为 `protected` | | ACC_STATIC | 0x0008 | 方法是否为 `static` | | ACC_FINAL | 0x0010 | 方法是否为 `final` | | ACC_SYNCHRONIZED | 0x0020 | 方法是否为 `synchronized` | | ACC_BRIDGE | 0x0040 | 方法是否是由编译器产生的桥接方法 | | ACC_VARARGS | 0x0080 | 方法接受不定参数 | | ACC_NATIVE | 0x0100 | 方法是否为 `native` | | ACC_ABSTRACT | 0x0400 | 方法是否为 `abstract` | | ACC_STRICT | 0x0800 | 方法是否为 `strictfp` | | ACC_SYNTHETIC | 0x1000 | 方法是否由编译器自动产生 | **2、方法的代码`Code`** 方法的定义可以通过访问标志、名称索引、描述符索引来表达清楚。 而方法的代码，经过`javac`编译成[字节码指令](/md/jvm/basics/bytecode)后存放在**方法属性表集合**中的`Code`的属性中。 ### 8.属性表集合 > **属性表：** 用于存储一些额外的信息，如源文件名称、编译器版本等。 * Class文件、字段表、和方法表都可以携带自己的属性表集合，以描述某些场景专有的信息。 * 其限制相对宽松，不要求具有严格顺序。编译器可向属性表写入自定义信息，JVM运行时会忽略不认识的属性。 **虚拟机规范预定义的属性** | 属性名称 | 使用位置 | 含义 | |--------------------------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Code | 方法表 | Java代码编译成的字节码指令 | | ConstantValue | 字段表 | 由`final`关键字定义的常量值 | | Deprecated | 类、方法表、字段表 | 被声明为`deprecated`的方法和字段 | | Exceptions | 方法表 | 方法抛出的异常列表 | | EnclosingMethod | 类文件 | 仅当一个类为局部类或者匿名类时才可能拥有此属性，用于标示此类存在的外部方法 | | InnerClasses | 类文件 | 内部类列表 | | LineNumberTable | Code属性 | Java代码的行号与字节码指令的对应关系 | | LocalVariableTable | Code属性 | 方法的局部变量信息 | | StackMapTable | Code属性 | JDK6新增属性，供新的类型检查验证器（Type Checker）检查和处理目标方法的局部变量和操作数栈所需要的类型是否匹配 | | Signature | 类、方法表、字段表 | JDK5新增属性，用于支持泛型标记下的方法签名。在 Java 语言中，任何类、接口、初始化方法或成员的字段如果包含了类型变量（Type Variables）或参数化类型（Parameterized Types），则 Signature 属性会记录泛型签名信息。由于 Java 的泛型采用擦除实现，为了能够在泛型擦除后还能确保签名信息，可以通过 Signature 属性记录泛型签名相关信息 | | SourceFile | 类文件 | 记录源文件名称 | | SourceDebugExtension | 类文件 | JDK5新增属性，用于存储额外的调试信息。譬如如在 JSP 文件调试时，无法通过 Java 推栈来推导到 JSP 文件的代码。JSR 45 提议的运行时通过插桩机制向虚拟机中的程序提供了一种进行调试的标准机制，使用该属性可以用于存储插桩时额外新增的调试信息 | | Synthetic | 类、方法表、字段表 | 标示为编译器自动生成的代码 | | LocalVariableTypeTable | 类 | JDK5新增属性，使用扩展的签名标示符，是为了引入泛型方法之后能描述泛型参数的类型而添加 | | RuntimeVisibleAnnotations | 类、方法表、字段表 | JDK5新增属性，为动态注解提供支持。该属性用于指明哪些注解是在运行时（实际在运行时就意味着反射调用）可见的 | | RuntimeInvisibleAnnotations | 类、方法表、字段表 | JDK5新增属性，与 RuntimeVisibleAnnotations 属性作用相反，用于指明哪些注解是在运行时不可见的 | | RuntimeVisibleParameterAnnotations | 方法表 | JDK5新增属性，作用与 RuntimeVisibleAnnotations 属性类似，只不过作用对象为方法参数 | | RuntimeInvisibleParameterAnnotations | 方法表 | JDK5新增属性，作用与 RuntimeInvisibleAnnotations 属性类似，只不过作用对象为方法参数 | | AnnotationDefault | 方法表 | JDK5新增属性，用于记录注解类型元素默认值 | | BootstrapMethods | 类文件 | JDK7新增属性，用于保存 invokedynamic 指令引用的引导方法限定符 | | RuntimeVisibleTypeAnnotations | 类、方法表、字段表、Code 属性 | JDK8新增属性，为实现 JSR 308 中新增的类型注解提供的支持。用于指明哪些注解是在运行时（实际在运行时意味着反射调用）可见的 | | RuntimeInvisibleTypeAnnotations | 类、方法表、字段表、Code 属性 | JDK8新增属性，为实现 JSR 308 中新增的类型注解提供的支持。与 RuntimeVisibleTypeAnnotations 属性作用相反，用于指明哪些注解是在运行时不可见的 | | MethodParameters | 方法表 | JDK8新增属性，用于支持（编译时加上 -parameters 参数）将方法参数名称保存进 Class 文件中，并可运行时获取此数据。此数据可用于方法参数名称（典型的如 IDE 的代码提示）只能通过 Javadoc 中得到 | | Module | 类 | JDK9新增属性，用于记录一个 Module 的名称以及相关信息（requires、exports、opens、uses、provides） | | ModulePackages | 类 | JDK9新增属性，用于记录一个模块中所有存在 exports 或者 opens 的包 | | ModuleMainClass | 类 | JDK9新增属性，用于指定一个模块的主类 | | NestHost | 类 | JDK11新增属性，用于支持嵌套类（Java中的内部类）的成员和访问控制的 API。——宿主类通过此属性知道自己有哪些内部类 | | NestMembers | 类 | JDK11新增属性，用于支持嵌套类（Java中的内部类）的成员和访问控制的 API。——宿主类通过此属性知道自己有哪些内部类 | [JVM虚拟机规范第四章-属性表](https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.7) 定义了结构： ```shell attribute_info { u2 attribute_name_index; u4 attribute_length; u1 info[attribute_length]; } ``` 对于每个属性，其名称从常量池中引用1个`CONSTANT_Utf8_info`表示， 通过1个`u4`的`attribute_length`说明属性值的字节数，属性值的结构完全自定义。 1. Code属性 2. Exceptions属性 3. LineNumberTable属性 4. LocalVariableTable及LocalVariableTypeTable属性 5. SourceFile及SourceDebugExtension属性 6. ConstantValue属性 7. InnerClasses属性 8. Deprecated及Synthetic属性 9. StackMapTable属性 10. Signature属性 11. BootstrapMethods属性 12. MethodParameters属性 13. 模块化相关属性 14. 运行时注解相关属性 ## 编译字节码分析（实践） 使用`javac Main.java`命令，编译生成`Main.class`文件： ```java public class Main { private int m; public int inc() { return m + 1; } } ``` 使用[WinHex](https://www.ghxi.com/winhex.html)(十六进制编辑器) 打开`.class`文件查看： ```shell CA FE BA BE 00 00 00 3D 00 13 0A 00 02 00 03 07 00 04 0C 00 05 00 06 01 00 10 6A 61 76 61 2F 6C 61 6E 67 2F 4F 62 6A 65 63 74 01 00 06 3C 69 6E 69 74 3E 01 00 03 28 29 56 09 00 08 00 09 07 00 0A 0C 00 0B 00 0C 01 00 04 4D 61 69 6E 01 00 01 6D 01 00 01 49 01 00 04 43 6F 64 65 01 00 0F 4C 69 6E 65 4E 75 6D 62 65 72 54 61 62 6C 65 01 00 03 69 6E 63 01 00 03 28 29 49 01 00 0A 53 6F 75 72 63 65 46 69 6C 65 01 00 09 4D 61 69 6E 2E 6A 61 76 61 00 21 00 08 00 02 00 00 00 01 00 02 00 0B 00 0C 00 00 00 02 00 01 00 05 00 06 00 01 00 0D 00 00 00 1D 00 01 00 01 00 00 00 05 2A B7 00 01 B1 00 00 00 01 00 0E 00 00 00 06 00 01 00 00 00 01 00 01 00 0F 00 10 00 01 00 0D 00 00 00 1F 00 02 00 01 00 00 00 07 2A B4 00 07 04 60 AC 00 00 00 01 00 0E 00 00 00 06 00 01 00 00 00 06 00 01 00 11 00 00 00 02 00 12 ``` * `CA FE BA BE`：**魔数**，用于标识Class文件格式 * `00 00 00 3D`：**版本号**，其中`00 00`是次版本号，`00 3D`是主版本号（61，对应Java17） * `00 13`：**常量池计数**，`0x13`十进制为19，第0项常量空出，因此常量池中有18个常量 使用`javap -verbose Main`命令查看**常量池**： ```shell Constant pool: #1 = Methodref #2.#3 // java/lang/Object."
### 连接（Linking）
分为三个阶段：
* **验证**（Verify）：确保字节码符合虚拟机要求
* **准备**（Prepare）：为字段赋予初始值
* **解析**（Resolve）：符号引用转换为直接引用
> **验证**（Verify）是连接阶段的第一阶段，目的是确保字节码的正确性和安全性，包括文件格式验证、元数据验证、字节码验证和符号引用验证四个阶段。
验证阶段大致上会完成下面四个阶段的检验动作：
1. **文件格式验证：** 检查字节流是否符合Class文件的格式规范。
2. **元数据验证：** 对类的元数据信息进行语义校验，确保其符合Java语言的语法和语意规则。
3. **字节码验证：** 通过数据流分析和控制流分析，确保字节码指令的合法性和逻辑正确性。
4. **符号引用验证：** 在解析阶段之前，检查符号引用是否能被正确解析。
> **准备**（Prepare）阶段为类中的静态变量分配内存并设置初始值。
静态变量的内存分配发生在**方法区**中。
* 在 JDK 7及之前，HotSpot使用**永久代**（PerGen）来实现方法区，存放在堆内存中。
* 在 JDK 8及之后，永久代被移除，取而代之的是**元空间**（Metaspace），存放在操作系统本地内存中。
> **解析**（Prepare）阶段是Java虚拟机将常量池内的符号引用替换为直接引用的过程。
* **符号引用（Symbolic References）：** 字符串形式表示的对目标的逻辑引用
* **直接引用（Direct References）：** 是直接定位到目标内存位置的指针、偏移量或句柄。
解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符这 7 类符号引用进行。
### 初始化（Initialization）
> 类加载过程的最后一个阶段，负责执行类构造器方法 `不执行自动装配。开发者需要使用`ref`标签显式声明依赖关系。 | | byName | **按名称自动装配**：
容器会寻找一个属性名称或setter方法名称相匹配的Bean定义将其注入。
例如：Bean的属性名为`master`（也就是说，它有一个`setMaster(..)`方法），Spring会寻找名为`master`的Bean定义来注入。 | | byType | **按类型自动装配**：
容器会寻找与属性类型相匹配的Bean定义将其注入。如果存在多个相同类型的Bean，将抛出异常。 | | constructor | **按构造函数参数类型自动装配**：
容器会寻找与构造函数参数类型相匹配的Bean定义将其注入。如果没有匹配的Bean定义，将抛出异常。这种模式确保了Bean在创建时其必需的依赖就已经被满足。 | 利用`byType`或`constructor`自动装配模式，你可以装配数组（`array`）和泛型集合（`collection`）。 在这种模式下，Spring容器会自动寻找所有与所需类型相匹配的Bean，并将其注入到定义的数组或集合中，从而满足配置的依赖关系。 此外，当预期的键（key）类型为`String`时，还可以自动装配一个强类型化的`Map`实例。 在这个`Map`中，键（key）将是Bean的名称，而值（value）则是所有匹配期望类型的Bean实例。 > 这样的自动装配`Map`实例，为我们提供了一种便捷的方式来管理和访问一组具有相同类型的Bean，特别是当我们需要根据名称快速查找特定的Bean时。 ## 自动装配的局限和缺点 自动装配在项目中保持一致性时效果最佳。如果自动装配没有被普遍采用，而只有少数Bean定义使用它，可能会引起开发人员的困惑。 以下是考虑自动装配时需要注意的限制和缺点： 1. **显式依赖优先**：当存在显式依赖（`property`或`constructor-arg`）时，自动装配将被忽略 2. **不适用于基本类型**：自动装配不适用于基本类型，如`int`、`long`、`String`等，因为它们没有Bean名称 3. **精确性问题**：自动装配不如显式注入精确，因为它依赖于类型匹配，而不是Bean的名称或其他限定符，这可能导致意外的结果 4. **文档化缺失**：自动装配的依赖关系可能不会自动包含在生成的文档中，因此开发者需要额外的文档或注释来解释Bean之间的依赖关系 5. **多重匹配问题**：当存在多个Bean定义与自动装配的属性类型匹配时，Spring将抛出异常 6. **歧义性**：当存在多个Bean定义与自动装配的属性类型匹配时，Spring将无法确定哪个Bean是首选的,就会抛出异常 你有以下几种方法来解决**多重匹配问题和歧义性**： * 放弃自动装配，使用显式装配 * 通过将Bean定义的`autowire-candidate`属性设置为`false`来排除Bean * 通过将Bean定义的`primary`属性设置为`true`来指定首选Bean * 实现更细粒度的控制，可以使用基于注解的配置方式， 参阅 [基于注解的容器配置](https://docs.spring.io/spring-framework/reference/core/beans/annotation-config.html) ## 从自动装配中排除Bean 在每个Bean定义中，你可以设置`autowire-candidate`属性来控制Bean是否标记为自动装配候选项。 * 默认情况下，`autowire-candidate`属性的值为`true`，表示Bean是自动装配的候选项 * 属性为`false`时，Bean将被排除在自动装配之外，这一设置对注解式配置 （如[@Autowired](https://docs.spring.io/spring-framework/reference/core/beans/annotation-config/autowired.html)）同样有效 ::: note **注意⚠️**：`autowire-candidate`属性仅影响基于类型的自动装配模式。 对于按名称的显示引用，`autowire-candidate`属性不起作用。 只要名称匹配，它仍然可以被注入。 ::: 你还可以根据`byName`的模式匹配来限制自动装配候选项。 顶层的`