Java 基础类库：System、Runtime、Object、Math、日期、时间

摘要：类提供方法和方法来通知系统进行垃圾回收清理系统资源，并提供了和方法来加载文件和动态链接库。返回按照标准的规定，对两个参数进行余数运算。

//Java程序入口：main()方法
public static void main(String[] args){...}

public修饰符：Java类由JVM调用，为了让JVM可以自由调用这个main()方法，所以使用public修饰符把这个方法暴露出来

static修饰符：JVM调用这个主方法时，不会先创建该主类的对象，然后通过对象来调用该主方法。JVM直接通过该类来调用主方法，因此使用static修饰该主方法。

void返回值：因为主方法被JVM调用，该方法的返回值将返回给JVM，因此main()方法没有返回值。

使用Scanner类可以很方便地获取用户的键盘输入，Scanner是一个基于正则表达式的文本扫描器，可以从文件、输入流、字符串中解析出基本类型值和字符串值。

Scanner主要提供了两个方法来扫描输入

hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果只是判断是否包含下一个字符串，则直接使用hasNext()

nextXxx()：获取下一个输入项。

默认情况下，Scanner使用空白（空格、Tab空白、回车）作为多个输入项之间的分隔符。

import java.util.Scanner;

public class ScannerKeyBoardTest 
{
    public static void main(String[] args) 
    {
        //System.in代表标准输入，就是键盘输入
        Scanner sc = new Scanner(System.in);
        //增加下面一行将只把回车作为分隔符
        //sc.useDelimiter("
");
        //判断是否还有下一个输入项
        while (sc.hasNext()) 
        {
            //输出输入项
            System.out.println("键盘输入的内容是："+ sc.next());
        }
    }
}

Scanner提供了两个简单的方法来逐行读取

boolean hasNextLine()：返回输入源中是否还有下一行

String nextLine()：返回输入源中下一行的字符串

创建Scanner对象，传入一个File对象作为参数，程序将读取ScannerFileTest.java文件中的内容

import java.io.File;
import java.util.Scanner;

public class ScannerFileTest 
{
    public static void main(String[] args) throws Exception
    {
        //将一个File对象作为Scanner的构造器参数，Scanner读取文件内容
        Scanner sc = new Scanner(new File("ScannerFileTest.java"));
        System.out.println("ScannerFileTest.java文件内容如下：");
        //判断是否还有下一行
        while (sc.hasNextLine()) 
        {
            //输出文件中的下一行
            System.out.println(sc.nextLine());
        }
    }
}  

System类代表了当前Java程序的运行平台，程序不能创建System类的对象，System类提供了一些类变量和类方法，允许直接通过System类来调用这些类变量和类方法。

加载文件和动态链接库主要对naive方法有用，对于一些特殊的功能（如访问操作系统底层硬件设备等）Java程序无法实现必须借助C语音来完成，此时需要使用C语音为Java方法提供实现

Java程序中声明native修饰的方法，类似于abstract方法，只有方法签名，没有实现。编译该Java程序，生成一个class文件

用javah编译第1步生成的class文件，将生成一个.h文件

写一个.cpp文件实现native，这一步需要包含第2步生成的.h文件（.h文件中包含JDK带的jni.h文件）

将第3步的.cpp文件编译成动态链接库文件

在Java中用System类的loadLibrary..()方法或Runtime类的loadLibrary()方法加载第4步产生的动态链接库文件，Java程序中就可以调用这个native方法了。

import java.io.FileOutputStream;
import java.util.Map;
import java.util.Properties;

public class SystemTest 
{
    public static void main(String[] args) throws Exception
    {
        //获取系统所有的环境变量
        Map env = System.getenv();
        for(String name : env.keySet())
        {
            System.out.println(name + " ---> " + env.get(name));
        }
        //获取指定环境变量的值
        System.out.println(System.getenv("JAVA_HOME"));
        //获取所有的系统属性
        Properties properties = System.getProperties();
        //将所有的系统属性保存到properties.txt文件中
        properties.store(new FileOutputStream("properties.txt"), "System Properties");
        //输出特定的系统属性
        System.out.println(System.getProperty("os.name"));
    }
}

System类的in、out和err分别代表系统的标准输入（通常是键盘）、标准输出（通常是显示器）和错误输出流，并提供了setIn()、setOut()和setErr()方法

identityHashCode(Object x)方法，该方法返回指定对象的精确hashCode值，也就是根据该对象的地址计算得到的hashCode值。如果两个对象的identityHashCode值相同，则两个对象绝对是同一个对象。

public class IdentityHashCodeTest 
{
    public static void main(String[] args) 
    {
        //下面程序中s1和s2是两个不同的对象
        String s1 = new String("Hello");
        String s2 = new String("Hello");
        //String重写了hashCode()方法——改为根据字符序列计算hashCode值
        //因为s1和s2的字符序列相同，所有它们的hashCode()方法返回值相同
        System.out.println(s1.hashCode() + "---" + s2.hashCode());
        //s1和s2是不同的字符串对象，所以它们的identityHashCode值不同
        System.out.println(System.identityHashCode(s1) + "---" + System.identityHashCode(s2));
        String s3 = "Java";
        String s4 = "Java";
        //s3和s4是相同的字符串对象，所以它们的identityHashCode值相同
        System.out.println(System.identityHashCode(s3) + "---" + System.identityHashCode(s4));
    }
}

Runtime类代表Java程序的运行时环境，可以访问JVM的相关信息，如处理器数量、内存信息等。每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。应用程序不能创建自己的Runtime实例，但可以通过getRuntime()方法获取与之关联的Runtime对象。

Runtime类提供gc()方法和runFinalization()方法来通知系统进行垃圾回收、清理系统资源，并提供了load(String filename)和loadLibrary(String libname)方法来加载文件和动态链接库。

public class ExecTest 
{
    public static void main(String[] args) throws Exception
    {
        //获取Java程序关联的运行时对象
        Runtime runtime = Runtime.getRuntime();
        System.out.println("处理器数量：" + runtime.availableProcessors());
        System.out.println("空闲内存数：" + runtime.freeMemory());
        System.out.println("总内存数：" + runtime.totalMemory());
        System.out.println("可用最大内存数" + runtime.maxMemory());
        //运行记事本程序
        runtime.exec("notepad.exe");
    }
}

Object类是所有类、数组、枚举类的父类，Java允许把任何类型的对象赋给Object类型的变量。

boolean equals(Object obj)：判断指定对象与该对象是否相等

protected void finalize()：当系统中没有引用变量引用到该对象时，垃圾回收器调用该方法来清理该对象的资源

ClassgetClass()：返回该对象的运行时类

int hashCode()：返回该对象的hashCode()值

String toString()：返回该对象的字符串表示，当程序使用System.out.println()方法输出一个对象，或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的toString()方法返回该对象的字符串表示。

Java提供protected修饰的clone()方法，用于帮助其他对象来实现“自我克隆”，需要被子类重写或调用。

自定义类实现“克隆”的步骤

自定义类实现Cloneable接口

自定义实现自己的clone()方法

实现clone()方法时通过super.clone();调用Object实现的clone()方法来得到该对象的副本，并返回该副本。

class Address
{
    String detail;
    public Address(String detail)
    {
        this.detail =detail;
    }
}
//实现Cloneable接口
class User implements Cloneable
{
    int age;
    Address address;
    public User(int age)
    {
        this.age = age;
        address = new Address("珠江新城");
    }
    //通过调用super.clone()来实现clone()方法
    public User clone() throws CloneNotSupportedException
    {
        return (User)(super.clone());
    }
}
public class CloneTest
{
    public static void main(String[] args) throws CloneNotSupportedException
    {
        User u1 = new User(27);
        //clone得到u1对象的副本
        User u2 = u1.clone();
        //判断u1、u2是否相同
        System.out.println(u1 == u2);
        //判断u1、u2的address是否相同
        System.out.println(u1.address == u2.address);
    }
}

如果不能确定一个引用变量是否为null，如果贸然地调用该变量的toString()方法，则可能引发NullPointerException异常；如果使用Object类提供的toString(Object o)方法，就不会引发空指针异常，当o为null时，程序将返回一个"null"字符串。

Java为工具类的命名习惯是添加一个字母s，比如操作数组的工具类Arrays，操作集合的工具类Collections。

import java.util.Objects;
public class ObjectsTest 
{
    //定义一个objectsTest变量，它的默认值是null
    static ObjectsTest objectsTest;
    public static void main(String[] args) 
    {
        //输出一个null对象的hashCode值，输出0
        System.out.println(Objects.hashCode(objectsTest));
        //输出一个null对象的toString，输出null
        System.out.println(Objects.toString(objectsTest));
        //要求objectsTest不能为null，如果objectsTest为null
        System.out.println(Objects.requireNonNull(objectsTest,"objectsTest参数不能是null!"));
    }
}

requireNonNull()方法，当传入的参数不为null时，该方法返回参数本身；否则将会引发NullPointerException异常。

构造器被定义成private的，因此无法参加Math类的对象，所有方法都是类方法，可以直接通过类名来调用它们，还提供了两个类变量：PI和E

public class MathTest
{
    public static void main(String[] args)
    {
        /*---------下面是三角运算---------*/
        // 将弧度转换角度
        System.out.println("Math.toDegrees(1.57)："
            + Math.toDegrees(1.57));
        // 将角度转换为弧度
        System.out.println("Math.toRadians(90)："
            + Math.toRadians(90));
        // 计算反余弦，返回的角度范围在 0.0 到 pi 之间。
        System.out.println("Math.acos(1.2)：" + Math.acos(1.2));
        // 计算反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
        System.out.println("Math.asin(0.8)：" + Math.asin(0.8));
        // 计算反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
        System.out.println("Math.atan(2.3)：" + Math.atan(2.3));
        // 计算三角余弦。
        System.out.println("Math.cos(1.57)：" + Math.cos(1.57));
        // 计算值的双曲余弦。
        System.out.println("Math.cosh(1.2 )：" + Math.cosh(1.2 ));
        // 计算正弦
        System.out.println("Math.sin(1.57 )：" + Math.sin(1.57 ));
        // 计算双曲正弦
        System.out.println("Math.sinh(1.2 )：" + Math.sinh(1.2 ));
        // 计算三角正切
        System.out.println("Math.tan(0.8 )：" + Math.tan(0.8 ));
        // 计算双曲正切
        System.out.println("Math.tanh(2.1 )：" + Math.tanh(2.1 ));
        // 将矩形坐标 (x, y) 转换成极坐标 (r, thet));
        System.out.println("Math.atan2(0.1, 0.2)：" + Math.atan2(0.1, 0.2));
        /*---------下面是取整运算---------*/
        // 取整，返回小于目标数的最大整数。
        System.out.println("Math.floor(-1.2 )：" + Math.floor(-1.2 ));
        // 取整，返回大于目标数的最小整数。
        System.out.println("Math.ceil(1.2)：" + Math.ceil(1.2));
        // 四舍五入取整
        System.out.println("Math.round(2.3 )：" + Math.round(2.3 ));
        /*---------下面是乘方、开方、指数运算---------*/
        // 计算平方根。
        System.out.println("Math.sqrt(2.3 )：" + Math.sqrt(2.3 ));
        // 计算立方根。
        System.out.println("Math.cbrt(9)：" + Math.cbrt(9));
        // 返回欧拉数 e 的n次幂。
        System.out.println("Math.exp(2)：" + Math.exp(2));
        // 返回 sqrt(x2 +y2)
        System.out.println("Math.hypot(4 , 4)：" + Math.hypot(4 , 4));
        // 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
        System.out.println("Math.IEEEremainder(5 , 2)："
            + Math.IEEEremainder(5 , 2));
        // 计算乘方
        System.out.println("Math.pow(3, 2)：" + Math.pow(3, 2));
        // 计算自然对数
        System.out.println("Math.log(12)：" + Math.log(12));
        // 计算底数为 10 的对数。
        System.out.println("Math.log10(9)：" + Math.log10(9));
        // 返回参数与 1 之和的自然对数。
        System.out.println("Math.log1p(9)：" + Math.log1p(9));
        /*---------下面是符号相关的运算---------*/
        // 计算绝对值。
        System.out.println("Math.abs(-4.5)：" + Math.abs(-4.5));
        // 符号赋值，返回带有第二个浮点数符号的第一个浮点参数。
        System.out.println("Math.copySign(1.2, -1.0)："
            + Math.copySign(1.2, -1.0));
        // 符号函数；如果参数为 0，则返回 0；如果参数大于 0，
        // 则返回 1.0；如果参数小于 0，则返回 -1.0。
        System.out.println("Math.signum(2.3)：" + Math.signum(2.3));
        /*---------下面是大小相关的运算---------*/
        // 找出最大值
        System.out.println("Math.max(2.3 , 4.5)：" + Math.max(2.3 , 4.5));
        // 计算最小值
        System.out.println("Math.min(1.2 , 3.4)：" + Math.min(1.2 , 3.4));
        // 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
        System.out.println("Math.nextAfter(1.2, 1.0)："
            + Math.nextAfter(1.2, 1.0));
        // 返回比目标数略大的浮点数
        System.out.println("Math.nextUp(1.2 )：" + Math.nextUp(1.2 ));
        // 返回一个伪随机数，该值大于等于 0.0 且小于 1.0。
        System.out.println("Math.random()：" + Math.random());
    }
}

Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子（当前时间作为种子），另一个构造器需要程序员显式传入一个long型整数的种子

ThreadLocalRandom类是Java7新增的一个类，在并发访问环境下，可以减少多线程资源竞争，最终保证系统具有更好的线程安全性。提供静态的current()方法来获取ThreadLocalRandom对象，获取该对象之后调用各种nextXxx()方法来获取伪随机数

import java.util.Arrays;
import java.util.Random;

public class RandomTest 
{
    public static void main(String[] args) 
    {
        Random random = new Random();
        System.out.println("random.nextBoolean():"+random.nextBoolean());
        byte[] buffer = new byte[16];
        random.nextBytes(buffer);
        System.out.println(Arrays.toString(buffer));
        //生成0.0~1.0之间的伪随机double数
        System.out.println("random.nextDouble():"+random.nextDouble());
        //生成0.0~1.0之间的伪随机float数
        System.out.println("random.nextFloat():"+random.nextFloat());
        //生成平均值是0.0，标准差是1.0的伪高斯数
        System.out.println("random.nextGaussian():"+random.nextGaussian());
        //生成0~26之间的伪随机整数
        System.out.println("random.nextInt(26):"+random.nextInt(26));
        //生成一个处于long整数取值范围的伪随机整数
        System.out.println("random.nextLong():"+random.nextLong());
    }
}

Random使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，对它们以同样的顺序调用方法，则它们会产生相同的数字序列。为避免两个Random对象产生相同的数字序列，推荐使用当前时间作为Random对象的种子

Random rt = new Random(System.currentTimeMillis());

ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
//生成一个4~20之间的伪随机整数
int vall = threadLocalRandom.nextInt(4, 20);
//生成一个2.0~10.0之间的伪随机浮点数
int vall2 = threadLocalRandom.nextDouble(2.0, 10.0);

BigDecimal能精确表示、计算浮点数。该类提供了大量的构造器用于创建BigDecimal对象，包括把所有基本数值型变量转换成一个BigDecimal对象，也包括利用数字字符串、数字字符数组来创建BigDecimal对象。

BigDecimal(String val)构造器的结果是可预知的——写入new BigDecimal("0.1")将创建一个BigDecimal对象，优先建议使用基于String的构造器

如果必须使用double浮点数作为BigDecimal构造器的参数时， 不要直接将该double浮点数作为构造器参数创建BigDecimal对象，而是通过BigDecimal.valueOf(double calue)静态方法来创建BigDecimal对象

Date()：生成一个代表当前日期的Date对象
Date(long date)：根据指定的long型整数来生成一个Date对象
boolean after(Date when)：测试该日期是否在指定日期when之后
boolean before(Date when)：测试该日期是否在指定日期when之前
long getTime()：返回该时间对应的long型整数，即从GMT 1970-01-01 00:00:00到该Date对象之间的时间差，以毫秒为计时单位
void setTime()：设置该Date对象的时间

Calendar类是一个抽象类，所以不能使用构造器来创建Calendar对象。但它提供了几个静态getInstance()方法来获取Calendar对象，这些方法根据TimeZone，Locale类来获取特定的Calendar

Calendar类提供了大量访问、修改日期时间的方法

void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量

int get(int field)：返回给定日历字段的值

int getActualMaximum(int field)：返回指定日历字段可能拥有的最大值

int getActualMinimum(int field)：返回指定日历字段可能拥有的最小值

void roll(int field, int amount)：向指定日历字段添加指定（有符号的）时间量，不更改更大的字段

void set(int field, int value)：将给定的日历字段设置为给定值

void set(int year, int month, int date)：设置日历字段年、月、日的值

void set(int year, int month, int date, int hourOfDay, int minute)：设置日历字段年、月、日、时、分、秒的值。

public class CalendarTest
{
    public static void main(String[] args)
    {
        Calendar c = Calendar.getInstance();
        // 取出年
        System.out.println(c.get(YEAR));
        // 取出月份
        System.out.println(c.get(MONTH));
        // 取出日
        System.out.println(c.get(DATE));
        // 分别设置年、月、日、小时、分钟、秒
        c.set(2003 , 10 , 23 , 12, 32, 23); //2003-11-23 12:32:23
        System.out.println(c.getTime());
        // 将Calendar的年前推1年
        c.add(YEAR , -1); //2002-11-23 12:32:23
        System.out.println(c.getTime());
        // 将Calendar的月前推8个月
        c.roll(MONTH , -8); //2002-03-23 12:32:23
        System.out.println(c.getTime());

        Calendar cal1 = Calendar.getInstance();
        cal1.set(2003, 7, 23, 0, 0 , 0); // 2003-8-23
        cal1.add(MONTH, 6); //2003-8-23 => 2004-2-23
        System.out.println(cal1.getTime());

        Calendar cal2 = Calendar.getInstance();
        cal2.set(2003, 7, 31, 0, 0 , 0); // 2003-8-31
        // 因为进位到后月份改为2月，2月没有31日，自动变成29日
        cal2.add(MONTH, 6); // 2003-8-31 => 2004-2-29
        System.out.println(cal2.getTime());

        Calendar cal3 = Calendar.getInstance();
        cal3.set(2003, 7, 23, 0, 0 , 0); //2003-8-23
        // MONTH字段“进位”，但YEAR字段并不增加
        cal3.roll(MONTH, 6); //2003-8-23 => 2003-2-23
        System.out.println(cal3.getTime());

        Calendar cal4 = Calendar.getInstance();
        cal4.set(2003, 7, 31, 0, 0 , 0); //2003-8-31
        // MONTH字段“进位”后变成2，2月没有31日，
        // YEAR字段不会改变，2003年2月只有28天
        cal4.roll(MONTH, 6); //2003-8-31 => 2003-2-28
        System.out.println(cal4.getTime());
    }
}

add(int field, int amount)

当被修改的字段超过它允许的范围时，会发生进位，即上一级字段会增大

如果下一级字段也需要改变，那么该字段会修正到变化最小的值

roll当被修改的字段超过它允许的范围时，上一级字段不会增大，下一级字段的处理规则与add相似

public class LenientTest
{
    public static void main(String[] args)
    {
        Calendar cal = Calendar.getInstance();
        // 结果是YEAR字段加1，MONTH字段为1（二月）
        cal.set(MONTH , 13);   //①
        System.out.println(cal.getTime());
        // 关闭容错性
        cal.setLenient(false);
        // 导致运行时异常
        cal.set(MONTH , 13);   //②
        System.out.println(cal.getTime());
    }
}

①代码可以正常运行，YEAR字段加1；②代码将会导致运行时异常，因为设置MONTH字段超出了MONTH字段允许的范围。Calendar提供了一个setLenient()用于设置它的容错性，Calendar默认支持较好的容错性，通过setLenient(false)可以关闭Calendar的容错性，让它严格的参数检查。

Clock：该类用于获取指定时间的当前的日期、时间。该类可取代System类的currentTimeMillis()方法，而且提供了更多方法来获取当前日期、时间。该类提供了大量静态方法来获取Clock对象

Duration:该类代表持续的时间

Instant：代表一个具体的时刻，可以精确到纳秒。提供了静态now()方法来获取当前时刻，也提供了静态的now(Clock clock)方法来获取clock对应的时刻。minusXxx()和plusXxx()方法在当前时刻的基础上减去/加上一段时间

LocalDate：该类代表不带时区的日期。供了静态的now(Clock clock)方法来获取clock对应的日期。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几年、几月、几周或几日

LocalTime：该类代表不带时区的时间。供了静态的now(Clock clock)方法来获取clock对应的时间。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几小时、几分、几秒等

LocalDateTime：该类代表不带时区的日期、时间。供了静态的now(Clock clock)方法来获取clock对应的时间、日期。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几年、几月、几周、几日、几小时、几分、几秒等

MonthDay：该类仅表示月日。提供了静态的now(Clock clock)方法

Year：该类仅表示年。提供了静态的now(Clock clock)方法。minusYears()和plusYears()方法
-YearMonth：该类仅代表年月。提供了静态的now(Clock clock)方法，minusXxx()和plusXxx()方法

ZonedDatetime：该类代表一个时区化的日期、时间

ZoneId：该类代表一个时区

DayofWeek：这是一个枚举类周一到周六的枚举

Mouth：该类也是一个枚举类，定义一月到十二月的枚举值

public class NewDatePackageTest
{

public static void main(String[] args)
{
    // -----下面是关于Clock的用法-----
    // 获取当前Clock
    Clock clock = Clock.systemUTC();
    // 通过Clock获取当前时刻
    System.out.println("当前时刻为：" + clock.instant());
    // 获取clock对应的毫秒数，与System.currentTimeMillis()输出相同
    System.out.println(clock.millis());
    System.out.println(System.currentTimeMillis());
    // -----下面是关于Duration的用法-----
    Duration d = Duration.ofSeconds(6000);
    System.out.println("6000秒相当于" + d.toMinutes() + "分");
    System.out.println("6000秒相当于" + d.toHours() + "小时");
    System.out.println("6000秒相当于" + d.toDays() + "天");
    // 在clock基础上增加6000秒，返回新的Clock
    Clock clock2 = Clock.offset(clock, d);
    // 可看到clock2与clock1相差1小时40分
    System.out.println("当前时刻加6000秒为：" +clock2.instant());
    // -----下面是关于Instant的用法-----
    // 获取当前时间
    Instant instant = Instant.now();
    System.out.println(instant);
    // instant添加6000秒（即100分钟），返回新的Instant
    Instant instant2 = instant.plusSeconds(6000);
    System.out.println(instant2);
    // 根据字符串中解析Instant对象
    Instant instant3 = Instant.parse("2014-02-23T10:12:35.342Z");
    System.out.println(instant3);
    // 在instant3的基础上添加5小时4分钟
    Instant instant4 = instant3.plus(Duration
        .ofHours(5).plusMinutes(4));
    System.out.println(instant4);
    // 获取instant4的5天以前的时刻
    Instant instant5 = instant4.minus(Duration.ofDays(5));
    System.out.println(instant5);
    // -----下面是关于LocalDate的用法-----
    LocalDate localDate = LocalDate.now();
    System.out.println(localDate);
    // 获得2014年的第146天
    localDate = LocalDate.ofYearDay(2014, 146);
    System.out.println(localDate); // 2014-05-26
    // 设置为2014年5月21日
    localDate = LocalDate.of(2014, Month.MAY, 21);
    System.out.println(localDate); // 2014-05-21
    // -----下面是关于LocalTime的用法-----
    // 获取当前时间
    LocalTime localTime = LocalTime.now();
    // 设置为22点33分
    localTime = LocalTime.of(22, 33);
    System.out.println(localTime); // 22:33
    // 返回一天中的第5503秒
    localTime = LocalTime.ofSecondOfDay(5503);
    System.out.println(localTime); // 01:31:43
    // -----下面是关于localDateTime的用法-----
    // 获取当前日期、时间
    LocalDateTime localDateTime = LocalDateTime.now();
    // 当前日期、时间加上25小时３分钟
    LocalDateTime future = localDateTime.plusHours(25).plusMinutes(3);
    System.out.println("当前日期、时间的25小时3分之后：" + future);
    // 下面是关于Year、YearMonth、MonthDay的用法示例-----
    Year year = Year.now(); // 获取当前的年份
    System.out.println("当前年份：" + year); // 输出当前年份
    year = year.plusYears(5); // 当前年份再加5年
    System.out.println("当前年份再过5年：" + year);
    // 根据指定月份获取YearMonth
    YearMonth ym = year.atMonth(10);
    System.out.println("year年10月：" + ym); // 输出XXXX-10，XXXX代表当前年份
    // 当前年月再加5年，减3个月
    ym = ym.plusYears(5).minusMonths(3);
    System.out.println("year年10月再加5年、减3个月：" + ym);
    MonthDay md = MonthDay.now();
    System.out.println("当前月日：" + md); // 输出--XX-XX，代表几月几日
    // 设置为5月23日
    MonthDay md2 = md.with(Month.MAY).withDayOfMonth(23);
    System.out.println("5月23日为：" + md2); // 输出--05-23
}

}