前言

日期格式轉(zhuǎn)化及計算，比較使我們最常用的功能，現(xiàn)就工具類用法歸結(jié)如下

測試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 相關依賴，并實現(xiàn)對其的自動配置 -->
        <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 作為消息隊列，并實現(xiàn)對其的自動配置 -->
        <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>

字符串轉(zhuǎn)日期

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的互相轉(zhuǎn)換
        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的互相轉(zhuǎn)換
        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對應的時區(qū)，即UTC時區(qū)
        String dateStr = dt.toString();
        Assert.assertEquals("2018-09-13 05:34:31", dateStr);

        // 使用當前（上海）時區(qū)
        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時區(qū)
        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));



        //根據(jù)特定格式格式化日期
        /*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);*/


        //根據(jù)特定格式格式化日期
        /*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);



    }

獲取年，季度，月，周，日，時，分，秒，毫秒的開始時間和結(jié)束時間

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

日期計算

 有時候我們計算相差天數(shù)的時候需要忽略時分秒。 
比如：2016-02-01 23:59:59和2016-02-02 00:00:00相差一秒 
如果isReset為{@code false}相差天數(shù)為0。
 如果isReset為{@code true}相差天數(shù)將被計算為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)
方法描述
計算兩個日期相差年數(shù)

在非重置情況下，如果起始日期的月大于結(jié)束日期的月，年數(shù)要少算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)

當前日期是否在日期指定范圍內(nèi)

起始日期和結(jié)束日期可以互換

		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)

計時，常用于記錄某段代碼的執(zhí)行時間，單位：納秒

		//計時，常用于記錄某段代碼的執(zhí)行時間，單位：納秒
		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)
方法描述
計時，常用于記錄某段代碼的執(zhí)行時間，單位：毫秒

timer()

		TimeInterval timer = DateUtil.timer();

		// ---------------------------------
		// -------這是執(zhí)行過程
		// ---------------------------------

		timer.interval();// 花費毫秒數(shù)
		timer.intervalRestart();// 返回花費時間，并重置開始時間
		timer.intervalMinute();// 花費分鐘數(shù)

createStopWatch()

方法描述
創(chuàng)建秒表{@link StopWatch}，用于對代碼塊的執(zhí)行時間計數(shù)

使用方法如下：

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";
		//生日轉(zhuǎn)為年齡，計算法定年齡(生日，標準日期字符串)
		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)

方法描述
秒數(shù)轉(zhuǎn)為時間格式(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)

比較結(jié)果，如果date1 < date2，返回數(shù)小于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));		

求一年，一月的天數(shù)

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

常用的時間類型轉(zhuǎn)換

獲取日期的各種內(nèi)容

獲取日期的各種內(nèi)容，包含：年，季度，月，周，星期，日，時，分，秒，毫秒

獲得月份，從0開始計數(shù)

農(nóng)歷日期工具類ChineseDate

LocalDateTimeUtil(JDK8+中的LocalDateTime 工具類封裝)

TemporalAccessorUtil{TemporalAccessor} 工具類封裝

轉(zhuǎn)換

Date、long、Calendar之間的相互轉(zhuǎn)換
//當前時間
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庫的優(yōu)點，并提供更多的便捷方法，這樣我們在開發(fā)時不必再單獨導入Joda-Time庫便可以享受簡單快速的日期時間處理過程。

說明

DateTime類繼承于java.util.Date類，為Date類擴展了眾多簡便方法，這些方法多是DateUtil靜態(tài)方法的對象表現(xiàn)形式，使用DateTime對象可以完全替代開發(fā)中Date對象的使用。

使用

新建對象
DateTime對象包含眾多的構(gòu)造方法，構(gòu)造方法支持的參數(shù)有：

Date
Calendar
String(日期字符串，第二個參數(shù)是日期格式)
long 毫秒數(shù)
構(gòu)建對象有兩種方式：DateTime.of()和new DateTime()：

Date date = new Date();

//new方式創(chuàng)建
DateTime time = new DateTime(date);
Console.log(time);

//of方式創(chuàng)建
DateTime now = DateTime.now();
DateTime dt = DateTime.of(date);
使用對象
DateTime的成員方法與DateUtil中的靜態(tài)方法所對應，因為是成員方法，因此可以使用更少的參數(shù)操作日期時間。

示例：獲取日期成員（年、月、日等）

DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);

//年，結(jié)果：2017
int year = dateTime.year();

//季度（非季節(jié)），結(jié)果：Season.SPRING
Season season = dateTime.seasonEnum();

//月份，結(jié)果：Month.JANUARY
Month month = dateTime.monthEnum();

//日，結(jié)果：5
int day = dateTime.dayOfMonth();
更多成員方法請參閱API文檔。

對象的可變性
DateTime對象默認是可變對象（調(diào)用offset、setField、setTime方法默認變更自身），但是這種可變性有時候會引起很多問題（例如多個地方共用DateTime對象）。我們可以調(diào)用setMutable(false)方法使其變?yōu)椴豢勺儗ο蟆Ｔ诓豢勺兡Ｊ较?，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);
格式化為字符串
調(diào)用toString()方法即可返回格式為yyyy-MM-dd HH:mm:ss的字符串，調(diào)用toString(String format)可以返回指定格式的字符串。

DateTime dateTime = new DateTime(“2017-01-05 12:34:23”, DatePattern.NORM_DATETIME_FORMAT);
//結(jié)果：2017-01-05 12:34:23
String dateStr = dateTime.toString();

//結(jié)果：2017/01/05文章來源地址http://www.zghlxwxcb.cn/news/detail-436458.html

到了這里，關于Hutool 常用工具類介紹-DateUtil的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！