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看完点赞~人美心善！