Date、Calendar(日历对象)、LocalDateTime三大时间日期类的各种处理方式【 ...

Date类：

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

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

复制代码

 
 
Calendar(日历对象)类：

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

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

复制代码

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

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

复制代码

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

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

复制代码

控制台：

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

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

复制代码

控制台：

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

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

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

复制代码

控制台：

 
 
LocalDateTime类：

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

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

复制代码

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

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

复制代码

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

对于LocalDate，只有精度大于或等于日的加减,如年、月、日;
对于LocalTime，只有精度小于或等于时的加减,如时、分、秒、纳秒;
对于LocalDateTime，则可以进行任意精度的时间相加减;

1.         //方式一：
2.         System.out.println("——————————方式1——————————");
3.         LocalDateTime localDateTime = LocalDateTime.now();  //获取当前时间
4.         LocalDateTime plusYearResult = localDateTime.plusYears(1);      //增加1年;减就给参数传负数
5.         LocalDateTime plusMonthResult = localDateTime.plusMonths(1);    //增加1月;减就给参数传负数
6.         LocalDateTime plusDayResult = localDateTime.plusDays(1);        //增加1天;减就给参数传负数
7.         LocalDateTime plusHoursResult = localDateTime.plusHours(1);     //增加1小时;减就给参数传负数
8.         LocalDateTime plusMinutesResult = localDateTime.plusMinutes(1); //增加1分钟;减就给参数传负数
9.         LocalDateTime plusSecondResult = localDateTime.plusSeconds(1);  //增加1秒;减就给参数传负数
10.         System.out.println("当前时间：" + localDateTime + "\n增加1年后的时间：" + plusYearResult +
11.                 "\n增加1月后的时间：" + plusMonthResult + "\n增加1天后的时间：" + plusDayResult +
12.                 "\n增加1小时后的时间：" + plusHoursResult + "\n增加1分钟后的时间：" + plusMinutesResult +
13.                 "\n增加1秒后的时间：" + plusSecondResult);
14.         
15.         //方式二：
16.         System.out.println("\n\n——————————方式2——————————");
17.         LocalDateTime plusYearResult2 = localDateTime.plus(1, ChronoUnit.YEARS);      //增加1年;减就给参数传负数
18.         LocalDateTime plusMonthResult2 = localDateTime.plus(1, ChronoUnit.MONTHS);    //增加1月;减就给参数传负数
19.         LocalDateTime plusDayResult2 = localDateTime.plus(1, ChronoUnit.DAYS);        //增加1天;减就给参数传负数
20.         LocalDateTime plusHoursResult2 = localDateTime.plus(1, ChronoUnit.HOURS);     //增加1小时;减就给参数传负数
21.         LocalDateTime plusMinutesResult2 = localDateTime.plus(1, ChronoUnit.MINUTES); //增加1分钟;减就给参数传负数
22.         LocalDateTime plusSecondResult2 = localDateTime.plus(1, ChronoUnit.SECONDS);  //增加1秒;减就给参数传负数
23.         System.out.println("当前时间：" + localDateTime + "\n增加1年后的时间：" + plusYearResult2 +
24.                 "\n增加1月后的时间：" + plusMonthResult2 + "\n增加1天后的时间：" + plusDayResult2 +
25.                 "\n增加1小时后的时间：" + plusHoursResult2 + "\n增加1分钟后的时间：" + plusMinutesResult2 +
26.                 "\n增加1秒后的时间：" + plusSecondResult2);

复制代码

控制台：

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

其效果与时间日期相加减差不多，如今天是2018-01-13，要想变为2018-01-20有两种方式：
a： localDate.plusDays(7) -> 相加指定的天数
b： localDate.withDayOfYear(20) -> 直接指定到那一天

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

复制代码

控制台：

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

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

复制代码

控制台：

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

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

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

复制代码

控制台：

 
3.7、计算时间、日期间隔

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

复制代码

控制台：

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

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

复制代码

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

注：自定义转化的格式一定要与日期类型对应
1、LocalDate类型数据只能设置仅含年月日的格式
2、LocalTime类型数据只能设置仅含时分秒的格式
3、LocalDateTime类型数据可以设置含年月日时分秒的格式

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

复制代码

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

1.         String timeString = "2023-11-17 20:30:30";  //定义时间日期字符串
2.         DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");  //创建"时间格式器(DateTimeFormatter)"对象,格式为：yyyy年MM月dd日 HH:mm:ss
3.         LocalDateTime dateTime = LocalDateTime.parse(timeString, dtf);  //将字符串型时间日期(timeString)通过时间格式器(dtf)解析(parse)为LocalDateTime类型
4.         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将时间日期对象转为格式化后的时间日期对象

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

复制代码

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

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

复制代码

看完点赞~人美心善！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！