Date类：

1.1、将字符串型时间日期转化为date类型

        String timeString = "2023-11-17 09:27:00";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //创建"简单时间格式化"对象,格式为：yyyy-MM-dd HH:mm:ss
        try {
            Date time = sdf.parse(timeString);  //将字符串(timeString)通过简单时间格式化工具(sdf)解析(parse)为date类型
            System.out.println(time);   //控制台：Fri Nov 17 09:27:00 CST 2023   直接输出Date型数据显示的是CST时间,所以看不太懂
            System.out.println(sdf.format(time));  //控制台：2023-11-17 09:27:00   再将Date数据格式化后输出,就变成yyyy-MM-dd HH:mm:ss格式了
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }

1.2、将时间戳转化为date类型

        long sjc = 1700185034000L;  //时间戳,时间的唯一值;尾巴加L是把这个值转换为long类型,因为时间戳的数值范围太大了,不转会异常
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //创建"简单时间格式化"对象,格式为：yyyy-MM-dd HH:mm:ss
        String time = sdf.format(sjc);  //将时间戳(sjc)通过简单时间格式化工具(sdf)格式化(format)为字符串型时间日期
        System.out.println(time);  //控制台：2023-11-17 09:37:14
        try {
            Date DateTime = sdf.parse(time);  //再将字符串型时间日期(time)通过简单时间格式化工具(sdf)解析(parse)为date类型
            System.out.println(DateTime);  //输出Date数据(显示的是CST时间),控制台：Fri Nov 17 09:37:14 CST 2023
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }

1.3、将字符串转化为时间戳

        String timeString = "2023-11-17 09:27:00";  //定义字符串型时间日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //创建"简单时间格式化"对象,格式为：yyyy-MM-dd HH:mm:ss
        try {
            Date timeDate = sdf.parse(timeString);  //字符串型时间日期(timeString)通过简单时间格式化工具(sdf)解析(parse)为date类型
            long sjc = timeDate.getTime();  //将date型时间日期(timeDate)通过getTime()方法转换为时间戳并用long类型接收
            System.out.println(sjc / 1000);  //控制台：1700184420;因为时间戳是精确到毫秒集的,输出时间戳时除以1000是精确到秒集就够了,因为1s(秒)=1000ms(毫秒)
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }

1.4、比较两个时间日期(两种方法)

方法1：日期1.before(日期2)，判断日期1是否在日期2之前的意思，返回值为boolean;

方法2：日期1.after(日期2)，判断日期1是否在日期2之后的意思，返回值为boolean;

        String timeString1 = "2023-11-17 09:27:00";  //定义字符串型时间日期1
        String timeString2 = "2024-11-17 09:27:00";  //定义字符串型时间日期2
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //创建"简单时间格式化"对象,格式为：yyyy-MM-dd HH:mm:ss
        try {
            Date time1 = sdf.parse(timeString1);  //将字符串型时间日期(timeString1)通过简单时间格式化工具(sdf)解析(parse)为date类型
            Date time2 = sdf.parse(timeString2);  //将字符串型时间日期(timeString2)通过简单时间格式化工具(sdf)解析(parse)为date类型
            boolean before = time1.before(time2);  //指定日期(time1)在参数日期(time2)之前返回true,反之返回false
            boolean after = time1.after(time2);    //指定日期(time1)在参数日期(time2)之后返回true,反之返回false
            System.out.println("日期1：" + timeString1 + "\n日期2：" + timeString2 + "\n日期1在日期2之前：" + before + "\n日期1在日期2之后：" + after);
            /* 控制台：日期1：2023-11-17 09:27:00
                      日期2：2024-11-17 09:27:00
                      日期1在日期2之前：true
                      日期1在日期2之后：false */
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }

Calendar(日历对象)类：

2.1、为日历对象定义一个指定日期的数据

        Calendar calendar = Calendar.getInstance();  //获取一个日历对象(calendar)
        calendar.set(Calendar.YEAR, 2023);  //给日历对象的年份赋值
        calendar.set(Calendar.MONTH, 11-1);  //给日历对象的月份赋值; 注：月份赋值时要减1,具体原因当时我也不是很清楚,可能是下标吧(例如月份给定11月,那么值就应填10)
        calendar.set(Calendar.DAY_OF_MONTH, 17);  //给日历对象的号数赋值
        //注：未赋值的单位(例如：时,分,秒)默认为当前时间;也可使用set()方法一次性给定所有值(年-月-日 时:分:秒)：calendar.set(2023,11,17,9,30,0);
 
        //将日历对象(calendar)通过getTime()方法转换为Date类型并输出,Date类型输出的是CST时间
        System.out.println(calendar.getTime());  //控制台：Fri Nov 17 22:16:41 CST 2023
 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //创建"简单时间格式"化对象,格式为：yyyy-MM-dd HH:mm:ss
 
        //将Date型数据(calendar.getTime())通过简单时间格式化工具(sdf)格式化(format)为字符串后输出
        System.out.println(sdf.format(calendar.getTime()));  //控制台：2023-11-17 22:16:41

2.2、为日历对象添加或减去年、月、日、周

        Calendar calendar = Calendar.getInstance();  //获取一个日历对象(calendar)
 
        //使用set()方法一次性给定所有值(年-月-日 时:分:秒)  注：月份给定值时要减1,具体原因当时我也不是很清楚,可能是下标吧(例如月份给定11月,那么值就应填10)
        calendar.set(2023,11-1,17,9,30,0);
 
        calendar.add(Calendar.YEAR, 1);  //给日历对象增加1年的时间;减就给参数传负数
        calendar.add(Calendar.MONTH,1);  //给日历对象增加1月的时间;减就给参数传负数
        calendar.add(Calendar.DAY_OF_MONTH, 1);  //给日历对象增加1天的时间;减就给参数传负数
        calendar.add(Calendar.WEEK_OF_MONTH, 1);  //给日历对象增加1周的时间;减就给参数传负数
 
        //将日历对象(calendar)通过getTime()方法转换为Date类型并输出,Date类型输出的是CST时间
        System.out.println(calendar.getTime());  //控制台：Wed Dec 25 09:30:00 CST 2024
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //创建"简单时间格式化"对象,格式为：yyyy-MM-dd HH:mm:ss
 
        //将Date型数据(calendar.getTime())通过简单时间格式化工具(sdf)格式化(format)为字符串后输出
        System.out.println(sdf.format(calendar.getTime()));  //控制台：2024-12-25 09:30:00

2.3、获取日历对象的年、月、日、时、分、秒、周

        Calendar calendar = Calendar.getInstance();  //获取一个日历对象(calendar)
 
        //使用set()方法一次性给定所有值(年-月-日 时:分:秒)  注：月份给定值时要减1,具体原因当时我也不是很清楚,可能是下标吧(例如月份给定11月,那么值就应填10)
        calendar.set(2023,11-1,17,9,30,0);
 
        int year = calendar.get(Calendar.YEAR);         //获取年份
        int month = calendar.get(Calendar.MONTH);       //获取月份
        int day = calendar.get(Calendar.DAY_OF_MONTH);  //获取当天是本月当中的第几天(获取号数)
        int hour = calendar.get(Calendar.HOUR);         //获取时
        int minute = calendar.get(Calendar.MINUTE) ;    //获取分
        int second = calendar.get(Calendar.SECOND);     //获取秒
        int week = calendar.get(Calendar.WEEK_OF_YEAR); //获取当前是今年的第几周
        
        System.out.println("年份：" + year + "\n月份：" + month + "\n号数：" + day + "\n时：" + hour + "\n分：" + minute + "\n秒：" + second + "\n本周是今年的第" + week + "周");

控制台：

2.4、将日历对象转化为时间戳(两种方法)、获取当前时间的时区

        Calendar calendar = Calendar.getInstance();  //获取一个日历对象(calendar)
 
        //使用set()方法一次性给定所有值(年-月-日 时:分:秒)  注：月份给定值时要减1,具体原因当时我也不是很清楚,可能是下标吧(例如月份给定11月,那么值就应填10)
        calendar.set(2023,11-1,17,9,30,0);
        
        //方法一(通过getTimeInMillis()方法获取)：
        long timeInMillis = calendar.getTimeInMillis() / 1000;  //因为时间戳是精确到毫秒集的,得到时间戳时除以1000是精确到秒集就够了,因为1s(秒)=1000ms(毫秒)
        System.out.println("Calendar类的getTimeInMillis()方法获取的时间戳："+timeInMillis);
        
        //方法二(先将日历对象转换为Date数据,再调用Date类的方法获取时间戳)：
        Date date = calendar.getTime();  //将日历对象(calendar)通过Calendar类的getTime()方法转换为Date数据
        long timeInMillisDate = date.getTime() / 1000;  //调用Date类的getTime()方法获取时间戳,因为时间戳是精确到毫秒集的,得到时间戳时除以1000是精确到秒集就够了,因为1s(秒)=1000ms(毫秒)
        System.out.println("Date类的getTime()方法获取的时间戳：" + timeInMillisDate);
        //注：方法二可以简化为long timeInMillisDate = calendar.getTime().getTime() / 1000;   第一个getTime()是转Date类型数据,第二个是转时间戳,/1000是毫秒集转秒集
        
        //获取当前时间的时区
        TimeZone timeZone = calendar.getTimeZone();
        System.out.println("当前时间的时区：" + timeZone);

控制台：

2.5、比较两个时间日期(两种方法)

方法1：日期1.before(日期2)，判断日期1是否在日期2之前的意思，返回值为boolean;

方法2：日期1.after(日期2)，判断日期1是否在日期2之后的意思，返回值为boolean;

        Calendar calendar1 = Calendar.getInstance();  //获取日历对象1(calendar1)
        calendar1.set(2023,11-1,17,9,30,0);  //使用set()方法一次性给定所有值(年-月-日 时:分:秒)  注：月份给定值时要减1,具体原因当时我也不是很清楚,可能是下标吧(例如月份给定11月,那么值就应填10)
        
        Calendar calendar2 = Calendar.getInstance();  //获取日历对象2(calendar2)
        calendar2.set(2024,11-1,17,9,30,0);  //使用set()方法一次性给定所有值(年-月-日 时:分:秒)  注：月份给定值时要减1,具体原因当时我也不是很清楚,可能是下标吧(例如月份给定11月,那么值就应填10)
        
        boolean before = calendar1.before(calendar2);  //指定日期(calendar1)在参数日期(calendar2)之前返回true,反之返回false
        boolean after = calendar1.after(calendar2);    //指定日期(calendar1)在参数日期(calendar2)之后返回true,反之返回false
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //创建"简单时间格式化"对象,为了下面将Date数据转字符串输出更好的看懂
        
        String time1 = sdf.format(calendar1.getTime());  //先将日历对象(calendar1)通过getTime()方法转换为Date类型数据,然后将Date数据格式化(format)后用String类型接收
        String time2 = sdf.format(calendar2.getTime());  //先将日历对象(calendar2)通过getTime()方法转换为Date类型数据,然后将Date数据格式化(format)后用String类型接收
        
        System.out.println("日期1：" + time1 + "\n日期2：" + time2 + "\n日期1在日期2之前：" + before + "\n日期1在日期2之后：" + after);

控制台：

LocalDateTime类：

3.1、获取当前时间的三种形式

        LocalDate localDate = LocalDate.now();  //第一种(LocalDate)格式为：yyyy-MM-dd
        System.out.println(localDate);  //控制台：2023-11-18
 
        LocalTime localTime = LocalTime.now();  //第二种(LocalTime)格式为：HH-mm-ss
        System.out.println(localTime);  //控制台：23:02:13.573164400
 
        LocalDateTime localDateTime = LocalDateTime.now();  //第三种(LocalDateTime)格式为：yyyy-MM-ddTHH-mm-ss
        System.out.println(localDateTime);  //控制台：2023-11-18T23:02:13.574161700

3.2、根据指定日期/时间创建对象的三种形式

        LocalDate localDate = LocalDate.of(2023,11,17);  //第一种(LocalDate)格式为：yyyy-MM-dd
        System.out.println(localDate);  //控制台：2023-11-17
 
        LocalTime localTime = LocalTime.of(15,30,10);  //第二种(LocalTime)格式为：HH-mm-ss
        System.out.println(localTime);  //控制台：15:30:10
 
        LocalDateTime localDateTime = LocalDateTime.of(2023,11,17,15,30,10);  //第三种(LocalDateTime)格式为：yyyy-MM-ddTHH-mm-ss
        System.out.println(localDateTime);  //控制台：2023-11-17T15:30:10

3.3、日期时间的加减(两种方式)

对于LocalDate，只有精度大于或等于日的加减,如年、月、日;

对于LocalTime，只有精度小于或等于时的加减,如时、分、秒、纳秒;

对于LocalDateTime，则可以进行任意精度的时间相加减;

        //方式一：
        System.out.println("——————————方式1——————————");
        LocalDateTime localDateTime = LocalDateTime.now();  //获取当前时间
        LocalDateTime plusYearResult = localDateTime.plusYears(1);      //增加1年;减就给参数传负数
        LocalDateTime plusMonthResult = localDateTime.plusMonths(1);    //增加1月;减就给参数传负数
        LocalDateTime plusDayResult = localDateTime.plusDays(1);        //增加1天;减就给参数传负数
        LocalDateTime plusHoursResult = localDateTime.plusHours(1);     //增加1小时;减就给参数传负数
        LocalDateTime plusMinutesResult = localDateTime.plusMinutes(1); //增加1分钟;减就给参数传负数
        LocalDateTime plusSecondResult = localDateTime.plusSeconds(1);  //增加1秒;减就给参数传负数
        System.out.println("当前时间：" + localDateTime + "\n增加1年后的时间：" + plusYearResult +
                "\n增加1月后的时间：" + plusMonthResult + "\n增加1天后的时间：" + plusDayResult +
                "\n增加1小时后的时间：" + plusHoursResult + "\n增加1分钟后的时间：" + plusMinutesResult +
                "\n增加1秒后的时间：" + plusSecondResult);
        
        //方式二：
        System.out.println("\n\n——————————方式2——————————");
        LocalDateTime plusYearResult2 = localDateTime.plus(1, ChronoUnit.YEARS);      //增加1年;减就给参数传负数
        LocalDateTime plusMonthResult2 = localDateTime.plus(1, ChronoUnit.MONTHS);    //增加1月;减就给参数传负数
        LocalDateTime plusDayResult2 = localDateTime.plus(1, ChronoUnit.DAYS);        //增加1天;减就给参数传负数
        LocalDateTime plusHoursResult2 = localDateTime.plus(1, ChronoUnit.HOURS);     //增加1小时;减就给参数传负数
        LocalDateTime plusMinutesResult2 = localDateTime.plus(1, ChronoUnit.MINUTES); //增加1分钟;减就给参数传负数
        LocalDateTime plusSecondResult2 = localDateTime.plus(1, ChronoUnit.SECONDS);  //增加1秒;减就给参数传负数
        System.out.println("当前时间：" + localDateTime + "\n增加1年后的时间：" + plusYearResult2 +
                "\n增加1月后的时间：" + plusMonthResult2 + "\n增加1天后的时间：" + plusDayResult2 +
                "\n增加1小时后的时间：" + plusHoursResult2 + "\n增加1分钟后的时间：" + plusMinutesResult2 +
                "\n增加1秒后的时间：" + plusSecondResult2);

控制台：

3.4、将年、月、日等修改为指定的值,并返回新的日期(时间)对象

其效果与时间日期相加减差不多，如今天是2018-01-13，要想变为2018-01-20有两种方式：

a： localDate.plusDays(7) -> 相加指定的天数

b： localDate.withDayOfYear(20) -> 直接指定到那一天

        LocalDate LocalDate = java.time.LocalDate.now();  //获取当前时间
        LocalDate withDayOfYearResult = LocalDate.withDayOfYear(60);  //在当前时间的基础上,指定到本年当中的第60天,取值范围1-365,366
        LocalDate withDayOfMonthResult = LocalDate.withDayOfMonth(25);//在当前时间的基础上,指定到本月当中的第25天,取值范围1-29,30,31
        LocalDate withYearResult = LocalDate.withYear(2018);     //在当前时间的基础上,直接指定到2018年
        LocalDate withMonthResult = LocalDate.withMonth(12);      //在当前时间的基础上,直接指定到12月,取值范围1-12
        System.out.println("当前时间：" + LocalDate + "\n指定到本年当中的第60天：" + withDayOfYearResult +
                "\n指定到本月当中的第25天：" + withDayOfMonthResult + "\n直接指定年份为2018：" + withYearResult +
                "\n直接指定月份为12月：" + withMonthResult);

控制台：

3.5、获取日期的年、月、日、时、分、秒、周

        LocalDateTime localDateTime = LocalDateTime.now();  //获取当前时间
        int dayOfYear = localDateTime.getDayOfYear();  //获取今天是本年当中的第几天
        int dayOfMonth = localDateTime.getDayOfMonth();  //获取今天是本月当中的第几天
        DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();  //获取今天是本周当中的星期几,返回值为英文单词,例如星期一(Monday);若要输出数字,可以继续.getValue()方法获取
        System.out.println("当前时间：" + localDateTime + "\n今天是本年当中的第" + dayOfYear + "天,本月中的第" + dayOfMonth +
                "天,星期" + dayOfWeek.getValue() + ",今天是" + dayOfWeek);
        
        int year = localDateTime.getYear();  //获取年份
        Month month = localDateTime.getMonth();  //获取当前月份是本年当中的第几月,返回值为英文单词,例如一月(January);若要输出数字,可以继续.getValue()方法获取
        int day = localDateTime.getDayOfMonth();  //获取今天是本月当中的第几天(获取号数)
        int hour = localDateTime.getHour();  //获取时
        int minute = localDateTime.getMinute();  //获取分
        int second = localDateTime.getSecond();  //获取秒
        System.out.println("年：" + year + "\n月：" + month.getValue() + ",本月是" + month + "\n日：" + day + "\n时：" + hour + "\n分：" + minute +
                "\n秒：" + second);

控制台：

3.6、比较两个时间日期(两种方法)

方法1：日期1.before(日期2)，判断日期1是否在日期2之前的意思，返回值为boolean;

方法2：日期1.after(日期2)，判断日期1是否在日期2之后的意思，返回值为boolean;

        LocalDate time1 = LocalDate.of(2023, 11, 17);  //获取指定日期1(time1)
        LocalDate time2 = LocalDate.of(2024, 11, 17);  //获取指定日期2(time2)
        boolean before = time1.isBefore(time2);  //指定日期(time1)在参数日期(time2)之前返回true,反之返回false
        boolean after = time1.isAfter(time2);   //指定日期(time1)在参数日期(time2)之后返回true,反之返回false
        System.out.println("日期1：" + time1 + "\n日期2：" + time2 +
                "\n日期1在日期2之前：" + before + "\n日期1在日期2之后：" + after);

控制台：

3.7、计算时间、日期间隔

        //计算两个日期的间隔————年月日：
        LocalDate time1 = LocalDate.of(2023, 11, 17);  //获取指定日期1(time1)
        LocalDate time2 = LocalDate.of(2024, 12, 18);  //获取指定日期2(time2)
        Period period = Period.between(time1,time2);  //创建时期Period类并调用间隔范围between()方法,内部结构是后减前(time2-time1)
        System.out.println("日期1：" + time1 + "\n日期2：" + time2 + "\n相差年数：" + period.getYears() + "\n相差月数：" + period.getMonths() + "\n相差日数：" + period.getDays());
        //还可以这样获取相差的年月日
        System.out.println("————————————————");
        int year = (int) period.get(ChronoUnit.YEARS);  //获取间隔中的年份
        int month = (int) period.get(ChronoUnit.MONTHS);  //获取间隔中的月份
        int day = (int) period.get(ChronoUnit.DAYS);  //获取间隔中的天数
        System.out.println("日期1：" + time1 + "\n日期2：" + time2 + "\n相差年数：" + year + "\n相差月数：" + month + "\n相差日数：" + day);
        //注意：当获取两个日期的间隔时,并不是单纯的年月日对应的数字相加减,而是会先算出具体差多少天,在折算成相差几年几月几日的
        
        //计算两个时间的间隔————天时分秒：
        LocalDateTime date1 = LocalDateTime.of(2023, 11, 17, 20, 30, 10);  //获取指定日期1(date1)
        LocalDateTime date2 = LocalDateTime.of(2023, 11, 20, 23, 40, 30);  //获取指定日期2(date2)
        Duration duration = Duration.between(date1, date2);  //创建时间Duration类并调用间隔范围between()方法,内部结构是后减前(date2-date1)
        System.out.println(date1 + " 与 " + date2 + " 各项单位间隔如下：  " + "\n"
                + "天:" + duration.toDays() + "\n"
                + "时:" + duration.toHours() + "\n"
                + "分:" + duration.toMinutes() + "\n"
                + "毫秒:" + duration.toMillis() + "\n"
                + "纳秒:" + duration.toNanos() + "\n"
        );
        //注意：并没有获得秒差的,但既然可以获得毫秒,秒就可以自行获取了：1s(秒)=1000ms(毫秒) 可以拿毫秒差除以1000得到秒差

控制台：

3.8、当计算程序的运行时间时,应当使用时间戳Instant

        Instant instant1 = Instant.now();  //记录程序开始的时间
        for (int i = 0; i < 1000000000; i++) {
            //循环10亿次
        }
        Instant instant2 = Instant.now();  //记录程序结束的时间
        Duration duration = Duration.between(instant1, instant2);  //创建时间Duration类并调用间隔范围between()方法,内部结构是后减前(instant2-instant1)
        System.out.println("程序运行耗时为：" + duration.toNanos() + "纳秒");  //本次的控制台结果：程序运行耗时为：3989300纳秒

3.9、使用自定义时间日期格式

注：自定义转化的格式一定要与日期类型对应

1、LocalDate类型数据只能设置仅含年月日的格式

2、LocalTime类型数据只能设置仅含时分秒的格式

3、LocalDateTime类型数据可以设置含年月日时分秒的格式

        LocalDateTime localDateTime = LocalDateTime.now();  //获取当前时间
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");  //创建"时间格式器(DateTimeFormatter)"对象,格式为：yyyy年MM月dd日 HH:mm:ss
        String timeString = dtf.format(localDateTime);  //时间日期(localDateTime)格式化(format)后用String类型接收
        System.out.println(timeString);  //控制台：2023年11月18日 23:19:55

4.0、将字符串形式的时间日期转化为日期对象

        String timeString = "2023-11-17 20:30:30";  //定义时间日期字符串
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");  //创建"时间格式器(DateTimeFormatter)"对象,格式为：yyyy年MM月dd日 HH:mm:ss
        LocalDateTime dateTime = LocalDateTime.parse(timeString, dtf);  //将字符串型时间日期(timeString)通过时间格式器(dtf)解析(parse)为LocalDateTime类型
        System.out.println(dateTime);  //控制台：2023-11-17T20:30:30

注：格式的写法必须与字符串的形式一样，否则会报运行时异常，例如：

2023-11-17 20:30:30 对应 yyyy-MM-dd HH:mm:ss

20231117203030 对应 yyyyMMddHHmmss

但要记住：得到的最终结果都是类似2023-11-17T20:30:30的格式，因为在输出LocalDateTime对象时，会调用其重写的toString方法：

4.1将时间日期对象转为格式化后的时间日期对象

        LocalDateTime dateTime = LocalDateTime.now();  //获取当前时间,格式：yyyy-MM-dd HH:mm:ss
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");  //创建"时间格式器(DateTimeFormatter)"对象,格式为：yyyy-MM-dd
        String timeString =  dtf.format(dateTime);  //将时间日期对象(dateTime)通过时间格式器(dtf)格式化(format)为String类型后接收
        LocalDate time = LocalDate.parse(timeString, dtf);  //将字符串型时间日期(timeString)通过时间格式器(dtf)解析(parse)为LocalDate类型,格式为：yyyy-MM-dd
        System.out.println(time);  //控制台：2023-11-18

4.2、long毫秒值(时间戳)转换为日期

        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH-mm-ss");
        String longDateTime = dtf.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis()), ZoneId.of("Asia/Shanghai")));
        System.out.println(longDateTime);  //控制台：2023-11-18 23-25-08

看完点赞~人美心善！