使用jdk8 time API的日期工具类

青旅半醒 2021-11-27 06:38 280阅读 0赞

import java.time.\*;  
import java.time.format.DateTimeFormatter;  
import java.time.temporal.ChronoField;  
import java.time.temporal.ChronoUnit;  
import java.time.temporal.TemporalAccessor;  
import java.time.temporal.TemporalAdjusters;  
import java.util.Date;

/\*\*  
 \* 日期工具类  
 \* 针对入参是Date,long,string有三套函数  
 \* 使用jdk8的新时间API  
 \*\*/  
public class DateUtil \{

public static final DateTimeFormatter DATE\_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");  
    public static final DateTimeFormatter TIME\_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

private static final String TIME\_SUBFIX = " 00:00:00";

/\*\*  
     \* 按传入的格式 返回格式化的当前日期  
     \*  
     \* @param pattern  
     \* @return  
     \*/  
    public static String currentDayStr(String pattern) \{  
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);  
        return formatter.format(LocalDateTime.now());  
    \}

/\*\*  
     \* 按传入的格式 返回格式化的传入日期  
     \*  
     \* @param pattern  
     \* @return  
     \*/  
    public static String currentDayStr(Date date, String pattern) \{  
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);  
        return formatter.format(date.toInstant());  
    \}

/\*\*  
     \* 判断当前日期和传入日期是否是同一个月  
     \*  
     \* @param data  
     \* @return  
     \*/  
    public static boolean isCurrentMonth(Date data) \{  
        LocalDate nowDate = LocalDate.now();  
        LocalDate otherDate = data.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();  
        return nowDate.getMonth().equals(otherDate.getMonth());  
    \}

/\*\*  
     \* 判断传入日期和当前日期是否是同一天  
     \*  
     \* @param data  
     \* @return  
     \*/  
    public static boolean isCurrentDay(Date data) \{  
        LocalDate nowDate = LocalDate.now();  
        LocalDate otherDate = data.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();  
        return nowDate.getDayOfYear() == otherDate.getDayOfYear();  
    \}

/\*\*  
     \* 返回传入日期的下一天日期，时分秒和当前日期相同  
     \*  
     \* @param currentDate 当前日期  
     \* @return  
     \*/  
    public static LocalDateTime nextDay(Date currentDate) \{  
        Instant instant = currentDate.toInstant().plus(Period.ofDays(1));  
        return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());  
    \}

/\*\*  
     \* 返回传入日期的上一天日期，时分秒和当前日期相同  
     \*  
     \* @param currentDate 当前日期  
     \* @return  
     \*/  
    public static LocalDateTime previousDay(Date currentDate) \{  
        Instant instant = currentDate.toInstant().minus(Period.ofDays(1));  
        return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());  
    \}

/\*\*  
     \* 返回传入日期当月的第一天日期，时分秒和当前日期相同  
     \*  
     \* @param currentDate  
     \* @return  
     \*/  
    public static LocalDateTime firstDayOfMonth(Date currentDate) \{  
        return currentDate.toInstant()  
                .atZone(ZoneId.systemDefault()).toLocalDateTime()  
                .with(TemporalAdjusters.firstDayOfMonth());  
    \}

/\*\*  
     \* 返回传入日期当月的最后一天日期，时分秒和当前日期相同  
     \*  
     \* @param currentDate  
     \* @return  
     \*/  
    public static LocalDateTime lastDayOfMonth(Date currentDate) \{  
        return currentDate.toInstant()  
                .atZone(ZoneId.systemDefault()).toLocalDateTime()  
                .with(TemporalAdjusters.lastDayOfMonth());  
    \}

/\*\*  
     \* 返回传入日期的当天开始 时分秒都是0  
     \*  
     \* @param now  
     \* @return  
     \*/  
    public static LocalDateTime startOfDay(Date now) \{  
        return now.toInstant()  
                .atZone(ZoneId.systemDefault()).toLocalDateTime()  
                .with(ChronoField.MILLI\_OF\_DAY, 0);  
    \}

/\*\*  
     \* 返回传入日期的当天结束 也是第二天的开始时间  
     \*  
     \* @param now  
     \* @return  
     \*/  
    public static LocalDateTime endOfDay(Date now) \{  
        return now.toInstant()  
                .atZone(ZoneId.systemDefault()).toLocalDateTime()  
                .with(ChronoField.MILLI\_OF\_DAY, 0)  
                .plus(1, ChronoUnit.DAYS);  
    \}

/\*\*  
     \* 判断当前日期和传入日期是否是同一个月  
     \*  
     \* @param data  
     \* @return  
     \*/  
    public static boolean isCurrentMonth(String data) \{  
        LocalDate nowDate = LocalDate.now();  
        TemporalAccessor otherDate = DATE\_FORMATTER.parse(data);  
        if (!otherDate.isSupported(ChronoField.MONTH\_OF\_YEAR)) \{  
            return false;  
        \}  
        return nowDate.getMonth().getValue() == (otherDate.get(ChronoField.MONTH\_OF\_YEAR));

/\*\*  
     \* 判断传入日期和当前日期是否是同一天  
     \*  
     \* @param data  
     \* @return  
     \*/  
    public static boolean isCurrentDay(String data) \{  
        LocalDate nowDate = LocalDate.now();  
        TemporalAccessor otherDate = DATE\_FORMATTER.parse(data);  
        if (!otherDate.isSupported(ChronoField.DAY\_OF\_YEAR)) \{  
            return false;  
        \}  
        return nowDate.getDayOfYear() == (otherDate.get(ChronoField.DAY\_OF\_YEAR));

/\*\*  
     \* 返回传入日期的下一天日期，时分秒和当前日期相同  
     \*  
     \* @param date         日期格式 yyyy-MM-dd 或者 yyyy-MM-dd HH:mm:ss  
     \* @param needTimePart 如果传入格式是 yyyy-MM-dd,则传入true，格式是yyyy-MM-dd HH:mm:ss 传入false  
     \* @return  
     \*/  
    public static LocalDateTime nextDay(String date, boolean needTimePart) \{  
        if (needTimePart) \{  
            date = date.concat(TIME\_SUBFIX);  
        \}  
        LocalDateTime dateTime = LocalDateTime.parse(date, TIME\_FORMATTER);  
        return dateTime.plus(Period.ofDays(1));  
    \}

/\*\*  
     \* 返回传入日期的上一天日期，时分秒和当前日期相同  
     \*  
     \* @param date         日期格式 yyyy-MM-dd 或者 yyyy-MM-dd HH:mm:ss  
     \* @param needTimePart 如果传入格式是 yyyy-MM-dd,则传入true，格式是yyyy-MM-dd HH:mm:ss 传入false  
     \* @return  
     \*/  
    public static LocalDateTime previousDay(String date, boolean needTimePart) \{  
        if (needTimePart) \{  
            date = date.concat(TIME\_SUBFIX);  
        \}  
        LocalDateTime dateTime = LocalDateTime.parse(date, TIME\_FORMATTER);  
        return dateTime.minus(Period.ofDays(1));  
    \}

/\*\*  
     \* 返回传入日期当月的第一天日期，时分秒和当前日期相同  
     \*  
     \* @param date         日期格式 yyyy-MM-dd 或者 yyyy-MM-dd HH:mm:ss  
     \* @param needTimePart 如果传入格式是 yyyy-MM-dd,则传入true，格式是yyyy-MM-dd HH:mm:ss 传入false  
     \* @return  
     \*/  
    public static LocalDateTime firstDayOfMonth(String date, boolean needTimePart) \{  
        if (needTimePart) \{  
            date = date.concat(TIME\_SUBFIX);  
        \}  
        LocalDateTime dateTime = LocalDateTime.parse(date, TIME\_FORMATTER);  
        return dateTime.with(TemporalAdjusters.firstDayOfMonth());  
    \}

/\*\*  
     \* 返回传入日期当月的最后一天日期，时分秒和当前日期相同  
     \*  
     \* @param date         日期格式 yyyy-MM-dd 或者 yyyy-MM-dd HH:mm:ss  
     \* @param needTimePart 如果传入格式是 yyyy-MM-dd,则传入true，格式是yyyy-MM-dd HH:mm:ss 传入false  
     \* @return  
     \*/  
    public static LocalDateTime lastDayOfMonth(String date, boolean needTimePart) \{  
        if (needTimePart) \{  
            date = date.concat(TIME\_SUBFIX);  
        \}  
        LocalDateTime dateTime = LocalDateTime.parse(date, TIME\_FORMATTER);  
        return dateTime.with(TemporalAdjusters.lastDayOfMonth());  
    \}

/\*\*  
     \* 返回传入日期的当天开始 时分秒都是0  
     \*  
     \* @param date         日期格式 yyyy-MM-dd 或者 yyyy-MM-dd HH:mm:ss  
     \* @param needTimePart 如果传入格式是 yyyy-MM-dd,则传入true，格式是yyyy-MM-dd HH:mm:ss 传入false  
     \* @return  
     \*/  
    public static LocalDateTime startOfDay(String date, boolean needTimePart) \{  
        if (needTimePart) \{  
            date = date.concat(TIME\_SUBFIX);  
        \}  
        LocalDateTime dateTime = LocalDateTime.parse(date, TIME\_FORMATTER);  
        return dateTime.with(ChronoField.MILLI\_OF\_DAY, 0);  
    \}

/\*\*  
     \* 返回传入日期的当天结束 也是第二天的开始时间  
     \*  
     \* @param date         日期格式 yyyy-MM-dd 或者 yyyy-MM-dd HH:mm:ss  
     \* @param needTimePart 如果传入格式是 yyyy-MM-dd,则传入true，格式是yyyy-MM-dd HH:mm:ss 传入false  
     \* @return  
     \*/  
    public static LocalDateTime endOfDay(String date, boolean needTimePart) \{  
        if (needTimePart) \{  
            date = date.concat(TIME\_SUBFIX);  
        \}  
        LocalDateTime dateTime = LocalDateTime.parse(date, TIME\_FORMATTER);  
        return dateTime.with(ChronoField.MILLI\_OF\_DAY, 0)  
                .plus(1, ChronoUnit.DAYS);  
    \}

/\*\*  
     \* 按传入的格式 返回格式化的传入日期  
     \*  
     \* @param pattern  
     \* @return  
     \*/  
    public static String currentDayStr(long timeStamp, String pattern) \{  
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);  
        return formatter.format(new Date(timeStamp).toInstant());  
    \}

/\*\*  
     \* 判断当前日期和传入日期是否是同一个月  
     \*  
     \* @param timeStamp  
     \* @return  
     \*/  
    public static boolean isCurrentMonth(long timeStamp) \{  
        return isCurrentMonth(new Date(timeStamp));  
    \}

/\*\*  
     \* 判断传入日期和当前日期是否是同一天  
     \*  
     \* @param timeStamp  
     \* @return  
     \*/  
    public static boolean isCurrentDay(long timeStamp) \{  
        return isCurrentDay(new Date(timeStamp));  
    \}

/\*\*  
     \* 返回传入日期的下一天日期，时分秒和当前日期相同  
     \*  
     \* @param timeStamp 毫秒的时间戳  
     \* @return  
     \*/  
    public static LocalDateTime nextDay(long timeStamp) \{  
        return nextDay(new Date(timeStamp));  
    \}

/\*\*  
     \* 返回传入日期的上一天日期，时分秒和当前日期相同  
     \*  
     \* @param timeStamp 毫秒的时间戳  
     \* @return  
     \*/  
    public static LocalDateTime previousDay(long timeStamp) \{  
        return previousDay(new Date(timeStamp));  
    \}

/\*\*  
     \* 返回传入日期当月的第一天日期，时分秒和当前日期相同  
     \*  
     \* @param timeStamp 毫秒的时间戳  
     \* @return  
     \*/  
    public static LocalDateTime firstDayOfMonth(long timeStamp) \{  
        return firstDayOfMonth(new Date(timeStamp));  
    \}

/\*\*  
     \* 返回传入日期当月的最后一天日期，时分秒和当前日期相同  
     \*  
     \* @param timeStamp 毫秒的时间戳  
     \* @return  
     \*/  
    public static LocalDateTime lastDayOfMonth(long timeStamp) \{  
        return lastDayOfMonth(new Date(timeStamp));  
    \}

/\*\*  
     \* 返回传入日期的当天开始 时分秒都是0  
     \*  
     \* @param nowTimeStamp 毫秒的时间戳  
     \* @return  
     \*/  
    public static LocalDateTime startOfDay(long nowTimeStamp) \{  
        return startOfDay(new Date(nowTimeStamp));  
    \}

/\*\*  
     \* 返回传入日期的当天结束 也是第二天的开始时间  
     \*  
     \* @param nowTimeStamp 毫秒的时间戳  
     \* @return  
     \*/  
    public static LocalDateTime endOfDay(long nowTimeStamp) \{  
        return endOfDay(new Date(nowTimeStamp));  
    \}

public static void main(String\[\] args) \{  
        System.out.println(TIME\_FORMATTER.format(DateUtil.nextDay(new Date())));  
        System.out.println(DateUtil.firstDayOfMonth(new Date()));  
        System.out.println(DateUtil.lastDayOfMonth(new Date()));  
        System.out.println(DateUtil.startOfDay(new Date()));  
        System.out.println(DateUtil.endOfDay(new Date()));

System.out.println(DATE\_FORMATTER.format(DateUtil.endOfDay("2018-12-12 12:12:12", false)));  
        System.out.println(TIME\_FORMATTER.format(DateUtil.endOfDay(System.currentTimeMillis())));

\}  
原文：https://blog.csdn.net/lqadam/article/details/86695567