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:412.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:002.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.5741617003.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:103.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:554.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-184.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看完点赞~人美心善！