java常用的API常用方法

常用的方法

public static int abs(int a)                   // 返回参数的绝对值
public static double ceil(double a)               // 返回大于或等于参数的最小整数
public static double floor(double a)           // 返回小于或等于参数的最大整数
public static int round(float a)               // 按照四舍五入返回最接近参数的int类型的值
public static int max(int a,int b)               // 获取两个int值中的较大值
public static int min(int a,int b)               // 获取两个int值中的较小值
public static double pow (double a,double b)   // 计算a的b次幂的值
public static double random()                   // 返回一个[0.0,1.0)的随机值

二、System

System包含了系统操作的一些常用的方法。比如获取当前时间所对应的毫秒值，再比如终止当前JVM等等。

常用的方法

public static long currentTimeMillis() // 获取当前时间所对应的毫秒值（当前时间为0时区所对应的时间即就是英国格林尼治天文台旧址所在位置）
public static void exit(int status) // 终止当前正在运行的Java虚拟机，0表示正常退出，非零表示异常退出
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); // 进行数值元素copy

arraycopy方法方法参数说明：

// src: 源数组
// srcPos：源数值的开始位置
// dest：目标数组
// destPos：目标数组开始位置
// length: 要复制的元素个数
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

三、Runtime

Runtime表示Java中运行时对象，可以获取到程序运行时设计到的一些信息

常用的方法

public static Runtime getRuntime()       //当前系统的运行环境对象
public void exit(int status)           //停止虚拟机
public int availableProcessors()       //获得CPU的线程数
public long maxMemory()               //JVM能从系统中获取总内存大小（单位byte）
public long totalMemory()               //JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory()               //JVM剩余内存大小（单位byte）
public Process exec(String command)    //运行cmd命令

代码示例

public class RunTimeDemo1 {
    public static void main(String[] args) throws IOException {
        /*
            public static Runtime getRuntime() 当前系统的运行环境对象
            public void exit(int status) 停止虚拟机
            public int availableProcessors() 获得CPU的线程数
            public long maxMemory() JVM能从系统中获取总内存大小(单位byte)
            public long totalMemory() JVM已经从系统中获取总内存大小(单位byte)
            public long freeMemory() JVM剩余内存大小(单位byte)
            public Process exec(string command) 运行cmd命令
        */

        //1.获取Runtime的对象
        //Runtime r1 =Runtime.getRuntime();

        //2.exit 停止虚拟机
        //Runtime.getRuntime().exit(0);
        //System.out.println("看看我执行了吗?");


        //3.获得CPU的线程数
        System.out.println(Runtime.getRuntime().availableProcessors());//8
        //4.总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);//4064
        //5.已经获取的总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);//254
        //6.剩余内存大小
        System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);//251

        //7.运行cmd命令
        //shutdown :关机
        //加上参数才能执行
        //-s :默认在1分钟之后关机
        //-s -t 指定时间 : 指定关机时间
        //-a :取消关机操作
        //-r: 关机并重启
        Runtime.getRuntime().exec("shutdown -s -t 3600");
    }
}

四、Object

Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类；换句话说，该类所具备的方法，其他所有类都继承了。

常用的方法

public String toString()               //返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj)       //比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone()             //对象克隆

深克隆和浅克隆（对象克隆分类）

浅克隆：

不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来

基本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。

Object类默认的是浅克隆

深克隆：

基本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的

克隆代码

public class ObjectDemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        // protected object clone(int a) 对象克隆 

        //1.先创建一个对象
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};
        User u1 = new User(1, "zhangsan", "1234qwer", "girl11", data);

        //2.克隆对象
        //细节:
        //方法在底层会帮我们创建一个对象,并把原对象中的数据拷贝过去。
        //书写细节:
        //1.重写Object中的clone方法
        //2.让javabean类实现Cloneable接口
        //3.创建原对象并调用clone就可以了
        //User u2 =(User)u1.clone();

        //验证一件事情：Object中的克隆是浅克隆
        //想要进行深克隆，就需要重写clone方法并修改里面的方法体
        //int[] arr = u1.getData();
        //arr[0] = 100;

        //System.out.println(u1);
        //System.out.println(u2);


        //以后一般会用第三方工具进行克隆
        //1.第三方写的代码导入到项目中
        //2.编写代码
        //Gson gson =new Gson();
        //把对象变成一个字符串
        //String s=gson.toJson(u1);
        //再把字符串变回对象就可以了
        //User user =gson.fromJson(s, User.class);

        //int[] arr=u1.getData();
        //arr[0] = 100;

        //打印对象
        //System.out.println(user);

    }
}

package com.itheima.a04objectdemo;

import java.util.StringJoiner;



//Cloneable
//如果一个接口里面没有抽象方法
//表示当前的接口是一个标记性接口
//现在Cloneable表示一旦实现了，那么当前类的对象就可以被克降
//如果没有实现，当前类的对象就不能克隆
public class User implements Cloneable {
    private int id;
    private String username;
    private String password;
    private String path;
    private int[] data;




    public User() {
    }

    public User(int id, String username, String password, String path, int[] data) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.path = path;
        this.data = data;
    }

    /**
     * 获取
     *
     * @return id
     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     *
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     *
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * 设置
     *
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 获取
     *
     * @return password
     */
    public String getPassword() {
        return password;
    }

    /**
     * 设置
     *
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 获取
     *
     * @return path
     */
    public String getPath() {
        return path;
    }

    /**
     * 设置
     *
     * @param path
     */
    public void setPath(String path) {
        this.path = path;
    }

    /**
     * 获取
     *
     * @return data
     */
    public int[] getData() {
        return data;
    }

    /**
     * 设置
     *
     * @param data
     */
    public void setData(int[] data) {
        this.data = data;
    }

    public String toString() {
        return "角色编号为：" + id + "，用户名为：" + username + "密码为：" + password + ", 游戏图片为:" + path + ", 进度:" + arrToString();
    }


    public String arrToString() {
        StringJoiner sj = new StringJoiner(", ", "[", "]");

        for (int i = 0; i < data.length; i++) {
            sj.add(data[i] + "");
        }
        return sj.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类中的clone方法
        //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。

        //先把被克隆对象中的数组获取出来
        int[] data = this.data;
        //创建新的数组
        int[] newData =new int[data.length];
        //拷贝数组中的数据
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //调用父类中的方法克隆对象
            User u=(User)super.clone();
        //因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
        u.data =newData;
        return u;
    }
}

五、Objects

Objects类提供了一些对象常见操作的方法。比如判断对象是否相等，判断对象是否为null等等。

常用方法

public static String toString(Object o)                    // 获取对象的字符串表现形式
public static boolean equals(Object a, Object b)           // 比较两个对象是否相等
public static boolean isNull(Object obj)                   // 判断对象是否为null
public static boolean nonNull(Object obj)                   // 判断对象是否不为null

了解

public static <T> T requireNonNull(T obj) // 检查对象是否不为null,如果为null直接抛出异常；如果不是null返回该对象；
public static <T> T requireNonNullElse(T obj, T defaultObj) // 检查对象是否不为null，如果不为null，返回该对象；如果为null返回defaultObj值
public static <T> T requireNonNullElseGet(T obj, Supplier<? extends T> supplier) // 检查对象是否不为null，如果不为null，返回该对象；如果 // 为null,返回由Supplier所提供的值

六、BigInteger

这个类的由来

平时在存储整数的时候，Java中默认是int类型，int类型有取值范围：-2147483648 ~ 2147483647。如果数字过大，我们可以使用long类型，但是如果long类型也表示不下怎么办呢？

就需要用到BigInteger，可以理解为：大的整数。

有多大呢？理论上最大到42亿的21亿次方

基本上在内存撑爆之前，都无法达到这个上限。

获得BigInteger对象方法

public BigInteger(int num, Random rnd)        //获取随机大整数，范围：[0 ~ 2的num次方-1]
public BigInteger(String val)                //获取指定的大整数
public BigInteger(String val, int radix)    //获取指定进制的大整数
public static BigInteger valueOf(long val)    //静态方法获取BigInteger的对象，内部有优化

常用方法

public BigInteger add(BigInteger val)                   //加法
public BigInteger subtract(BigInteger val)               //减法
public BigInteger multiply(BigInteger val)               //乘法
public BigInteger divide(BigInteger val)               //除法
public BigInteger[] divideAndRemainder(BigInteger val)   //除法，获取商和余数
public boolean equals(Object x)                    //比较是否相同
public BigInteger pow(int exponent)                    //次幂、次方
public BigInteger max/min(BigInteger val)                //返回较大值/较小值
public int intValue(BigInteger val)                    //转为int类型整数，超出范围数据有误

底层存储方式

对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。

数组中最多能存储元素个数：21亿多

数组中每一位能表示的数字：42亿多

理论上，BigInteger能表示的最大数字为：42亿的21亿次方。

但是还没到这个数字，电脑的内存就会撑爆，所以一般认为BigInteger是无限的。

存储方式如图所示：

七、BigDecimal

引入

这样的结果其实就是一个丢失精度的结果。为什么会产生精度丢失呢？

在使用float或者double类型的数据在进行数学运算的时候，很有可能会产生精度丢失问题。我们都知道计算机底层在进行运算的时候，使用的都是二进制数据；当我们在程序中写了一个十进制数据，

在进行运算的时候，计算机会将这个十进制数据转换成二进制数据，然后再进行运算，计算完毕以后计算机会把运算的结果再转换成十进制数据给我们展示；如果我们使用的是整数类型的数据进行计算，

那么在把十进制数据转换成二进制数据的时候不会存在精度问题；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的

趋近于这个十进数的二进制数据；这样使用一个不太准确的数据进行运算的时候，最终就会造成精度丢失；为了提高精度，Java就给我们提供了BigDecimal供我们进行数据运算。

常用的构造方法

常用的方法

public BigDecimal add(BigDecimal value)               // 加法运算
public BigDecimal subtract(BigDecimal value)       // 减法运算
public BigDecimal multiply(BigDecimal value)       // 乘法运算
public BigDecimal divide(BigDecimal value)           // 除法运算

除法的特殊情况

解决方案

针对这个问题怎么解决，此时我们就需要使用到BigDecimal类中另外一个divide方法，如下所示：
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

上述divide方法参数说明：

divisor:            除数对应的BigDecimal对象；
scale:              精确的位数；
roundingMode:       取舍模式；
取舍模式被封装到了RoundingMode这个枚举类中（关于枚举我们后期再做重点讲解），在这个枚举类中定义了很多种取舍方式。最常见的取舍方式有如下几个：
UP(直接进1) ， FLOOR(直接删除) ， HALF_UP(4舍五入),我们可以通过如下格式直接访问这些取舍模式：枚举类名.变量名

改后的代码

public class BigDecimalDemo02 {

    public static void main(String[] args) {

        // 调用方法
        method_03() ;

    }

    // 演示取舍模式HALF_UP
    public static void method_03() {

        // 创建两个BigDecimal对象
        BigDecimal b1 = new BigDecimal("0.3") ;
        BigDecimal b2 = new BigDecimal("4") ;

        // 调用方法进行b1和b2的除法运算，并且将计算结果在控制台进行输出
        System.out.println(b1.divide(b2 , 2 , RoundingMode.HALF_UP));

    }

    // 演示取舍模式FLOOR
    public static void method_02() {

        // 创建两个BigDecimal对象
        BigDecimal b1 = new BigDecimal("1") ;
        BigDecimal b2 = new BigDecimal("3") ;

        // 调用方法进行b1和b2的除法运算，并且将计算结果在控制台进行输出
        System.out.println(b1.divide(b2 , 2 , RoundingMode.FLOOR));

    }

    // 演示取舍模式UP
    public static void method_01() {

        // 创建两个BigDecimal对象
        BigDecimal b1 = new BigDecimal("1") ;
        BigDecimal b2 = new BigDecimal("3") ;

        // 调用方法进行b1和b2的除法运算，并且将计算结果在控制台进行输出
        System.out.println(b1.divide(b2 , 2 , RoundingMode.UP));

    }

}

底层存储方式

把数据看成字符串，遍历得到里面的每一个字符，把这些字符在ASCII码表上的值，都存储到数组中。

八、Date

java.util.Date`类表示特定的瞬间，精确到毫秒。

常用的构造方法

public Date()：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

public Date(long date)：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

tips: 由于中国处于东八区（GMT+08:00）是比世界协调时间/格林尼治时间（GMT）快8小时的时区，当格林尼治标准时间为0:00时，东八区的标准时间为08:00。

测试

public class Main {
    public static void main(String[] args) throws IOException {
        Date date1 = new Date();
        System.out.println(date1);//Sun Aug 11 17:25:36 CST 2024
        Date date2 = new Date(8000);
        System.out.println(date2);//Thu Jan 01 08:00:08 CST 1970
    }
}

常用的方法

public long getTime() 把日期对象转换成对应的时间毫秒值。

public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象

测试

public class Main {
    public static void main(String[] args) throws IOException {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);//1723368553138
        date.setTime(8000);
        System.out.println(date);//Thu Jan 01 08:00:08 CST 1970
    }
}

九、SimpleDateFormat

java.text.SimpleDateFormat 是日期/时间格式化类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

构造方法

public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。

pattern日期格式

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档。

常用方法

public String format(Date date)：将Date对象格式化为字符串。

public Date parse(String source)：将字符串解析为Date对象。

测试

public class A03_SimpleDateFormatDemo1 {
    public static void main(String[] args) throws ParseException {
        /*
            public simpleDateFormat() 默认格式
            public simpleDateFormat(String pattern) 指定格式
            public final string format(Date date) 格式化(日期对象 ->字符串)
            public Date parse(string source) 解析(字符串 ->日期对象)
        */

        //1.定义一个字符串表示时间
        String str = "2023-11-11 11:11:11";
        //2.利用空参构造创建simpleDateFormat对象
        // 细节:
        //创建对象的格式要跟字符串的格式完全一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(str);
        //3.打印结果
        System.out.println(date.getTime());//1699672271000


    }

    private static void method1() {
        //1.利用空参构造创建simpleDateFormat对象，默认格式
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        Date d1 = new Date(0L);
        String str1 = sdf1.format(d1);
        System.out.println(str1);//1970/1/1 上午8:00

        //2.利用带参构造创建simpleDateFormat对象，指定格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        String str2 = sdf2.format(d1);
        System.out.println(str2);//1970年01月01日 08:00:00

        //课堂练习:yyyy年MM月dd日 时:分:秒 星期
    }
}

十、Calendar

java.util.Calendar类表示一个“日历类”，可以进行日期运算。它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。

常用方法

测试

// 获取当前日期
Calendar calendar = Calendar.getInstance();

// 输出当前日期
System.out.println("当前日期: " + calendar.getTime());//当前日期: Sun Aug 11 18:08:43 CST 2024

// 获取年、月、日
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1; // +1 因为月份从0开始
int day = calendar.get(Calendar.DAY_OF_MONTH);

System.out.println("年: " + year + ", 月: " + month + ", 日: " + day);//年: 2024, 月: 8, 日: 11

// 设置日期
calendar.set(2023, Calendar.OCTOBER, 15);
System.out.println("设置后的日期: " + calendar.getTime());//设置后的日期: Sun Oct 15 18:08:43 CST 2023

// 加5天
calendar.add(Calendar.DAY_OF_MONTH, 5);
System.out.println("加5天后的日期: " + calendar.getTime());//加5天后的日期: Fri Oct 20 18:08:43 CST 2023

// 格式化日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String formattedDate = sdf.format(calendar.getTime());
System.out.println("格式化后的日期: " + formattedDate);//格式化后的日期: 2023-10-20

十一、JDK8时间相关类

ZoneId时区

/*
        static Set<string> getAvailableZoneIds() 获取Java中支持的所有时区
        static ZoneId systemDefault() 获取系统默认时区
        static Zoneld of(string zoneld) 获取一个指定时区
        */

//1.获取所有的时区名称
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds.size());//600
System.out.println(zoneIds);// Asia/Shanghai

//2.获取当前系统的默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId);//Asia/Shanghai

//3.获取指定的时区
ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
System.out.println(zoneId1);//Asia/Pontianak

Instant 时间戳

/*
            static Instant now() 获取当前时间的Instant对象(标准时间)
            static Instant ofXxxx(long epochMilli) 根据(秒/毫秒/纳秒)获取Instant对象
            ZonedDateTime atZone(ZoneIdzone) 指定时区
            boolean isxxx(Instant otherInstant) 判断系列的方法
            Instant minusXxx(long millisToSubtract) 减少时间系列的方法
            Instant plusXxx(long millisToSubtract) 增加时间系列的方法
        */
//1.获取当前时间的Instant对象(标准时间)
Instant now = Instant.now();
System.out.println(now);//2024-08-11T10:16:45.269211300Z

//2.根据(秒/毫秒/纳秒)获取Instant对象
Instant instant1 = Instant.ofEpochMilli(0L);
System.out.println(instant1);//1970-01-01T00:00:00z

Instant instant2 = Instant.ofEpochSecond(1L);
System.out.println(instant2);//1970-01-01T00:00:01Z

Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
System.out.println(instant3);//1970-01-01T00:00:027

//3. 指定时区
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);//2024-08-11T18:20:22.454647100+08:00[Asia/Shanghai]


//4.isXxx 判断
Instant instant4=Instant.ofEpochMilli(0L);
Instant instant5 =Instant.ofEpochMilli(1000L);

//5.用于时间的判断
//isBefore:判断调用者代表的时间是否在参数表示时间的前面
boolean result1=instant4.isBefore(instant5);
System.out.println(result1);//true

//isAfter:判断调用者代表的时间是否在参数表示时间的后面
boolean result2 = instant4.isAfter(instant5);
System.out.println(result2);//false

//6.Instant minusXxx(long millisToSubtract) 减少时间系列的方法
Instant instant6 =Instant.ofEpochMilli(3000L);
System.out.println(instant6);//1970-01-01T00:00:03Z

Instant instant7 =instant6.minusSeconds(1);
System.out.println(instant7);//1970-01-01T00:00:02Z

ZoneDateTime 带时区的时间

/*
    static ZonedDateTime now() 获取当前时间的ZonedDateTime对象
    static ZonedDateTime ofXxxx(。。。) 获取指定时间的ZonedDateTime对象
    ZonedDateTime withXxx(时间) 修改时间系列的方法
    ZonedDateTime minusXxx(时间) 减少时间系列的方法
    ZonedDateTime plusXxx(时间) 增加时间系列的方法
 */
//1.获取当前时间对象(带时区)
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);//2024-08-11T18:21:39.598205300+08:00[Asia/Shanghai]

//2.获取指定的时间对象(带时区)1/年月日时分秒纳秒方式指定
ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
        11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));
System.out.println(time1);//2023-10-01T11:12:12+08:00[Asia/Shanghai]

//通过Instant + 时区的方式指定获取时间对象
Instant instant = Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);//1970-01-01T08:00+08:00[Asia/Shanghai]


//3.withXxx 修改时间系列的方法
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);//2000-01-01T08:00+08:00[Asia/Shanghai]

//4. 减少时间
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);//1999-01-01T08:00+08:00[Asia/Shanghai]

//5.增加时间
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);//2000-01-01T08:00+08:00[Asia/Shanghai]

DateTimeFormatter 用于时间的格式化和解析

/*
    static DateTimeFormatter ofPattern(格式) 获取格式对象
    String format(时间对象) 按照指定方式格式化
*/
//获取时间对象
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));

// 解析/格式化器
DateTimeFormatter dtf1= DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm;ss EE a");
// 格式化
System.out.println(dtf1.format(time));//2024-08-11 18:24;08 周日 下午

LocalDate 年、月、日

//1.获取当前时间的日历对象(包含 年月日)
LocalDate nowDate = LocalDate.now();
//System.out.println("今天的日期:" + nowDate);
//2.获取指定的时间的日历对象
LocalDate ldDate = LocalDate.of(2023, 1, 1);
System.out.println("指定日期:" + ldDate);//指定日期:2023-01-01

System.out.println("=============================");

//3.get系列方法获取日历中的每一个属性值//获取年
int year = ldDate.getYear();
System.out.println("year: " + year);//year: 2023
//获取月//方式一:
Month m = ldDate.getMonth();
System.out.println(m);//JANUARY
System.out.println(m.getValue());//1

//方式二:
int month = ldDate.getMonthValue();
System.out.println("month: " + month);//month: 1


//获取日
int day = ldDate.getDayOfMonth();
System.out.println("day:" + day);//day: 1

//获取一年的第几天
int dayofYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayofYear);//dayOfYear: 1

//获取星期
DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
System.out.println(dayOfWeek);//SUNDAY
System.out.println(dayOfWeek.getValue());//7

//is开头的方法表示判断
System.out.println(ldDate.isBefore(ldDate));//false
System.out.println(ldDate.isAfter(ldDate));//false

//with开头的方法表示修改，只能修改年月日
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);//2000-01-01

//minus开头的方法表示减少，只能减少年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);//2022-01-01


//plus开头的方法表示增加，只能增加年月日
LocalDate plusLocalDate = ldDate.plusDays(1);
System.out.println(plusLocalDate);//2023-01-02

//-------------
// 判断今天是否是你的生日
LocalDate birDate = LocalDate.of(2000, 1, 1);
LocalDate nowDate1 = LocalDate.now();

MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
MonthDay nowMd = MonthDay.from(nowDate1);

System.out.println("今天是你的生日吗? " + birMd.equals(nowMd));//今天是你的生日吗? false

LocalDateTime 年、月、日、时、分、秒

// 当前时间的的日历对象(包含年月日时分秒)
LocalDateTime nowDateTime = LocalDateTime.now();

System.out.println("今天是:" + nowDateTime);//今天是:2024-08-11T18:30:40.499228
System.out.println(nowDateTime.getYear());//2024年
System.out.println(nowDateTime.getMonthValue());//8月
System.out.println(nowDateTime.getDayOfMonth());//11日
System.out.println(nowDateTime.getHour());//18时
System.out.println(nowDateTime.getMinute());//30分
System.out.println(nowDateTime.getSecond());//40秒
System.out.println(nowDateTime.getNano());//499228000纳秒
// 日:当年的第几天
System.out.println("dayofYear:" + nowDateTime.getDayOfYear());//dayofYear:224
//星期
System.out.println(nowDateTime.getDayOfWeek());//SUNDAY
System.out.println(nowDateTime.getDayOfWeek().getValue());//7
//月份
System.out.println(nowDateTime.getMonth());//AUGUST
System.out.println(nowDateTime.getMonth().getValue());//8

LocalDate ld = nowDateTime.toLocalDate();
System.out.println(ld);//2024-08-11

LocalTime lt = nowDateTime.toLocalTime();
System.out.println(lt.getHour());//10
System.out.println(lt.getMinute());//30
System.out.println(lt.getSecond());//40

Duration 时间间隔（秒，纳，秒）

// 本地日期时间对象。
LocalDateTime today = LocalDateTime.now();
System.out.println(today);//2024-08-11T18:34:48.883091200

// 出生的日期时间对象
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);//2000-01-01T00:00

Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:" + duration);//相差的时间间隔对象:PT215754H34M48.8830912S

System.out.println("============================================");
System.out.println(duration.toDays());//两个时间差的天数8989
System.out.println(duration.toHours());//两个时间差的小时数215754
System.out.println(duration.toMinutes());//两个时间差的分钟数12945274
System.out.println(duration.toMillis());//两个时间差的毫秒数776716488883
System.out.println(duration.toNanos());//两个时间差的纳秒数776716488883091200

Period 时间间隔（年，月，日）

// 当前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);//2024-08-11

// 生日的 年月日
LocalDate birthDate = LocalDate.of(2000, 1, 1);
System.out.println(birthDate);//2000-01-01

Period period = Period.between(birthDate, today);//第二个参数减第一个参数

System.out.println("相差的时间间隔对象:" + period);//相差的时间间隔对象:P24Y7M10D
System.out.println(period.getYears());//24
System.out.println(period.getMonths());//7
System.out.println(period.getDays());//10

System.out.println(period.toTotalMonths());//295

ChronoUnit 时间间隔（所有单位）

// 当前时间
LocalDateTime today = LocalDateTime.now();
System.out.println(today);//2024-08-11T18:38:36.245785800
// 生日时间
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1,0, 0, 0);
System.out.println(birthDate);//2000-01-01T00:00

System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate, today));//相差的年数:24
System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));//相差的月数:295
System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(birthDate, today));//相差的周数:1284
System.out.println("相差的天数:" + ChronoUnit.DAYS.between(birthDate, today));//相差的天数:8989
System.out.println("相差的时数:" + ChronoUnit.HOURS.between(birthDate, today));//相差的时数:215754
System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(birthDate, today));//相差的分数:12945278
System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(birthDate, today));//相差的秒数:776716716
System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(birthDate, today));//相差的毫秒数:776716716245
System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(birthDate, today));//相差的微秒数:776716716245785
System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(birthDate, today));//相差的纳秒数:776716716245785800
System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(birthDate, today));//相差的半天数:17979
System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(birthDate, today));//相差的十年数:2
System.out.println("相差的世纪(百年)数:" + ChronoUnit.CENTURIES.between(birthDate, today));//相差的世纪(百年)数:0
System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(birthDate, today));//相差的千年数:0
System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(birthDate, today));//相差的纪元数:0