com.cn.lp.common.utils.DateTimeAide Maven / Gradle / Ivy
The newest version!
package com.cn.lp.common.utils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.text.ParseException;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Optional;
/**
* 时间辅助类
*/
public class DateTimeAide {
/**
* 默认时间日期格式化模式
*/
public static final String DEF_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
/**
* 默认日期格式化模式
*/
public static final String DEF_DATE_PATTERN = "yyyy-MM-dd";
/**
* 默认时间格式化模式
*/
public static final String DEF_TIME_PATTERN = "HH:mm:s`s";
private static Logger LOGGER = LoggerFactory.getLogger(DateTimeAide.class);
/**
* 检查时间是否在今天内
*
* @param time
* @return
*/
public static boolean isToday(long time) {
return isSameDay(time, System.currentTimeMillis());
}
/**
* LocalDate: 表示没有时区的日期, LocalDate是不可变并且线程安全的 2020-09-09T14:21:47.892909100
* LocalTime: 表示没有时区的时间, LocalTime是不可变并且线程安全的 2020-09-09
* LocalDateTime: 表示没有时区的日期时间, LocalDateTime是不可变并且线程安全的 14:21:47.893908900
*
* @param time
* @return
*/
public static boolean isToday(LocalDateTime time) {
return isToday(time.toLocalDate());
}
public static boolean isToday(LocalDate date) {
return isSameDay(date, LocalDate.now());
}
/**
* 检查时间是否在同一天
* Instant: 用来表示时间线上的一个点（瞬时）
* Clock: 用于访问当前时刻、日期、时间，用到时区
* Duration: 用秒和纳秒表示时间的数量（长短），用于计算两个日期的“时间”间隔
* Period: 用于计算两个“日期”间隔
*
* @param time
* @param otherTime
* @return
*/
public static boolean isSameDay(long time, long otherTime) {
return toDateNum(time) == toDateNum(otherTime);
}
public static boolean isSameDay(LocalDate date, LocalDate otherDate) {
return toDateNum(date) == toDateNum(otherDate);
}
/**
* 自定义格式化日期
*
* @param date 日期对象
* @param pattern 例如:yyyy-MM-dd HH:mm:ss
* @return
*/
public static String format(Date date, String pattern) {
if (date == null) {
return "";
}
return DateFormatUtils.format(date, pattern);
}
/**
* 自定义格式化日期
*
* @param date 日期对象
* @param pattern 例如:yyyy-MM-dd HH:mm:ss
* @return
*/
public static String format(LocalDateTime date, String pattern) {
if (date == null) {
return "";
}
return format(toDate(date), pattern);
}
/**
* 自定义格式化日期
*
* @param time 日期对象
* @param pattern 例如:yyyy-MM-dd HH:mm:ss
* @return
*/
public static String format(long time, String pattern) {
return format(new Date(time), pattern);
}
/**
* 格式化日期 yyyy-MM-dd
*
* @param date
* @return
*/
public static String formatDate(Date date) {
return format(date, DEF_DATE_PATTERN);
}
/**
* 格式化日期 yyyy-MM-dd
*
* @param date
* @return
*/
public static String formatDate(LocalDateTime date) {
return format(toDate(date), DEF_DATE_PATTERN);
}
/**
* 格式化日期 HH:mm:s`s
*
* @param date
* @return
*/
public static String formatTime(Date date) {
return format(date, DEF_TIME_PATTERN);
}
/**
* 格式化日期 HH:mm:s`s
*
* @param date
* @return
*/
public static String formatTime(LocalDateTime date) {
return format(toDate(date), DEF_TIME_PATTERN);
}
/**
* 格式化日期 yyyy-MM-dd HH:mm:ss
*
* @param date
* @return
*/
public static String formatDateTime(Date date) {
return format(date, DEF_DATE_TIME_PATTERN);
}
/**
* 格式化日期 yyyy-MM-dd HH:mm:ss
*
* @param time
* @return
*/
public static String formatDateTime(long time) {
return format(new Date(time), DEF_DATE_TIME_PATTERN);
}
/**
* 格式化日期 yyyy-MM-dd HH:mm:ss
*
* @param date
* @return
*/
public static String formatDateTime(LocalDateTime date) {
return format(toDate(date), DEF_DATE_TIME_PATTERN);
}
/**
* 从字符串转为日期
*
* @param str 自定义日期字符串对象
* @param pattern 例如:yyyy-MM-dd HH:mm:ss
* @return
*/
public static Optional parse(String str, String pattern){
try {
Date date = DateUtils.parseDate(str, pattern);
return Optional.ofNullable(toLocalDateTime(date));
} catch (ParseException e) {
LOGGER.error("[DateTimeAide] parse {}-{} 失败", str, pattern, e);
return Optional.empty();
}
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd
* @return
*/
public static Optional parseDate(String str) {
return parse(str, DEF_DATE_PATTERN);
}
/**
* 从字符串转为日期
*
* @param str HH:mm:s`s
* @return
*/
public static Optional parseTime(String str) {
return parse(str, DEF_TIME_PATTERN);
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd HH:mm:ss
* @return
*/
public static Optional parseDateTime(String str) {
return parse(str, DEF_DATE_TIME_PATTERN);
}
/**
* 从字符串转为日期
*
* @param str 自定义日期字符串对象
* @param pattern 例如:yyyy-MM-dd HH:mm:ss
* @param defValue 默认值
* @return
*/
public static LocalDateTime parse(String str, String pattern, LocalDateTime defValue) {
if (StringUtils.isBlank(str)) {
return defValue;
}
return parse(str, pattern).orElse(defValue);
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd
* @return
*/
public static LocalDateTime parseDate(String str, LocalDateTime defValue) {
return parse(str, DEF_DATE_PATTERN, defValue);
}
/**
* 从字符串转为日期
*
* @param str HH:mm:s`s
* @return
*/
public static LocalDateTime parseTime(String str, LocalDateTime defValue) {
return parse(str, DEF_TIME_PATTERN, defValue);
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd HH:mm:ss
* @return
*/
public static LocalDateTime parseDateTime(String str, LocalDateTime defValue) {
return parse(str, DEF_DATE_TIME_PATTERN, defValue);
}
// ========================
/**
* 从字符串转为日期
*
* @param str 自定义日期字符串对象
* @param pattern 例如:yyyy-MM-dd HH:mm:ss
* @return
*/
public static Optional parseOld(String str, String pattern) {
try {
return Optional.ofNullable(DateUtils.parseDate(str, pattern));
} catch (ParseException e) {
LOGGER.error("[DateTimeAide] parseOld {}-{} 失败", str, pattern, e);
return Optional.empty();
}
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd
* @return
*/
public static Optional parseOldDate(String str) {
return parseOld(str, DEF_DATE_PATTERN);
}
/**
* 从字符串转为日期
*
* @param str HH:mm:s`s
* @return
*/
public static Optional parseOldTime(String str) {
return parseOld(str, DEF_TIME_PATTERN);
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd HH:mm:ss
* @return
*/
public static Optional parseOldDateTime(String str) {
return parseOld(str, DEF_DATE_TIME_PATTERN);
}
/**
* 从字符串转为日期
*
* @param str 自定义日期字符串对象
* @param pattern 例如:yyyy-MM-dd HH:mm:ss
* @return
*/
public static Date parseOld(String str, String pattern, Date defValue) {
if (StringUtils.isBlank(str)) {
return defValue;
}
return parseOld(str, pattern).orElse(defValue);
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd
* @return
*/
public static Date parseOldDate(String str, Date defValue) {
return parseOld(str, DEF_DATE_PATTERN, defValue);
}
/**
* 从字符串转为日期
*
* @param str HH:mm:s`s
* @return
*/
public static Date parseOldTime(String str, Date defValue) {
return parseOld(str, DEF_TIME_PATTERN, defValue);
}
/**
* 从字符串转为日期
*
* @param str yyyy-MM-dd HH:mm:ss
* @return
*/
public static Date parseOldDateTime(String str, Date defValue) {
return parseOld(str, DEF_DATE_TIME_PATTERN, defValue);
}
// =========================
public static LocalDateTime toLocalDateTime(Date date) {
Instant instant = date.toInstant();
ZoneId zone = ZoneId.systemDefault();
return LocalDateTime.ofInstant(instant, zone);
}
public static LocalDate toLocalDate(Date date) {
return toLocalDateTime(date).toLocalDate();
}
public static Date toDate(LocalDateTime localDateTime) {
ZoneId zone = ZoneId.systemDefault();
Instant instant = localDateTime.atZone(zone).toInstant();
return Date.from(instant);
}
/**
* 是否比现在迟
*
* @param localDateTime
* @return
*/
public static boolean isAfterNow(LocalDateTime localDateTime) {
return localDateTime.isAfter(LocalDateTime.now());
}
/**
* 是否比现在早
*
* @param localDateTime
* @return
*/
public static boolean isBeforeNow(LocalDateTime localDateTime) {
return localDateTime.isBefore(LocalDateTime.now());
}
public static boolean isEqualOrBeforeNow(LocalDateTime localDateTime) {
LocalDateTime now = LocalDateTime.now();
return now.isEqual(localDateTime) || isBeforeNow(localDateTime);
}
public static boolean isEqualOrAfterNow(LocalDateTime localDateTime) {
LocalDateTime now = LocalDateTime.now();
return now.isEqual(localDateTime) || isAfterNow(localDateTime);
}
/**
* 转成毫秒
*
* @param ldt
* @return
*/
public static long toMillis(LocalDateTime ldt) {
return ldt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
}
public static Date parseDate(long mills) {
if (mills <= 0) {
return null;
}
return new Date(mills);
}
public static int toTimeNum(LocalDateTime dateTime) {
return toTimeNum(dateTime.toLocalTime());
}
/**
* 转换为时间数 hhmm
*/
public static int toTimeNum(LocalTime localTime) {
int num = localTime.getHour() * 100;
num += localTime.getMinute();
return num;
}
/**
* 转换为时间数 hhmm
*/
public static int toTimeNum(long mills, Duration offset) {
mills += offset.toMillis();
return toTimeNum(mills);
}
/**
* 转换为时间数 hhmm
*/
public static int toTimeNum(Date date, Duration offset) {
return toTimeNum(date.getTime(), offset);
}
/**
* 转换为日期数 yyyyMMdd
*/
public static int toTimeNum(Date date) {
return toDateNum(date.getTime());
}
/**
* 转换为日期数 yyyyMMdd
*/
public static int toDateNum(long mills) {
LocalDateTime localDate = LocalDateTime.ofInstant(Instant.ofEpochMilli(mills), ZoneId.systemDefault());
return toDateNum(localDate);
}
/**
* 转换为时间数 hhmm
*/
public static int toTimeNum(long mills) {
LocalDateTime localDate = LocalDateTime.ofInstant(Instant.ofEpochMilli(mills), ZoneId.systemDefault());
return toTimeNum(localDate);
}
/**
* 转换为日期数 yyyyMMdd
*/
public static int toDateNum(LocalDateTime dateTime) {
return toDateNum(dateTime.toLocalDate());
}
/**
* 转换为日期数 yyyyMMdd
*/
public static int toDateNum(Date date) {
return toDateNum(date.getTime());
}
/**
* 转换为日期数 yyyyMMdd
*
* @param mills 时间戳
* @param offset 偏移量
* @return 日期数
*/
public static int toDateNum(long mills, Duration offset) {
mills += offset.toMillis();
return toDateNum(mills);
}
/**
* 转换为日期数 yyyyMMdd
*
* @param date 日期时间对象
* @param offset 偏移量
* @return 日期数
*/
public static int toDateNum(Date date, Duration offset) {
return toDateNum(date.getTime(), offset);
}
/**
* 转换为日期数 yyyyMMdd
*/
public static int toDateNum(LocalDate localDate) {
int num = localDate.getYear() * 10000;
num += localDate.getMonthValue() * 100;
num += localDate.getDayOfMonth();
return num;
}
public static LocalDate dateNumToLocalDate(int dateNum) {
int y = dateNum / 10000;
int m = (dateNum / 100) % 100;
int d = dateNum % 100;
return LocalDate.of(y, m, d);
}
public static Date dateNumToDate(int dateNum) {
LocalDate localDate = dateNumToLocalDate(dateNum);
return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
}
/**
* 获得当前日期数 yyyyMMdd
*/
public static int nowDateNum() {
return toDateNum(System.currentTimeMillis());
}
/**
* 格式化日期数
*
* @param dateNum yyyyMMdd
* @param pattern 自定义模式
*/
public static String formatDateNum(int dateNum, String pattern) {
return dateNumToLocalDate(dateNum).format(DateTimeFormatter.ofPattern(pattern));
}
/**
* 格式化日期数，以 yyyy-MM-dd 模式
*
* @param dateNum yyyyMMdd
*/
public static String formatDateNum(int dateNum) {
return formatDateNum(dateNum, DEF_DATE_PATTERN);
}
public static LocalTime timeNumToLocalTime(int timeNum) {
int h = (timeNum / 100) % 100;
int m = timeNum % 100;
int s = 0;
return LocalTime.of(h, m, s);
}
/**
* 格式化日期数
*
* @param timeNum mmss
* @param pattern 自定义模式
*/
public static String formatTimeNum(int timeNum, String pattern) {
return timeNumToLocalTime(timeNum).format(DateTimeFormatter.ofPattern(pattern));
}
/**
* 格式化日期数，以 yyyy-MM-dd 模式
*
* @param timeNum mmss
*/
public static String formatTimeNum(int timeNum) {
return formatTimeNum(timeNum, DEF_TIME_PATTERN);
}
}