文章目录
-
- 前言
- 字符串转日期
- 格式化日期
- 获取年，季度，月，周，日，时，分，秒，毫秒的开始时间和结束时间
- 日期计算
- isIn(java.util.Date, java.util.Date, java.util.Date)
- 年龄计算
- isLeapYear(int)
- timeToSecond(java.lang.String)
- secondToTime(int)
- compare(java.util.Date, java.util.Date)
- 求一年，一月的天数
- 获取当前时间
- 常用的时间类型转换
- 获取日期的各种内容
- 农历日期工具类ChineseDate
- LocalDateTimeUtil(JDK8+中的LocalDateTime 工具类封装)
- TemporalAccessorUtil{TemporalAccessor} 工具类封装
- 转换
- 日期时间对象-DateTime
前言
日期格式转化及计算，比较使我们最常用的功能，现就工具类用法归结如下
测试pom
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>${spring.boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring.cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>${spring.cloud.alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- 引入 SpringMVC 相关依赖，并实现对其的自动配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.7.22</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>
<!-- 引入 Spring Cloud Alibaba Stream RocketMQ 相关依赖，将 RocketMQ 作为消息队列，并实现对其的自动配置 -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rocketmq</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
字符串转日期
DateUtil.parse 方法
DateUtil.parse 方法会自动识别一些常用格式，包括：
yyyy-MM-dd HH:mm:ss
yyyy/MM/dd HH:mm:ss
yyyy.MM.dd HH:mm:ss
yyyy年MM月dd日 HH时mm分ss秒
yyyy-MM-dd yyyy/MM/dd
yyyy.MM.dd HH:mm:ss
HH时mm分ss秒
yyyy-MM-dd HH:mm
yyyy-MM-dd HH:mm:ss.SSS
yyyyMMddHHmmss
yyyyMMddHHmmssSSS
yyyyMMdd
EEE, dd MMM yyyy HH:mm:ss z
EEE MMM dd HH:mm:ss zzz yyyy
yyyy-MM-dd’T’HH:mm:ss’Z’
yyyy-MM-dd’T’HH:mm:ss.SSS’Z’
yyyy-MM-dd’T’HH:mm:ssZ
yyyy-MM-dd’T’HH:mm:ss.SSSZ
// 测试字符串与LocalDateTime的互相转换
String strDate = "2022-12-01 17:02:30";
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
String strDate1 = DateUtil.formatLocalDateTime(ldt);
System.out.println(ldt);
System.out.println(strDate1);
String strDate2 = "2022-12-01 17:02:30.111";
ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN);
strDate2 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
System.out.println(ldt);
----------------------------1
2022-05-06 00:00:00
----------------------------1
2022-12-01T17:02:30
2022-12-01 17:02:30
2022-12-01T17:02:30.111
2022-12-01 17:02:30
package com.liu.test.stream.rocketmq.consumer.Utils;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import org.junit.Assert;
import org.junit.Test;
/**
* @author liu
* @date 2022年05月06日 10:57
*/
@Slf4j
public class DataUtileTest {
public void test(){
//当前时间
Date date = DateUtil.date();
//当前时间
Date date2 = DateUtil.date(Calendar.getInstance());
//当前时间
Date date3 = DateUtil.date(System.currentTimeMillis());
//当前时间字符串，格式：yyyy-MM-dd HH:mm:ss
String now = DateUtil.now();
//当前日期字符串，格式：yyyy-MM-dd
String today= DateUtil.today();
}
@Test
public void test1() {
// int i = DateUtil.ageOfNow("20110101");
// DateUtil.ageOfNow()
String dateStr = "2022-05-06";
Date date = DateUtil.parse(dateStr);
System.out.println("----------------------------1");
System.out.println(date);
System.out.println("----------------------------1");
// 测试字符串与LocalDateTime的互相转换
String strDate = "2022-12-01 17:02:30";
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
String strDate1 = DateUtil.formatLocalDateTime(ldt);
System.out.println(ldt);
System.out.println(strDate1);
String strDate2 = "2022-12-01 17:02:30.111";
ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN);
strDate2 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
System.out.println(ldt);
System.out.println(strDate2);
String str = "31-Aug-2020";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("dd-MMM-yyyy", Locale.US);
LocalDateTime localDateTime = LocalDate.parse(str, dtf).atStartOfDay();
Date date1 = DateUtil.date(localDateTime);
System.out.println(date1);
Assert.assertNotNull(date1);
String ymd1 = DateUtil.parse("2019-3-21 12:20:15", "yyyy-MM-dd").toString(DatePattern.PURE_DATE_PATTERN);
Assert.assertEquals("20190321", ymd1);
String ymd = DateUtil.parse("2021-05-16 21:20:15", "yyyy-MM-dd",Locale.US).toString(DatePattern.PURE_DATE_PATTERN);
Assert.assertEquals("20210516", ymd);
String ymd2 = DateUtil.parse("2021-05-16 21:20:15", "yyyy/MM/dd HH:mm:ss","yyyy.MM.dd HH:mm:ss","yyyy-MM-dd HH:mm:ss").toString(DatePattern.PURE_DATE_PATTERN);
Assert.assertEquals("20210516", ymd2);
DateTime dateTime =DateUtil.parseDateTime("2021-05-16 21:20:15");
Assert.assertEquals("2021-05-16 21:20:15", dateTime.toString("yyyy-MM-dd HH:mm:ss"));
String beginStr = "2020-03-11";
DateTime date4 = DateUtil.parseDate(beginStr);
Calendar calendar = date4.toCalendar();
final Calendar begin = DateUtil.beginOfWeek(calendar, false);
Assert.assertEquals("2020-03-08 00:00:00", DateUtil.date(begin).toString());
String beginStr5 = "22:10:00";
DateTime date5 = DateUtil.parseTimeToday(beginStr5);
System.out.println("date5:::::"+date5);
String str5 = "2022-05-06 22:10:00";
Date today1 = DateUtil.parse(str5);
System.out.println("today1:::::"+today1);
Assert.assertEquals(DateUtil.format(today1,"yyyy-MM-dd HH:mm:ss"), date5.toString());
testParseUTC();
}
public static void testParseUTC(){
String dateStr1 = "2018-09-13T05:34:31Z";
DateTime dt = DateUtil.parseUTC(dateStr1);
// parse方法支持UTC格式测试
DateTime dt2 = DateUtil.parse(dateStr1);
Assert.assertEquals(dt, dt2);
// 默认使用Pattern对应的时区，即UTC时区
String dateStr = dt.toString();
Assert.assertEquals("2018-09-13 05:34:31", dateStr);
// 使用当前（上海）时区
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:31", dateStr);
dateStr1 = "2018-09-13T13:34:32+0800";
dt = DateUtil.parseUTC(dateStr1);
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:32", dateStr);
dateStr1 = "2018-09-13T13:34:33+08:00";
dt = DateUtil.parseUTC(dateStr1);
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:33", dateStr);
dateStr1 = "2018-09-13T13:34:34+0800";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:34", dateStr);
dateStr1 = "2018-09-13T13:34:35+08:00";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(TimeZone.getTimeZone("GMT+8:00"));
Assert.assertEquals("2018-09-13 13:34:35", dateStr);
dateStr1 = "2018-09-13T13:34:36.999+0800";
dt = DateUtil.parseUTC(dateStr1);
final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DatePattern.NORM_DATETIME_MS_PATTERN);
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:36.999", dateStr);
dateStr1 = "2018-09-13T13:34:37.999+08:00";
dt = DateUtil.parseUTC(dateStr1);
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:37.999", dateStr);
dateStr1 = "2018-09-13T13:34:38.999+0800";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:38.999", dateStr);
dateStr1 = "2018-09-13T13:34:39.999+08:00";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString(simpleDateFormat);
Assert.assertEquals("2018-09-13 13:34:39.999", dateStr);
// 使用UTC时区
dateStr1 = "2018-09-13T13:34:39.99";
dt = DateUtil.parse(dateStr1);
assert dt != null;
dateStr = dt.toString();
Assert.assertEquals("2018-09-13 13:34:39", dateStr);
}
}
Connected to the target VM, address: ‘127.0.0.1:52523’, transport: ‘socket’
----------------------------1
2022-05-06 00:00:00
----------------------------1
2022-12-01T17:02:30
2022-12-01 17:02:30
2022-12-01T17:02:30.111
2022-12-01 17:02:30
2020-08-31 00:00:00
date5:::::2022-05-06 22:10:00
today1:::::2022-05-06 22:10:00
Disconnected from the target VM, address: ‘127.0.0.1:52523’, transport: ‘socket’
Process finished with exit code 0
格式化日期
@Test
@SneakyThrows
public void testFormat (){
String strDate = "2019-12-01 17:02:30";
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
String strDate1 = DateUtil.formatLocalDateTime(ldt);
Assert.assertEquals(strDate, strDate1);
String strDate2 = "2019-12-01 17:02:30.111";
ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN);
strDate1 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
Assert.assertEquals(strDate, strDate1);
String strDate3 = "2021-05-16";
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd");
Date localDate = sdf3.parse(strDate3);
Assert.assertEquals(strDate3, DateUtil.format(localDate, DatePattern.NORM_DATE_PATTERN));
//根据特定格式格式化日期
/*String str = "2021-05-16";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.US);
Date date = DateUtil.parse(str);
String dateStr = DateUtil.format(date,sdf);
System.out.println(dateStr);
Assert.assertEquals(str, dateStr);*/
//根据特定格式格式化日期
/*String str = "2021-05-16";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd", Locale.US);
Date date = DateUtil.parse(str);
String dateStr = DateUtil.format(date,dtf);
System.out.println(dateStr);
Assert.assertEquals(str, dateStr);*/
/*String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, "yyyy/MM/dd");
Assert.assertEquals("2017/03/01", format);
// 常用格式的格式化
String formatDate = DateUtil.formatDate(date);
Assert.assertEquals("2017-03-01", formatDate);
String formatDateTime = DateUtil.formatDateTime(date);
Assert.assertEquals("2017-03-01 00:00:00", formatDateTime);
String formatTime = DateUtil.formatTime(date);
Assert.assertEquals("00:00:00", formatTime);*/
String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, "yyyy/MM/dd");
Assert.assertEquals("2017/03/01", format);
// 常用格式的格式化
String formatDate = DateUtil.formatDate(date);
Assert.assertEquals("2017-03-01", formatDate);
String formatDateTime = DateUtil.formatDateTime(date);
Assert.assertEquals("2017-03-01 00:00:00", formatDateTime);
String formatTime = DateUtil.formatTime(date);
Assert.assertEquals("00:00:00", formatTime);
String formatChineseDate = DateUtil.formatChineseDate(DateUtil.parse("2018-02-24"), true, false);
Assert.assertEquals("二〇一八年二月二十四日", formatChineseDate);
}
获取年，季度，月，周，日，时，分，秒，毫秒的开始时间和结束时间
String dateStr2 = "2021-05-16 22:50:34.111";
DateTime date2 = DateUtil.parse(dateStr2,"yyyy-MM-dd HH:mm:ss.SSS");
int millisecond = DateUtil.millisecond(date2);
DateTime dateTime = DateUtil.endOfSecond(date2);
DateTime dateTime1 = DateUtil.endOfMinute(date2);
System.out.println(dateTime1);
Assert.assertEquals(999, DateUtil.millisecond(dateTime));
@Test
public void testOffset(){
//方法名称:cn.hutool.core.date.DateUtil.truncate(java.util.Date, cn.hutool.core.date.DateField)
/*String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2);
final DateTime dateTime = DateUtil.truncate(date2, DateField.HOUR);
Assert.assertEquals("2020-02-29 12:00:00", dateTime.toString());*/
//方法名称:cn.hutool.core.date.DateUtil.round(java.util.Date, cn.hutool.core.date.DateField)
/*String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.round(date2, DateField.MINUTE);
Assert.assertEquals("2020-02-29 12:59:59", dateTime.toString());
dateStr2 = "2020-02-29 12:05:29";
date2 = DateUtil.parse(dateStr2);
dateTime = DateUtil.round(date2, DateField.MINUTE);
Assert.assertEquals("2020-02-29 12:05:00", dateTime.toString());*/
String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.ceiling(date2, DateField.MINUTE);
Assert.assertEquals("2020-02-29 12:59:59", dateTime.toString());
}
String dateStr2 = "2021-05-16 22:50:34.111";
Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.beginOfSecond(date2);
Assert.assertEquals("2021-05-16 22:50:34", dateTime.toString());
DateTime dateTime1 = DateUtil.beginOfMinute(dateTime);
System.out.println(dateTime1);
Assert.assertEquals("2021-05-16 22:50:00", dateTime1.toString());
DateTime dateTime2 = DateUtil.beginOfDay(dateTime);
System.out.println(dateTime2);
Assert.assertEquals("2021-05-16 00:00:00", dateTime2.toString());
//昨天
DateTime dateTime = DateUtil.yesterday();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//明天
DateTime dateTime = DateUtil.tomorrow();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//上周
DateTime dateTime = DateUtil.lastWeek();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//下周
DateTime dateTime = DateUtil.nextWeek();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//上个月
DateTime dateTime = DateUtil.lastMonth();
System.out.println(dateTime);
Assert.assertNotNull(dateTime);
//偏移月
String dateStr2 = "2021-05-16 22:50:34";
DateTime date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.offsetMonth(date2,1);
Assert.assertEquals("2021-06-16 22:50:34", dateTime.toString());
dateTime = DateUtil.offsetMonth(date2,-1);
Assert.assertEquals("2021-04-16 22:50:34", dateTime.toString());
获取指定日期偏移指定时间后的时间，生成的偏移日期不影响原日期
String dateStr = "2017-03-01 22:33:23";
Date date = DateUtil.parse(dateStr);
Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);
Assert.assertEquals("2017-03-03 22:33:23", newDate.toString());
日期计算
between 判断两个日期相差的时长，只保留绝对值
String dateStr1 = "2017-03-01 22:34:23";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14";
Date date2 = DateUtil.parse(dateStr2);
// 相差月
long betweenMonth = DateUtil.betweenMonth(date1, date2, false);
Assert.assertEquals(1, betweenMonth);// 相差一个月
// 反向
betweenMonth = DateUtil.betweenMonth(date2, date1, false);
Assert.assertEquals(1, betweenMonth);// 相差一个月
// 相差天
long betweenDay = DateUtil.between(date1, date2, DateUnit.DAY);
Assert.assertEquals(31, betweenDay);// 相差一个月，31天
// 反向
betweenDay = DateUtil.between(date2, date1, DateUnit.DAY);
Assert.assertEquals(31, betweenDay);// 相差一个月，31天
// 相差小时
long betweenHour = DateUtil.between(date1, date2, DateUnit.HOUR);
Assert.assertEquals(745, betweenHour);
// 反向
betweenHour = DateUtil.between(date2, date1, DateUnit.HOUR);
Assert.assertEquals(745, betweenHour);
// 相差分
long betweenMinute = DateUtil.between(date1, date2, DateUnit.MINUTE);
Assert.assertEquals(44721, betweenMinute);
// 反向
betweenMinute = DateUtil.between(date2, date1, DateUnit.MINUTE);
Assert.assertEquals(44721, betweenMinute);
// 相差秒
long betweenSecond = DateUtil.between(date1, date2, DateUnit.SECOND);
Assert.assertEquals(2683311, betweenSecond);
// 反向
betweenSecond = DateUtil.between(date2, date1, DateUnit.SECOND);
Assert.assertEquals(2683311, betweenSecond);
// 相差秒
long betweenMS = DateUtil.between(date1, date2, DateUnit.MS);
Assert.assertEquals(2683311000L, betweenMS);
// 反向
betweenMS = DateUtil.between(date2, date1, DateUnit.MS);
Assert.assertEquals(2683311000L, betweenMS);
long between = DateUtil.between(DateUtil.parse("2019-05-06 02:15:00"), DateUtil.parse("2019-05-06 02:20:00"), DateUnit.HOUR);
Assert.assertEquals(0, between);
cn.hutool.core.date.DateUtil.betweenYear(java.util.Date, java.util.Date, boolean)
方法描述
计算两个日期相差年数
在非重置情况下，如果起始日期的月大于结束日期的月，年数要少算1（不足1年）
long betweenYear = DateUtil.betweenYear(DateUtil.parse("2021-05-18 22:15:00"), DateUtil.parse("2020-05-18 21:15:00"),true);
Assert.assertEquals(1, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-05-18 22:15:00"),true);
Assert.assertEquals(1, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-05-18 21:15:00"),false);
Assert.assertEquals(0, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-05-19 22:15:00"),false);
Assert.assertEquals(1, betweenYear);
betweenYear = DateUtil.betweenYear(DateUtil.parse("2020-05-18 22:15:00"), DateUtil.parse("2021-04-18 22:15:00"),false);
Assert.assertEquals(0, betweenYear);
formatBetween(java.util.Date, java.util.Date, cn.hutool.core.date.BetweenFormatter.Level)
level 级别，按照天、小时、分、秒、毫秒分为5个等级
String dateStr1 = "2017-03-01 22:34:23";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14";
Date date2 = DateUtil.parse(dateStr2);
long between = DateUtil.between(date1, date2, DateUnit.MS);
String formatBetween = DateUtil.formatBetween(between, BetweenFormatter.Level.MINUTE);
Assert.assertEquals("31天1小时21分", formatBetween);
isIn(java.util.Date, java.util.Date, java.util.Date)
当前日期是否在日期指定范围内
起始日期和结束日期可以互换
String dateStr = "2017-03-01 22:34:23.100";
Date date = DateUtil.parse(dateStr);
String dateStr1 = "2017-02-01 22:34:23.100";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14.001";
Date date2 = DateUtil.parse(dateStr2);
boolean isIn = DateUtil.isIn(date,date1,date2);
Assert.assertEquals(Boolean.TRUE, isIn);
dateStr = "2017-05-01 22:34:23.100";
date = DateUtil.parse(dateStr);
isIn = DateUtil.isIn(date,date1,date2);
Assert.assertEquals(Boolean.FALSE, isIn);
isSameTime(java.util.Date, java.util.Date)
是否为相同时间
此方法比较两个日期的时间戳是否相同
String dateStr = "2017-02-01 22:34:23.100";
Date date = DateUtil.parse(dateStr);
String dateStr1 = "2017-02-01 22:34:23.100";
Date date1 = DateUtil.parse(dateStr1);
boolean isSameTime = DateUtil.isSameTime(date,date1);
Assert.assertEquals(Boolean.TRUE, isSameTime);
dateStr1 = "2017-02-01 22:34:23.110";
date1 = DateUtil.parse(dateStr1);
isSameTime = DateUtil.isSameTime(date,date1);
Assert.assertEquals(Boolean.FALSE, isSameTime);
String dateStr1 = "2021-05-19 22:34:23.100";
Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2021-05-19 23:56:14.001";
Date date2 = DateUtil.parse(dateStr2);
boolean isSameDay = DateUtil.isSameDay(date1,date2);
Assert.assertEquals(Boolean.TRUE, isSameDay);
dateStr2 = "2021-05-20 23:56:14.001";
date2 = DateUtil.parse(dateStr2);
isSameDay = DateUtil.isSameDay(date1,date2);
Assert.assertEquals(Boolean.FALSE, isSameDay);
spendNt(long)
计时，常用于记录某段代码的执行时间，单位：纳秒
//计时，常用于记录某段代码的执行时间，单位：纳秒
int j= 0;
long nanoTimeStart = System.nanoTime();
for (int i = 0; i < 100000; i++) {
j=j+i;
}
long nanoTimeEnd = DateUtil.spendNt(nanoTimeStart);
System.out.println("运行时间为："+nanoTimeEnd+"纳秒");
System.out.println("j的值为："+j);
spendMs(long)
方法描述
计时，常用于记录某段代码的执行时间，单位：毫秒
timer()
TimeInterval timer = DateUtil.timer();
// ---------------------------------
// -------这是执行过程
// ---------------------------------
timer.interval();// 花费毫秒数
timer.intervalRestart();// 返回花费时间，并重置开始时间
timer.intervalMinute();// 花费分钟数
createStopWatch()
方法描述
创建秒表{@link StopWatch}，用于对代码块的执行时间计数
使用方法如下：
StopWatch stopWatch = DateUtil.createStopWatch();
// 任务1
stopWatch.start(“任务一”);
Thread.sleep(1000);
stopWatch.stop();
// 任务2
stopWatch.start(“任务一”);
Thread.sleep(2000);
stopWatch.stop();
// 打印出耗时
Console.log(stopWatch.prettyPrint());
StopWatch stopWatch = DateUtil.createStopWatch("任务名称");
// 任务1
stopWatch.start("任务一");
Thread.sleep(1000);
stopWatch.stop();
// 任务2
stopWatch.start("任务二");
Thread.sleep(2000);
stopWatch.stop();
// 打印出耗时
System.out.println(stopWatch.prettyPrint());
年龄计算
String birthDay = "2019-05-19";
//生日转为年龄，计算法定年龄(生日，标准日期字符串)
int ageOfNow = DateUtil.ageOfNow(birthDay);
System.out.println(ageOfNow);
String d1 = "2000-02-29";
String d2 = "2018-02-28";
final int age = DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2));
Assert.assertEquals(18, age);
isLeapYear(int)
方法描述
是否闰年
timeToSecond(java.lang.String)
int second = DateUtil.timeToSecond("00:01:40");
Assert.assertEquals(100, second);
second = DateUtil.timeToSecond("00:00:40");
Assert.assertEquals(40, second);
second = DateUtil.timeToSecond("01:00:00");
Assert.assertEquals(3600, second);
second = DateUtil.timeToSecond("00:00:00");
Assert.assertEquals(0, second);
secondToTime(int)
方法描述
秒数转为时间格式(HH:mm:ss)
String time = DateUtil.secondToTime(3600);
Assert.assertEquals("01:00:00", time);
time = DateUtil.secondToTime(3800);
Assert.assertEquals("01:03:20", time);
time = DateUtil.secondToTime(0);
Assert.assertEquals("00:00:00", time);
time = DateUtil.secondToTime(30);
Assert.assertEquals("00:00:30", time);
compare(java.util.Date, java.util.Date)
比较结果，如果date1 < date2，返回数小于0，date1==date2返回0，date1 > date2 大于0
Date date1 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date2 = DateUtil.parse("2021-04-13 23:59:10");
Assert.assertEquals(1, DateUtil.compare(date1, date2));
Date date1 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date2 = DateUtil.parse("2021-04-13 23:59:10");
Assert.assertEquals(1, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_PATTERN));
Assert.assertEquals(0, DateUtil.compare(date1, date2, DatePattern.NORM_DATE_PATTERN));
Assert.assertEquals(0, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_MINUTE_PATTERN));
Date date11 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date22 = DateUtil.parse("2021-04-11 23:10:10");
Assert.assertEquals(0, DateUtil.compare(date11, date22, DatePattern.NORM_MONTH_PATTERN));
求一年，一月的天数
lengthOfYear(int)
int dayOfYear = DateUtil.dayOfYear(DateUtil.parse(“2020-01-01”));
Assert.assertEquals(1, dayOfYear);
int lengthOfYear = DateUtil.lengthOfYear(2020);
Assert.assertEquals(366, lengthOfYear);
int lengthOfMonth = DateUtil.lengthOfMonth(2,true);
Assert.assertEquals(29, lengthOfMonth);
lengthOfMonth = DateUtil.lengthOfMonth(2,false);
Assert.assertEquals(28, lengthOfMonth);
获取当前时间
| 方法 | 描述 |
|---|---|
| cn.hutool.core.date.DateUtil.date() |
当前时间，转换为{@link DateTime}对象
|
| cn.hutool.core.date.DateUtil.dateSecond() |
当前时间，转换为{@link DateTime}对象，忽略毫秒部分
|
| cn.hutool.core.date.DateUtil.current() |
当前时间的时间戳
|
| cn.hutool.core.date.DateUtil.currentSeconds() |
当前时间的时间戳（秒）
|
| cn.hutool.core.date.DateUtil.now() |
当前时间，格式 yyyy-MM-dd HH:mm:ss
|
| cn.hutool.core.date.DateUtil.today() |
当前日期，格式 yyyy-MM-dd
|
// 当前时间
DateTime date = DateUtil.date();
System.out.println(date);
System.out.println(date.toString());
Assert.assertNotNull(date);
// 当前时间
DateTime date = DateUtil.date();
System.out.println("long时间："+date.getTime());
//当前时间 忽略毫秒
System.out.println("long时间忽略毫秒："+DateUtil.dateSecond().getTime());
//当前时间 忽略毫秒部分
Date date4 = DateUtil.dateSecond();
Assert.assertNotNull(date4);
常用的时间类型转换
| 方法 | 描述 |
|---|---|
| cn.hutool.core.date.DateUtil.dateNew(java.util.Date) |
根据已有{@link Date} 产生新的{@link DateTime}对象
|
| cn.hutool.core.date.DateUtil.date(long) |
Long类型时间转为{@link DateTime}<br> 只支持毫秒级别时间戳，如果需要秒级别时间戳，请自行×1000
|
| cn.hutool.core.date.DateUtil.date(java.util.Calendar) |
{@link Calendar}类型时间转为{@link DateTime}<br> 始终根据已有{@link Calendar} 产生新的{@link DateTime}对象
|
| cn.hutool.core.date.DateUtil.date(java.time.temporal.TemporalAccessor) |
{@link TemporalAccessor}类型时间转为{@link DateTime}<br> 始终根据已有{@link TemporalAccessor} 产生新的{@link DateTime}对象
|
获取日期的各种内容
获取日期的各种内容，包含：年，季度，月，周，星期，日，时，分，秒，毫秒
获得月份，从0开始计数
农历日期工具类ChineseDate
LocalDateTimeUtil(JDK8+中的LocalDateTime 工具类封装)
TemporalAccessorUtil{TemporalAccessor} 工具类封装
转换
Date、long、Calendar之间的相互转换
//当前时间
Date date = DateUtil.date();
//当前时间
Date date2 = DateUtil.date(Calendar.getInstance());
//当前时间
Date date3 = DateUtil.date(System.currentTimeMillis());
//当前时间字符串，格式：yyyy-MM-dd HH:mm:ss
String now = DateUtil.now();
//当前日期字符串，格式：yyyy-MM-dd
String today= DateUtil.today();
日期时间对象-DateTime
由来
考虑工具类的局限性，在某些情况下使用并不简便，于是DateTime类诞生。DateTime对象充分吸取Joda-Time库的优点，并提供更多的便捷方法，这样我们在开发时不必再单独导入Joda-Time库便可以享受简单快速的日期时间处理过程。
说明
DateTime类继承于java.util.Date类，为Date类扩展了众多简便方法，这些方法多是DateUtil静态方法的对象表现形式，使用DateTime对象可以完全替代开发中Date对象的使用。
使用
新建对象
DateTime对象包含众多的构造方法，构造方法支持的参数有：
Date
Calendar
String(日期字符串，第二个参数是日期格式)
long 毫秒数
构建对象有两种方式：DateTime.of()和new DateTime()：
Date date = new Date();
//new方式创建
DateTime time = new DateTime(date);
Console.log(time);
//of方式创建
DateTime now = DateTime.now();
DateTime dt = DateTime.of(date);
使用对象
DateTime的成员方法与DateUtil中的静态方法所对应，因为是成员方法，因此可以使用更少的参数操作日期时间。
示例：获取日期成员（年、月、日等）
DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);
//年，结果：2017
int year = dateTime.year();
//季度（非季节），结果：Season.SPRING
Season season = dateTime.seasonEnum();
//月份，结果：Month.JANUARY
Month month = dateTime.monthEnum();
//日，结果：5
int day = dateTime.dayOfMonth();
更多成员方法请参阅API文档。
对象的可变性
DateTime对象默认是可变对象（调用offset、setField、setTime方法默认变更自身），但是这种可变性有时候会引起很多问题（例如多个地方共用DateTime对象）。我们可以调用setMutable(false)方法使其变为不可变对象。在不可变模式下，offset、setField方法返回一个新对象，setTime方法抛出异常。
DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);
//默认情况下DateTime为可变对象，此时offsite == dateTime
DateTime offsite = dateTime.offsite(DateField.YEAR, 0);
//设置为不可变对象后变动将返回新对象，此时offsite != dateTime
dateTime.setMutable(false);
offsite = dateTime.offsite(DateField.YEAR, 0);
格式化为字符串
调用toString()方法即可返回格式为yyyy-MM-dd HH:mm:ss的字符串，调用toString(String format)可以返回指定格式的字符串。
DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);
//结果：2017-01-05 12:34:23
String dateStr = dateTime.toString();
//结果：2017/01/05