Hutool 常用工具类介绍-DateUtil

• • 前言
  • 字符串转日期
  • 格式化日期
  • 获取年，季度，月，周，日，时，分，秒，毫秒的开始时间和结束时间
  • 日期计算
  • • formatBetween(java.util.Date, java.util.Date, cn.hutool.core.date.BetweenFormatter.Level)
  • isIn(java.util.Date, java.util.Date, java.util.Date)
  • • isSameTime(java.util.Date, java.util.Date)
    • spendNt(long)
    • timer()
    • createStopWatch()
  • 年龄计算
  • isLeapYear(int)
  • timeToSecond(java.lang.String)
  • secondToTime(int)
  • compare(java.util.Date, java.util.Date)
  • 求一年，一月的天数
  • 获取当前时间
  • 常用的时间类型转换
  • 获取日期的各种内容
  • 农历日期工具类ChineseDate
  • LocalDateTimeUtil(JDK8+中的LocalDateTime 工具类封装)
  • TemporalAccessorUtil{TemporalAccessor} 工具类封装
  • 转换
  • 日期时间对象-DateTime
  • • 说明
    • 使用

日期格式转化及计算，比较使我们最常用的功能，现就工具类用法归结如下

测试pom

        
            
                org.springframework.boot
                spring-boot-starter-parent
                ${spring.boot.version}
                pom
                import
            
            
                org.springframework.cloud
                spring-cloud-dependencies
                ${spring.cloud.version}
                pom
                import
            
            
                com.alibaba.cloud
                spring-cloud-alibaba-dependencies
                ${spring.cloud.alibaba.version}
                pom
                import
            
        
    

    
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            cn.hutool
            hutool-all
            5.7.22
        

        
        
            org.junit.jupiter
            junit-jupiter-api
            5.8.2
            test
        




        
        
            com.alibaba.cloud
            spring-cloud-starter-stream-rocketmq
        
        
            org.projectlombok
            lombok
            1.18.12
            compile
        
        
            junit
            junit
            4.12
        
    

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

 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 yyyy年MM月dd日 

// 测试字符串与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());

 有时候我们计算相差天数的时候需要忽略时分秒。 
比如：2016-02-01 23:59:59和2016-02-02 00:00:00相差一秒 
如果isReset为{@code false}相差天数为0。
 如果isReset为{@code true}相差天数将被计算为1 

 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(); 
// 打印出耗时 Console.log(stopWatch.prettyPrint()); 

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);

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);

当前日期是否在日期指定范围内

起始日期和结束日期可以互换

		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);

是否为相同时间

此方法比较两个日期的时间戳是否相同

		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);

计时，常用于记录某段代码的执行时间，单位：纳秒

		//计时，常用于记录某段代码的执行时间，单位：纳秒
		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)
方法描述
计时，常用于记录某段代码的执行时间，单位：毫秒

		TimeInterval timer = DateUtil.timer();

		// ---------------------------------
		// -------这是执行过程
		// ---------------------------------

		timer.interval();// 花费毫秒数
		timer.intervalRestart();// 返回花费时间，并重置开始时间
		timer.intervalMinute();// 花费分钟数

方法描述
创建秒表{@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);

方法描述
是否闰年

		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);

方法描述
秒数转为时间格式(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);

比较结果，如果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);

// 当前时间
		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);

获取日期的各种内容，包含：年，季度，月，周，星期，日，时，分，秒，毫秒

获得月份，从0开始计数

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对象充分吸取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