@Test
    void test06(){
        Date date1 = new Date();
        // 獲取當(dāng)前時間后 +100 ms時間
        Date date2 = new Date(System.currentTimeMillis() + 100);
        System.out.println(date1);
        System.out.println(date1.compareTo(date2));
        System.out.println(date1.before(date2));
    }

    @Test
    void test05(){
        Calendar calendar =  Calendar.getInstance();
        // Calendar.YEAR 表示當(dāng)前年
        int year = calendar.get(Calendar.YEAR);
        // Calendar.MONTH表示月份，但是為了計(jì)算方便，是從0開始算，所以顯示出來是月份 -1 的
        int month = calendar.get(Calendar.MONTH);
        // Calendar.DAY_OF_MONTH 在這個月 的這一天
        int dom = calendar.get(Calendar.DAY_OF_MONTH);
        // Calendar.DAY_OF_YEAR 在這一年 的這一天
        int doy = calendar.get(Calendar.DAY_OF_YEAR);
        // Calendar.DAY_OF_WEEK 在這一周 的這一天，從星期日當(dāng)?shù)谝惶鞆?開始算的，所以會是 +1
        int dow = calendar.get(Calendar.DAY_OF_WEEK);
        // Calendar.DAY_OF_WEEK_IN_MONTH 在這一個月 這一天在 第幾周
        int dowim = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);
        System.out.println(year+"年"+ month+"月");
        System.out.println(dom+"日");
        System.out.println(doy+"日");
        System.out.println(dow+"日");
        System.out.println(dowim);
    }

    @Test
    void test07(){
        Calendar cal1 = Calendar.getInstance();
        // 2003-8-23
        cal1.set(2003, 7, 23, 0, 0, 0);
        // 2003-8-23 => 2004-2-23
        cal1.add(Calendar.MONTH, 6);
        System.out.println(cal1.getTime());

        Calendar cal2 = Calendar.getInstance();
        // 2003-8-31
        cal2.set(2003, 7, 31, 0, 0, 0);
        // 因?yàn)檫M(jìn)位后月份改為2月,2月沒有31日,自動變成29日,若不是閏年則變成28日
        // 2003-8-31 => 2004-2-29
        cal2.add(Calendar.MONTH, 6);
        System.out.println(cal2.getTime());
    }

    @Test
    void test08(){
        Calendar cal1 = Calendar.getInstance();
        // 2003-8-23
        cal1.set(2003, 7, 23, 0, 0, 0);
        // 2003-8-23 => 2003-2-23
        cal1.roll(Calendar.MONTH, 6);
        System.out.println(cal1.getTime());

        Calendar cal2 = Calendar.getInstance();
        cal2.set(2003, 7, 31, 0, 0, 0);
        // MONTH字段“進(jìn)位”后變成2，2月沒有31日
        // YEAR字段不會改變，2003年2月只有28天
        // 2003-8-31 => 2003-2-28
        cal2.roll(Calendar.MONTH, 6);
        System.out.println(cal2.getTime());
    }

    @Test
    void test09(){
        Calendar cal = Calendar.getInstance();
        System.out.println(cal.getTime());
        // ① 結(jié)果是Year字段+1，MONTH字段為1（2月）
        cal.set(Calendar.MONTH, 13);
        System.out.println(cal.getTime());
        // 關(guān)閉容錯性
        cal.setLenient(false);
        // ② 導(dǎo)致運(yùn)行異常
        cal.set(Calendar.MONTH, 13);
        System.out.println(cal.getTime());
    }

    @Test
    void test10(){
        Calendar cal = Calendar.getInstance();
        // 2003-8-31
        cal.set(2003, 7, 31);
        cal.set(Calendar.MONTH, 8);

        // ① 將月份設(shè)置為9月，但是9月沒有31號，如果立即修改，系統(tǒng)會把cal自動調(diào)整為10月1日
        // System.out.println(cal.getTime());

        // 設(shè)置DATE字段為5
        cal.set(Calendar.DATE, 5);
        // 輸出結(jié)果為 2003-9-5
        System.out.println(cal.getTime());
    }

LocalDate localDate = LocalDate.now();
// 也可以通過 LocalDate.of(年，月，日)去構(gòu)造
System.out.println("當(dāng)前日期："+localDate.getYear()+" 年 "+localDate.getMonthValue()+" 月 "+localDate.getDayOfMonth()+"日" );

// 計(jì)算
LocalDate pluslocalDate = localDate.plusDays(1);//增加一天
LocalDate pluslocalDate = localDate.plusYears(1);//增加一年

// 對兩個日期的判斷，是在前、在后、或者相等。
LocalDate.isBefore(LocalDate);
LocalDate.isAfter();
LocalDate.isEqual();
//結(jié)果

LocalDate pluslocalDate = localDate.plusDays(1);//增加一天
LocalDate pluslocalDate = localDate.plusYears(1);//增加一年

public final class LocalDateTime ...{
    private final LocalDate date;
    private final LocalTime time;
}

Instant.ofEpochMilli(System.currentTimeMillis())
Instant.now()

LocalDateTime now = LocalDateTime.ofInstant(
    Instant.ofEpochMilli(System.currentTimeMillis()),ZoneId.systemDefault());

System.out.println("當(dāng)前日期："+now.getYear()+" 年 "+now.getMonthValue()+" 月 "+now.getDayOfMonth()+"日" );

LocalDate startDate = LocalDateTime.ofInstant(
    Instant.ofEpochMilli(1601175465000L), ZoneId.systemDefault())
						.toLocalDate();//1601175465000是2020-9-27 10:57:45
Period p  =  Period.between(startDate,  LocalDate.now());

System.out.println("目標(biāo)日期距離今天的時間差："+p.getYears()+" 年 "+p.getMonths()+" 個月 "+p.getDays()+" 天" );

//目標(biāo)日期距離今天的時間差：1 年 1 個月 1 天

public static Period between(LocalDate startDateInclusive, LocalDate endDateExclusive) {
    return startDateInclusive.until(endDateExclusive);
}
public Period until(ChronoLocalDate endDateExclusive) {
    LocalDate end = LocalDate.from(endDateExclusive);
    long totalMonths = end.getProlepticMonth() - this.getProlepticMonth();  // safe
    int days = end.day - this.day;
    if (totalMonths > 0 && days < 0) {
        totalMonths--;
        LocalDate calcDate = this.plusMonths(totalMonths);
        days = (int) (end.toEpochDay() - calcDate.toEpochDay());  // safe
    } else if (totalMonths < 0 && days > 0) {
        totalMonths++;
        days -= end.lengthOfMonth();
    }
    long years = totalMonths / 12;  // safe
    int months = (int) (totalMonths % 12);  // safe
    return Period.of(Math.toIntExact(years), months, days);
}

LocalDateTime end = LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis()), ZoneId.systemDefault());
LocalDateTime start = LocalDateTime.ofInstant(Instant.ofEpochMilli(1601175465000L), ZoneId.systemDefault());
Duration duration = Duration.between(start, end);

System.out.println("開始時間到結(jié)束時間，持續(xù)了"+duration.toDays()+"天");
System.out.println("開始時間到結(jié)束時間，持續(xù)了"+duration.toHours()+"小時");
System.out.println("開始時間到結(jié)束時間，持續(xù)了"+duration.toMillis()/1000+"秒");

@Test
    void durationTEst(){
        LocalTime target = LocalTime.parse("00:02:35.700");
        // 獲取當(dāng)前日期，此處為了保證后續(xù)結(jié)果固定，注掉自動獲取當(dāng)前日期，指定固定日期
        // LocalDate today = LocalDate.now();
        LocalTime today = LocalTime.parse("12:12:25.600");

        // 輸出：12:12:25.600
        System.out.println(today);
        // 輸出：00:02:35.700
        System.out.println(target);

        Duration duration = Duration.between(target, today);

        // 輸出：PT12H9M49.9S
        System.out.println(duration);
        // 輸出：43789
        System.out.println(duration.getSeconds());
        // 輸出：900000000
        System.out.println(duration.getNano());
        // 輸出：729
        System.out.println(duration.toMinutes());
        // 輸出：PT42H9M49.9S
        System.out.println(duration.plusHours(30L));
        // 輸出：PT15.9S
        System.out.println(duration.withSeconds(15L));

    }

    @Test
    void periodTest(){
        LocalDate target = LocalDate.parse("2021-07-11");
        // 獲取當(dāng)前日期，此處為了保證后續(xù)結(jié)果固定，注掉自動獲取當(dāng)前日期，指定固定日期
        // LocalDate today = LocalDate.now();
        LocalDate today = LocalDate.parse("2022-07-08");

        // 輸出：2022-07-08
        System.out.println(today);
        // 輸出：2021-07-11
        System.out.println(target);

        Period period = Period.between(target, today);

        // 輸出：P11M27D， 表示11個月27天
        System.out.println(period);
        // 輸出：0， 因?yàn)閜eriod值為11月27天，即year字段為0
        System.out.println(period.getYears());
        // 輸出：11， 因?yàn)閜eriod值為11月27天，即month字段為11
        System.out.println(period.getMonths());
        // 輸出：27， 因?yàn)閜eriod值為11月27天，即days字段為27
        System.out.println(period.getDays());
        // 輸出：P14M27D， 因?yàn)閜eriod為11月27天，加上3月，變成14月27天
        System.out.println(period.plusMonths(3L));
        // 輸出：P11M15D，因?yàn)閜eriod為11月27天，僅將days值設(shè)置為15，則變?yōu)?1月15天
        System.out.println(period.withDays(15));
        // 輸出：P2Y3M44D
        System.out.println(Period.of(2, 3, 44));

    }

public void calculateDurationDays(String targetDate) {
    LocalDate target = LocalDate.parse(targetDate);
    LocalDate today = LocalDate.now();
    System.out.println("today : " + today);
    System.out.println("target: " + target);
    long days = Duration.between(target, today).abs().toDays();
    System.out.println("相差："  + days + "天");
}

public void calculateDurationDays(String targetDate) {
    LocalDate target = LocalDate.parse(targetDate);
    LocalDate today = LocalDate.now();
    System.out.println("today : " + today);
    System.out.println("target: " + target);
    // 注意，此處寫法錯誤！這里容易踩坑：
    long days = Math.abs(Period.between(target, today).getDays());
    System.out.println("相差："  + days + "天");
}

public void calculateDurationDays(String targetDate) {
    LocalDate target = LocalDate.parse(targetDate);
    LocalDate today = LocalDate.now();
    System.out.println("today : " + today);
    System.out.println("target: " + target);
    Period between = Period.between(target, today);
    System.out.println("相差："
            + Math.abs(between.getYears()) + "年"
            + Math.abs(between.getMonths()) + "月"
            + Math.abs(between.getDays()) + "天");
}

public void calculateDurationDays(String targetDate) {
    LocalDate target = LocalDate.parse(targetDate);
    LocalDate today = LocalDate.now();
    System.out.println("today : " + today);
    System.out.println("target: " + target);
    long days = Math.abs(target.toEpochDay() - today.toEpochDay());
    System.out.println("相差：" + days + "天");
}

public void doSomething() {
    // 記錄開始時間戳
    long startMillis = System.currentTimeMillis();
    // do something ...

    // 計(jì)算結(jié)束時間戳
    long endMillis = System.currentTimeMillis();
    // 計(jì)算相差的毫秒數(shù)
    System.out.println(endMillis - startMillis);
}

public void doSomething() {
    // 記錄開始時間戳
    Instant start = Instant.now();
    // do something ...

    // 計(jì)算結(jié)束時間戳
    Instant end = Instant.now();

    // 計(jì)算相差的毫秒數(shù)
    System.out.println(Duration.between(start, end).toMillis());
}

        <!-- https://mvnrepository.com/artifact/com.xiaoleilu/hutool-all -->
        <dependency>
            <groupId>com.xiaoleilu</groupId>
            <artifactId>hutool-all</artifactId>
            <version>3.3.2</version>
        </dependency>

/**
 * start
     * 本周開始時間戳
 */
public static Date getWeekStartTime() {
    Calendar calendar = Calendar.getInstance();
    int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
    if (dayOfWeek == 0){
        dayOfWeek = 7;
    }
    calendar.add(Calendar.DATE, - dayOfWeek + 1);

    calendar.set(Calendar.HOUR_OF_DAY, 0);
    //將分鐘至0
    calendar.set(Calendar.MINUTE, 0);
    //將秒至0
    calendar.set(Calendar.SECOND, 0);
    //將毫秒至0
    calendar.set(Calendar.MILLISECOND, 0);
    return calendar.getTime();
}

    /**
         * 獲取當(dāng)前時間的月幾號0點(diǎn)時間或第二天0時間戳(即幾號的24點(diǎn))
     * @param calendar 當(dāng)前時間對象
     * @param day 幾號, 值范圍 是1 到 當(dāng)前時間月天數(shù) + 1 整數(shù), 
         *  傳入(day+1)為day號的第二天0點(diǎn)時間(day號的24點(diǎn)時間),
         *  如果值為當(dāng)前時間月天數(shù)+1則結(jié)果為當(dāng)前月的下個月1號0點(diǎn)(即當(dāng)月最后一天的24點(diǎn)),
         *  如果當(dāng)前月的天數(shù)為31天, 傳入32時則為當(dāng)前月的下個月1號0點(diǎn)(即當(dāng)月最后一天的24點(diǎn))
     * @return
     */
	public static Date getDayOfMonthStartOrEndTime(Calendar calendar, int day) {
	    Calendar calendarTemp = Calendar.getInstance();
	    calendarTemp.setTime(calendar.getTime());
	    int days = getDaysOfMonth(calendarTemp);
	    int limitDays = days + 1;
	    if (day > limitDays) {
	    	calendarTemp.set(Calendar.DAY_OF_MONTH, limitDays);
		} else {
			if (day >= 1) {
				calendarTemp.set(Calendar.DAY_OF_MONTH, day);
			} else {
				calendarTemp.set(Calendar.DAY_OF_MONTH, 1);
			}
		}
	    //將小時至0
	    calendarTemp.set(Calendar.HOUR_OF_DAY, 0);
	    //將分鐘至0
	    calendarTemp.set(Calendar.MINUTE, 0);
	    //將秒至0
	    calendarTemp.set(Calendar.SECOND, 0);
	    //將毫秒至0
	    calendarTemp.set(Calendar.MILLISECOND, 0);

	    //獲得當(dāng)前月幾號0點(diǎn)或幾號的第二天0點(diǎn)(即幾號的24點(diǎn))
	    Date startTime = calendarTemp.getTime();
	   return startTime;
	}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.Time;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;
import java.time.temporal.WeekFields;
import java.util.*;
/**
 * @author hhlm
 * @description: Java日期類型相關(guān)操作類；該類負(fù)責(zé)對日期格式化轉(zhuǎn)換、日期比較、日期加減、潤年判斷、獲 
 * 取相關(guān)的日期信息等。
 *  * @date 2022年03月02日 16:24 
 */
public class DateUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(DateUtil.class);
    public static final long ONE_MINUTE_MILLISECOND = 60 * 1000L;
    public static final long ONE_HOUR_MILLISECOND = 60 * ONE_MINUTE_MILLISECOND;
    /**
     * 一天所對應(yīng)的毫秒數(shù)
     */
    public static final long ONE_DAY_MILLISECOND = 24 * ONE_HOUR_MILLISECOND;
    /**
     * 一周所對應(yīng)的毫秒數(shù)
     */
    public static final long ONE_WEEK_MILLISECOND = 7 * ONE_DAY_MILLISECOND;
    public static final long ONE_MONTH_MILLISECOND = 30 * ONE_DAY_MILLISECOND;
    public static final long ONE_YEAR_MILLISECOND = 365 * ONE_DAY_MILLISECOND;
    private static String defaultDatePattern = null;
    /**
     * 從配置文件中返回配置項(xiàng)"date.format",默認(rèn)的日期格式符 (yyyy-MM-dd)，
     *
     * @return a string representing the date pattern on the UI
     */
    public static synchronized String getDatePattern() {
        defaultDatePattern = "yyyy-MM-dd";
        return defaultDatePattern;
    }
    /**
     * 校驗(yàn)日期入?yún)⑹欠裾_,如防止sql注入
     * @author linjx 2018-12-24
     * @param desc 入?yún)⒌拿枋?
     * @param format
     * @param dateStr notEmptyString
     * @return
     */
    public static Date validDate(String desc, String format, String dateStr) {
        LOGGER.debug("validDate.desc={}, format={}, dateStr={}", desc, format, dateStr);
        Date parse = DateUtil2.parse(dateStr, format, desc);
        /**
            format='yyyy-MM-dd',dateStr='2019-12-15' or '1'='1'是不會有ParseException的
            所以需要將parse重新格式化成字符串,和dateStr比較
         */
        AssertApp.isTrue(dateStr.equals(DateUtil2.format(parse, format)), desc + "異常");
        return parse;
    }
    /**
     * 獲取日期的年份
     *
     * @return 日期的年份
     */
    public static int getYear(Date date) {
        return getCalendar(date).get(Calendar.YEAR);
    }
    /**
     * 獲取日期的月份（0-11）
     *
     * @param date
     * @return 日期的月份（0-11）
     */
    public static int getMonth(Date date) {
        return getCalendar(date).get(Calendar.MONTH);
    }
    /**
     * 獲取日期的一個月中的某天
     *
     * @param date
     * @return 日期的一個月中的某天(1-31)
     */
    public static int getDay(Date date) {
        return getCalendar(date).get(Calendar.DATE);
    }
    /**
     * 獲取日期的一個星期中的某天
     *
     * @param date
     * @return 日期的星期中日期(1:sunday-7:SATURDAY)
     */
    public static int getWeek(Date date) {
        return getCalendar(date).get(Calendar.DAY_OF_WEEK);
    }
    /**
     * 將日期字符串按指定的格式轉(zhuǎn)為Date類型
     *
     * @param strDate 待解析的日期字符串
     * @param format  日期格式
     * @return 字符串對應(yīng)的日期對象
     */
    public static final Date parseDate(String strDate, String format) {
        return DateUtil2.parse(strDate, format, strDate);
    }
    /**
     * 將日期字符串按系統(tǒng)配置中指定默認(rèn)格式(getDatePattern()返回的格式)轉(zhuǎn)為Date類型
     *
     * @param strDate 待解析的日期字符串
     * @return 字符串對應(yīng)的日期對象
     */
    public static Date parseDate(String strDate) {
        return parseDate(strDate, getDatePattern());
    }
    /**
     * <p>檢查所給的年份是否是閏年</p>
     *
     * @param year 年
     * @return 檢查結(jié)果: true - 是閏年; false - 是平年
     */
    public static boolean isLeapYear(int year) {
        if (year / 4 * 4 != year) {
            return false; //不能被4整除
        } else if (year / 100 * 100 != year) {
            return true; //能被4整除，不能被100整除
        } else if (year / 400 * 400 != year) {
            return false; //能被100整除，不能被400整除
        } else {
            return true; //能被400整除
        }
    }
    /**
     * 按照默認(rèn)格式化樣式格式化當(dāng)前系統(tǒng)時間
     *
     * @return 日期字符串
     */
    public static String getCurrentTime() {
        return formatDate(new Date());
    }

    /**
     * 按照默認(rèn)格式化樣式格式化當(dāng)前系統(tǒng)時間
     *
     * @param format String 日期格式化標(biāo)準(zhǔn)
     * @return String 日期字符串。
     */
    public static String getCurrentTime(String format) {
        return formatDate(new Date(), format);
    }
    /**
     * 按照指定格式化樣式格式化指定的日期
     *
     * @param date   待格式化的日期
     * @param format 日期格式
     * @return 日期字符串
     */
    public static String formatDate(Date date, String format) {
        if (date == null) return "";
        if (format == null) format = getDatePattern();
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.format(date);
    }
    /**
     * 按照默認(rèn)格式化樣式格式化指定的日期
     *
     * @param date 待格式化的日期
     * @return 日期字符串
     */
    public static String formatDate(Date date) {
        long offset = System.currentTimeMillis() - date.getTime();
        String pos = "前";
        if (offset < 0) {
            pos = "后";
            offset = -offset;
        }
        if (offset >= ONE_YEAR_MILLISECOND)
            return formatDate(date, getDatePattern());

        StringBuilder sb = new StringBuilder();
        if (offset >= 2 * ONE_MONTH_MILLISECOND) {
            return sb.append((offset + ONE_MONTH_MILLISECOND / 2) / ONE_MONTH_MILLISECOND).append("個月").append(pos).toString();
        }
        if (offset > ONE_WEEK_MILLISECOND) {
            return sb.append((offset + ONE_WEEK_MILLISECOND / 2) / ONE_WEEK_MILLISECOND).append("周").append(pos).toString();
        }
        if (offset > ONE_DAY_MILLISECOND) {
            return sb.append((offset + ONE_DAY_MILLISECOND / 2) / ONE_DAY_MILLISECOND).append("天").append(pos).toString();
        }
        if (offset > ONE_HOUR_MILLISECOND) {
            return sb.append((offset + ONE_HOUR_MILLISECOND / 2) / ONE_HOUR_MILLISECOND).append("小時").append(pos).toString();
        }
        if (offset > ONE_MINUTE_MILLISECOND) {
            return sb.append((offset + ONE_MINUTE_MILLISECOND / 2) / ONE_MINUTE_MILLISECOND).append("分鐘").append(pos).toString();
        }
        return sb.append(offset / 1000).append("秒").append(pos).toString();
    }
    /**
     * 將date的時間部分清零
     *
     * @param day
     * @return 返回Day將時間部分清零后對應(yīng)日期
     */
    public static Date getCleanDay(Date day) {
        return getCleanDay(getCalendar(day));
    }

    /**
     * 設(shè)置當(dāng)天最后時間
     *
     * @param day
     * @return 返回當(dāng)天最后時間
     */
    public static Date getEndDay(Date day) {
        Calendar c = Calendar.getInstance();
        c.setTime(day);
        c.set(Calendar.HOUR_OF_DAY, 23);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        c.set(Calendar.MILLISECOND, 999);
        return c.getTime();
    }
    /**
     * 獲取day對應(yīng)的Calendar對象
     *
     * @param day
     * @return 返回date對應(yīng)的Calendar對象
     */
    public static Calendar getCalendar(Date day) {
        Calendar c = Calendar.getInstance();
        if (day != null)
            c.setTime(day);
        return c;
    }
    public static Date getCleanDay(Calendar c) {
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.clear(Calendar.MINUTE);
        c.clear(Calendar.SECOND);
        c.clear(Calendar.MILLISECOND);
        return c.getTime();
    }
    /**
     * 根據(jù)year，month，day構(gòu)造日期對象
     *
     * @param year  年份（4位長格式）
     * @param month 月份（1-12)
     * @param day   天（1-31）
     * @return 日期對象
     */
    public static Date makeDate(int year, int month, int day) {
        Calendar c = Calendar.getInstance();
        getCleanDay(c);
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, month - 1);
        c.set(Calendar.DAY_OF_MONTH, day);
        return c.getTime();
    }
    private static Date getFirstCleanDay(int datePart, Date date) {
        Calendar c = Calendar.getInstance();
        if (date != null)
            c.setTime(date);
        c.set(datePart, 1);
        return getCleanDay(c);
    }
    /**
     * Calendar.YEAR :1則代表的是對年份操作，
     * Calendar.MONTH :2是對月份操作;
     * Calendar.DATE : 5是對日期操作;
     * @param datePart
     * @param detal
     * @param date
     * @return
     */
    public static Date add(int datePart, int detal, Date date) {
        Calendar c = Calendar.getInstance();
        if (date != null)
            c.setTime(date);
        c.add(datePart, detal);
        return c.getTime();
    }
    /**
     * 日期date所在星期的第一天00:00:00對應(yīng)日期對象
     *
     * @param date
     * @return 日期所在星期的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfWeek(Date date) {
        return getFirstCleanDay(Calendar.DAY_OF_WEEK, date);
    }
    /**
     * 當(dāng)前日期所在星期的第一天00:00:00對應(yīng)日期對象
     *
     * @return 當(dāng)前日期所在星期的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfWeek() {
        return getFirstDayOfWeek(null);
    }
    /**
     * 日期date所在月份的第一天00:00:00對應(yīng)日期對象
     *
     * @param date
     * @return 日期所在月份的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfMonth(Date date) {
        return getFirstCleanDay(Calendar.DAY_OF_MONTH, date);
    }
    /**
     * 當(dāng)前日期所在月份的第一天00:00:00對應(yīng)日期對象
     *
     * @return 當(dāng)前日期所在月份的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfMonth() {
        return getFirstDayOfMonth(null);
    }
    /**
     * 日期date所在月份的最后一天23, 59, 59對應(yīng)日期對象
     *
     * @param date
     * @return 日期date所在月份的最后一天23, 59, 59對應(yīng)日期對象
     */
    public static Date getLastDayOfMonth(Date date) {
        Calendar cal = Calendar.getInstance();  
        cal.setTime(date);
        int MaxDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), MaxDay, 23, 59, 59);
        return cal.getTime();
    }

    /**
     * 日期date所在季度的第一天00:00:00對應(yīng)日期對象
     *
     * @param date
     * @return 日期date所在季度的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfSeason(Date date) {
        Date d = getFirstDayOfMonth(date);
        int delta = DateUtil.getMonth(d) % 3;
        if (delta > 0)
            d = DateUtil.getDateAfterMonths(d, -delta);
        return d;
    }
    /**
     * 當(dāng)前日期所在季度的第一天00:00:00對應(yīng)日期對象
     *
     * @return 當(dāng)前日期所在季度的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfSeason() {
        return getFirstDayOfMonth(null);
    }
    /**
     * 日期date所在年份的第一天00:00:00對應(yīng)日期對象
     *
     * @param date
     * @return 日期date所在年份的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfYear(Date date) {
        return makeDate(getYear(date), 1, 1);
    }
    /**
     * 獲取某年的第一天
     * @param year
     * @return 日期date所在年份的第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDaylOfYear(int year){
        return makeDate(year, 1, 1);
    }
    /**
     * 當(dāng)前日期年度的第一天00:00:00對應(yīng)日期對象
     *
     * @return 當(dāng)前日期年度第一天00:00:00對應(yīng)日期對象
     */
    public static Date getFirstDayOfYear() {
        return getFirstDayOfYear(new Date());
    }

    /**
     * 當(dāng)前日期年度的最后一天23:59:59對應(yīng)日期對象
     *
     * @return 當(dāng)前日期年度的最后一天23:59:59對應(yīng)日期對象
     */
    public static Date getLastDayOfYear() {
        return parseDate(getYear(new Date()) + "-12-31 23:59:59", "yyyy-MM-dd HH:mm:ss");
    }
    /**
     * 獲取某年最后一天
     * @return  傳入年份的最后一天23:59:59對應(yīng)日期對象
     */
    public static Date getLastDayOfYear(int year){
        return DateUtil2.parse(year + "-12-31 23:59:59", "yyyy-MM-dd HH:mm:ss", "");
    }
    /**
     * 計(jì)算N周后的日期
     *
     * @param start 開始日期
     * @param weeks 可以為負(fù)，表示前N周
     * @return 新的日期
     */
    public static Date getDateAfterWeeks(Date start, int weeks) {
        return getDateAfterMs(start, weeks * ONE_WEEK_MILLISECOND);
    }

    /**
     * 計(jì)算N月后的日期, 特殊情況:如果是'2016-1-31'一個月后是  '2017-2-28'
     *
     * @param start  開始日期
     * @param months 可以為負(fù)，表示前N月
     * @return 新的日期
     */
    public static Date getDateAfterMonths(Date start, int months) {
        return add(Calendar.MONTH, months, start);
    }
    /**
     * 計(jì)算N年后的日期, 特殊情況:如果是'2016-2-29'一年后是'2017-2-28'
     *
     * @param start 開始日期
     * @param years 可以為負(fù)，表示前N年
     * @return 新的日期
     */
    public static Date getDateAfterYears(Date start, int years) {
        return add(Calendar.YEAR, years, start);
    }
    /**
     * 計(jì)算N天后的日期
     *
     * @param start 開始日期
     * @param days  可以為負(fù)，表示前N天
     * @return 新的日期
     */
    public static Date getDateAfterDays(Date start, int days) {
        return getDateAfterMs(start, days * ONE_DAY_MILLISECOND);
    }
    /**
     * 計(jì)算N毫秒后的日期
     *
     * @param start 開始日期
     * @param ms    可以為負(fù)，表示前N毫秒
     * @return 新的日期
     */
    public static Date getDateAfterMs(Date start, long ms) {
        return new Date(start.getTime() + ms);
    }
    /**
     * 計(jì)算2個日期之間的間隔的周期數(shù)
     *
     * @param start    開始日期
     * @param end      結(jié)束日期
     * @param msPeriod 單位周期的毫秒數(shù)
     * @return 周期數(shù)
     */
    public static long getPeriodNum(Date start, Date end, long msPeriod) {
        return getIntervalMs(start, end) / msPeriod;
    }
    /**
     * 計(jì)算2個日期之間的毫秒數(shù)
     *
     * @param start 開始日期
     * @param end   結(jié)束日期
     * @return 毫秒數(shù)
     */
    public static long getIntervalMs(Date start, Date end) {
        return end.getTime() - start.getTime();
    }
    /**
     * 計(jì)算2個日期之間的天數(shù)
     *
     * @param start 開始日期
     * @param end   結(jié)束日期
     * @return 天數(shù)
     */
    public static int getIntervalDays(Date start, Date end) {
        return (int) getPeriodNum(start, end, ONE_DAY_MILLISECOND);
    }
    /**
     * 計(jì)算2個日期之間的周數(shù)
     *
     * @param start 開始日期
     * @param end   結(jié)束日期
     * @return 周數(shù)
     */
    public static int getIntervalWeeks(Date start, Date end) {
        return (int) getPeriodNum(start, end, ONE_WEEK_MILLISECOND);
    }
    /**
     * 比較日期前后關(guān)系
     *
     * @param base 基準(zhǔn)日期
     * @param date 待比較的日期
     * @return 如果date在base之前或相等返回true，否則返回false
     */
    public static boolean before(Date base, Date date) {
        return date.before(base) || date.equals(base);
    }
    /**
     * 比較日期前后關(guān)系
     *
     * @param base 基準(zhǔn)日期
     * @param date 待比較的日期
     * @return 如果date在base之后或相等返回true，否則返回false
     */
    public static boolean after(Date base, Date date) {
        return date.after(base) || date.equals(base);
    }
    /**
     * 返回對應(yīng)毫秒數(shù)大的日期
     *
     * @param date1
     * @param date2
     * @return 返回對應(yīng)毫秒數(shù)大的日期
     */
    public static Date max(Date date1, Date date2) {
        if (date1.getTime() > date2.getTime())
            return date1;
        else
            return date2;
    }
    /**
     * 返回對應(yīng)毫秒數(shù)小的日期
     *
     * @param date1
     * @param date2
     * @return 返回對應(yīng)毫秒數(shù)小的日期
     */
    public static Date min(Date date1, Date date2) {
        if (date1.getTime() < date2.getTime())
            return date1;
        else
            return date2;
    }
    /**
     * 判斷date是否在指定的時期范圍（start~end）內(nèi)
     *
     * @param start 時期開始日期
     * @param end   時期結(jié)束日期
     * @param date  待比較的日期
     * @return 如果date在指定的時期范圍內(nèi)，返回true，否則返回false
     */
    public static boolean inPeriod(Date start, Date end, Date date) {
        return (end.after(date) || end.equals(date)) && (start.before(date) || start.equals(date));
    }

    /**
     * 獲取當(dāng)前日期是星期幾<br>
     *
     * @param dt
     * @return 當(dāng)前日期是星期幾
     */
    public static String getWeekOfDate(Date dt) {
        String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        Calendar cal = Calendar.getInstance();
        cal.setTime(dt);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0)
            w = 0;
        return weekDays[w];
    }
    private static final DateTimeFormatter SHORT_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter LONG_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final TemporalField CHINA_DAY_OF_WEEK = WeekFields.of(Locale.CHINA).dayOfWeek();
    /**
     * 獲取指定日期所在周的第一天
     *
     * @param date
     * @return
     */
    public static LocalDate firstDayOfWeek(TemporalAccessor date) {
        return LocalDate.from(date).with(CHINA_DAY_OF_WEEK, 1);
    }
    /**
     * 獲取指定日期所在周的最后一天
     *
     * @param date
     * @return
     */
    public static LocalDate lastDayOfWeek(TemporalAccessor date) {
        return LocalDate.from(date).with(CHINA_DAY_OF_WEEK, 7);
    }
    /**
     * 獲取指定日期所在月的第一天
     *
     * @param date
     * @return
     */
    public static LocalDate firstDayOfMonth(TemporalAccessor date) {
        return LocalDate.from(date).withDayOfMonth(1);
    }
    /**
     * 獲取指定日期所在周的最后一天
     *
     * @param date
     * @return
     */
    public static LocalDate lastDayOfMonth(TemporalAccessor date) {
        return LocalDate.from(date).plusMonths(1).withDayOfMonth(1).plusDays(-1);
    }

    /**
     * 短日期格式
     *
     * @param date
     * @return
     */
    public static String shortString(TemporalAccessor date) {
        return SHORT_DATETIME_FORMATTER.format(date);
    }
    /**
     * 長日期格式
     *
     * @param date
     * @return
     */
    public static String longString(TemporalAccessor date) {
        return LONG_DATETIME_FORMATTER.format(date);
    }
    /**
     * 將指定定的日期轉(zhuǎn)換成LocalDateTime
     *
     * @param date
     * @return
     */
    public static LocalDateTime asLocalDateTime(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    }

    /**
     * 將指定定的日期轉(zhuǎn)換成LocalDate
     *
     * @param date
     * @return
     */
    public static LocalDate asLocalDate(Date date) {
        return asLocalDateTime(date).toLocalDate();
    }
    /**
     * LocalDate 轉(zhuǎn)為 Date
     *
     * @param localDate
     * @return
     */
    public static Date asDate(LocalDate localDate) {
        return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
    }
    /**
     * LocalDateTime 轉(zhuǎn)為 Date
     *
     * @param localDateTime
     * @return
     */
    public static Date asDate(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 按照“年-月”生成當(dāng)月的工作日
     * @param yearMonth [yyyy-MM]
     * @return
     */
    public static List<Date> getWorkdayOfMonth(String yearMonth){
    	int year;
    	int month ; 
    	List<Date> results = new ArrayList<>();
    	Calendar cal = Calendar.getInstance();
    	String[] splitStr = yearMonth.split("-");
    	year = Integer.parseInt(splitStr[0]);
		month = Integer.parseInt(splitStr[1]);
		cal.set(Calendar.YEAR, year);
    	cal.set(Calendar.MONTH, month - 1);
    	cal.set(Calendar.DATE, 1);
    	while(cal.get(Calendar.YEAR) == year && 
    			cal.get(Calendar.MONTH) < month){
    		int day = cal.get(Calendar.DAY_OF_WEEK);
    		if(!(day == Calendar.SUNDAY || day == Calendar.SATURDAY)){
    			results.add((Date) cal.getTime().clone());
    		}
    		cal.add(Calendar.DATE, 1);
    	}
    	return results;
    }
    /**
     * 按照年份生成一年內(nèi)的工作日
     * @param year
     * @return
     */
    public static List<Date> getWorkdayOfYear(int year){
    	List<Date> results = new ArrayList<>();
    	Calendar cal = Calendar.getInstance();
    	cal.set(Calendar.YEAR, year);
    	cal.set(Calendar.MONTH, 0);
    	cal.set(Calendar.DATE, 1);
    	while(cal.get(Calendar.YEAR) == year){
    		int day = cal.get(Calendar.DAY_OF_WEEK);
    		if(!(day == Calendar.SUNDAY || day == Calendar.SATURDAY)){
    			results.add((Date) cal.getTime().clone());
    		}
    		cal.add(Calendar.DATE, 1);
    	}
		return results;
    }
    /**
     * 獲取上一個月的第一天時間
     */
    public static Date getFirstDayOfLastMonth(){
        Calendar cal = Calendar.getInstance();//獲取當(dāng)前日期 
        /*
         * 2018-03-31時通過測試:
         * 不設(shè)置cal.set(Calendar.DAY_OF_MONTH, 1)時,得到的日期是2018-02-28而不是3月
         */
        cal.add(Calendar.MONTH, -1);
        cal.set(Calendar.DAY_OF_MONTH, 1);//設(shè)置為1號,當(dāng)前日期既為本月第一天 
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.clear(Calendar.MINUTE);
        cal.clear(Calendar.SECOND);
        cal.clear(Calendar.MILLISECOND);
        return cal.getTime();
    }
    /**
     * 獲取指定日期的上月一號
     * @param date
     * @return
     */
    public static Date getLastMonthFirst(Date date) {
        Calendar c = Calendar.getInstance();//獲取當(dāng)前日期 
        c.setTime(date);
        c.add(Calendar.MONTH, -1);
        c.set(Calendar.DAY_OF_MONTH, 1);// 設(shè)置為1號
        return getCleanDay(c);
    }
    /**
     * 獲取上月月末
     * @param date
     * @return
     */
    public static Date getLastMonthEnd(Date date) {
        Calendar c = Calendar.getInstance();//獲取當(dāng)前日期 
        c.setTime(date);
        c.add(Calendar.MONTH, -1);
        int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), maxDay, 23, 59, 59);
        return getCleanDay(c);
    }
    public static Date getLastMonthDay(Date date, int day) {
        Calendar c = Calendar.getInstance();//獲取當(dāng)前日期 
        c.setTime(date);
        c.add(Calendar.MONTH, -1);
        c.set(Calendar.DAY_OF_MONTH, day);// 設(shè)置為1號
        return getCleanDay(c);
    }
    /**
     * 本月月末
     * @param date
     * @return
     */
    public static Date getMonthEnd(Date date) {
        Calendar c = Calendar.getInstance();//獲取當(dāng)前日期 
        c.setTime(date);
        int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), maxDay, 23, 59, 59);
        return getCleanDay(c);
    }
    /**
     * 獲取下月1號
     * @param date
     * @return
     */
    public static Date getNextMonthFirst(Date date) {
        Calendar c = Calendar.getInstance();//獲取當(dāng)前日期 
        c.setTime(date);
        c.add(Calendar.MONTH, 1);
        c.set(Calendar.DAY_OF_MONTH, 1);// 設(shè)置為1號
        return getCleanDay(c);
    }
    /**
     * 獲取下月 月末
     * @param date
     * @return
     */
    public static Date getNextMonthEnd(Date date) {
        Calendar c = Calendar.getInstance();//獲取當(dāng)前日期 
        c.setTime(date);
        c.add(Calendar.MONTH, 1);
        int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), maxDay, 23, 59, 59);
        return getCleanDay(c);
    }
    /**
     * 判斷兩個日期之間是否為一整年
     * @param start
     * @param end
     * @return
     */
    public static boolean isOneYear(Date start, Date end) {
        Calendar startday = Calendar.getInstance();
        Calendar endday = Calendar.getInstance();
        startday.setTime(start);
        endday.setTime(end);
        if (startday.after(endday)) {
            return false;
        }
        long sl = startday.getTimeInMillis();
        long el = endday.getTimeInMillis();
        long days = ((el - sl) / (1000 * 60 * 60 * 24));
        if (days == 365 || days == 366) {
            if (startday.get(Calendar.MONTH) <= 1) {
                startday.set(Calendar.MONTH, 1);
                int lastDay = startday.getActualMaximum(Calendar.DAY_OF_MONTH);
                return (lastDay == 28 && days == 365) || (lastDay == 29 && days == 366);
            } else {
                endday.set(Calendar.MONTH, 1);
                int lastDay = endday.getActualMaximum(Calendar.DAY_OF_MONTH);
                return (lastDay == 28 && days == 365) || (lastDay == 29 && days == 366);
            }
        } else {
            return false;
        }
    }
    /**
     * @return 上一天Date
     */
    public static Date getPreviousDate(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        int day = c.get(Calendar.DATE);
        c.set(Calendar.DATE, day - 1);
        return c.getTime();
    }
    
    /**
     * @return 后一天Date
     */
    public static Date getNextDate(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        int day = c.get(Calendar.DATE);
        c.set(Calendar.DATE, day + 1);
        return c.getTime();
    }
    /**
     * 判斷兩個時間是否在同一天
     * @param date1
     * @param Date2
     * @return
     */
    public static boolean inSameDay(Date date1, Date Date2) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date1);
        int year1 = calendar.get(Calendar.YEAR);
        int day1 = calendar.get(Calendar.DAY_OF_YEAR);

        calendar.setTime(Date2);
        int year2 = calendar.get(Calendar.YEAR);
        int day2 = calendar.get(Calendar.DAY_OF_YEAR);
        if ((year1 == year2) && (day1 == day2)) {
            return true;
        }
        return false;
    }
    /**
     * 傳入多少分鐘
     * 獲取兩個時間的差值，有多少個小時，用于計(jì)算請了多少小時假
     * 尾數(shù)不足0.5小時按0.5小時計(jì)，超過0.5小時按1小時計(jì)
     * * ((int) diff / 30) 有n個半小時要轉(zhuǎn)int
     * 最后 如果余數(shù)不為0 就要補(bǔ)上0.5
     * return 單位：小時
     */
    public static double getLeaveValue(double differenceValue){
        double needLeaveTs = ((int)(differenceValue / 30))*0.5;
        if(differenceValue % 30 != 0) needLeaveTs+= 0.5;
        return needLeaveTs;
    }
    /**
     * 傳入一個日期
     * 打卡開始時間在下午，開始時間與14:00上班時間請多少個小時
     */
    public static double getLeaveValue(Date startTime){
        double hour = startTime.getHours();
        double minute = startTime.getMinutes();
        double needLeaveTs = ((int)(minute / 30))*0.5;
        if(minute % 30 != 0) needLeaveTs += 0.5;
        needLeaveTs += hour - 14;
        return needLeaveTs;
    }
    /**
     * 獲取指定日期下午上班時間
     * @param date
     * @return
     */
    public static Date getGotoWorkAfternoon(Date date){
        return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date)+" 14:00:00", "yyyy-MM-dd HH:mm:ss");
    }
       /**
     * 根據(jù)傳進(jìn)來的Time和Date，獲取到那天對應(yīng)完成日期
     * @param date
     * @param time
     * @return
     */
    public static Date getDateByTime(Date date, Time time){
        int hour = time.getHours();
        int minutes = time.getMinutes();
        int seconds = time.getSeconds();
        String timeStr = " " + hour + ":" + minutes + ":" + seconds;

        return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date) + timeStr, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 獲取XX:XX:XX的時間字符串
     * @param t 秒
     * @return [XX:XX:XX],[XX:XX]
     */
    public static String getTimeSpanStr(int t) {
        StringBuilder sb = new StringBuilder();
        if(t >= 3600) {
            int h = t / 3600;
            if(h < 10) sb.append("0");
            sb.append(h + ":");
        }
        if(t >= 60) {
            int m = t%3600/60;
            if(m < 10) sb.append("0");
            sb.append(m + ":");
        }
        int s = t%60;
        if(s < 10) sb.append("0");
        sb.append(s);
        return sb.toString();
    }
    /**
     * 根據(jù)傳入日期獲取目標(biāo)日期
     * @param date nullable 原始日期
     * @param monthDiff nullable 月份偏移量
     * @param dayOfMonth nullable 當(dāng)月幾號
     * @return null if date is null
     */
    public static Date getDiffDate(Date date, Integer monthDiff, Integer dayOfMonth) {
        if(date == null)
            return null;
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        if(monthDiff == null)
            monthDiff = 0;
        int month = c.get(Calendar.MONTH) + monthDiff;
        c.set(Calendar.MONTH, month);
        if(dayOfMonth != null)
            c.set(Calendar.DAY_OF_MONTH, dayOfMonth);
        return c.getTime();
    }
    /**
     * 獲取n天[前/后]的日期
     * @return
     */
    public static Date getDiffDay(Date date, Integer diffDay) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.DAY_OF_YEAR, diffDay);
        return c.getTime();
    }

    /**
     * @param d1 notNull
     * @param d2 notNull
     * @return 是否是同一個月
     */
    public static boolean isSameMonth(Date d1, Date d2) {
        Calendar c = Calendar.getInstance();
        c.setTime(d1);
        int y1 = c.get(Calendar.YEAR);
        int m1 = c.get(Calendar.MONTH);
        c.setTime(d2);
        int y2 = c.get(Calendar.YEAR);
        int m2 = c.get(Calendar.MONTH);
        return y1 == y2 && m1 == m2;
    }
    /**
     * @param d1 notNull
     * @param d2 notNull
     * @return 是否是同一天
     */
    public static boolean isSameDay(Date d1, Date d2) {
        Calendar c = Calendar.getInstance();
        c.setTime(d1);
        int y1 = c.get(Calendar.YEAR);
        int m1 = c.get(Calendar.MONTH);
        int day1 = c.get(Calendar.DAY_OF_MONTH);
        c.setTime(d2);
        int y2 = c.get(Calendar.YEAR);
        int m2 = c.get(Calendar.MONTH);
        int day2 = c.get(Calendar.DAY_OF_MONTH);
        return y1 == y2 && m1 == m2 && day1 == day2;
    }
    /**
     * @return d1>=d2
     */
    public static boolean greaterThanOrEqualTo(Date d1, Date d2) {
        return d1.compareTo(d2) >= 0;
    }
    /**
     * @return d1<=d2
     */
    public static boolean lessThanOrEqualTo(Date d1, Date d2) {
        return d1.compareTo(d2) <= 0;
    }
    /**
     * @return d1>d2
     */
    public static boolean greaterThan(Date d1, Date d2) {
        return d1.compareTo(d2) > 0;
    }
    /**
     * 獲取某個月的實(shí)際最大天數(shù), 如2016-02, 最大天數(shù)為29
     */
    public static int getMaximum(Date date) {
    	Calendar c = Calendar.getInstance();
    	c.setTime(date);
    	return c.getActualMaximum(Calendar.DAY_OF_MONTH);
    }
    public static Date getFirstDayOfWeek(int year, int week) {
        Calendar c = Calendar.getInstance();
        c.set(year, Calendar.JANUARY, 1, 0, 0, 0);//定到第一天
        c.add(Calendar.DATE, (week - 1) * 7);//直接add天數(shù)
        c.setFirstDayOfWeek(Calendar.SUNDAY);
        c.setTime(c.getTime());//必須先set一次time,否則是錯誤的!
        c.set(Calendar.DAY_OF_WEEK, 1);
        return c.getTime();
    }
    public static Date getHalfPastNineDateTime(Date date){
        return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date)+" 9:30:00", "yyyy-MM-dd HH:mm:ss");
    }
    public static Date getTenOClockDateTime(Date date){
        return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date)+" 9:30:00", "yyyy-MM-dd HH:mm:ss")

public void testDateFormatter() {
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 日期轉(zhuǎn)字符串
    String format = simpleDateFormat.format(new Date());
    System.out.println("當(dāng)前時間：" + format);
    try {
        // 字符串轉(zhuǎn)日期
        Date parseDate = simpleDateFormat.parse("2022-07-08 06:19:27");
        System.out.println("轉(zhuǎn)換后Date對象： " + parseDate);
        // 按照指定的時區(qū)進(jìn)行轉(zhuǎn)換，可以對比下前面轉(zhuǎn)換后的結(jié)果，會發(fā)現(xiàn)不一樣
        simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+5:00"));
        parseDate = simpleDateFormat.parse("2022-07-08 06:19:27");
        System.out.println("指定時區(qū)轉(zhuǎn)換后Date對象： " + parseDate);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

當(dāng)前時間：2022-07-08 06:25:31
轉(zhuǎn)換后Date對象： Fri Jul 08 06:19:27 CST 2022
指定時區(qū)轉(zhuǎn)換后Date對象： Fri Jul 08 09:19:27 CST 2022

public void testDateFormatter() {
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    LocalDateTime localDateTime = LocalDateTime.now();
    // 格式化為字符串
    String format = localDateTime.format(dateTimeFormatter);
    System.out.println("當(dāng)前時間：" + format);
    // 字符串轉(zhuǎn)Date
    LocalDateTime parse = LocalDateTime.parse("2022-07-08 06:19:27", dateTimeFormatter);
    Date date = Date.from(parse.atZone(ZoneId.systemDefault()).toInstant());
    System.out.println("轉(zhuǎn)換后Date對象： " + date);
}

spring.datasource.druid.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/Shanghai

spring.jackson.time-zone=GMT+8