io.github.util.time.TimeUtil Maven / Gradle / Ivy
The newest version!
package io.github.util.time;
import io.github.constant.TimeConstant;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjusters;
import java.util.ArrayList;
import java.util.List;
public class TimeUtil {
/**
* 获取今天的时间
* @return String 日期时间字符串，例如 2023-08-11 09:51:53
*/
public static String today(){
return nowDateTimeFormat();
}
/**
* 获取明天的时间
* @return String 日期时间字符串, 例如 2023-08-12 09:51:53
*/
public static String tomorrow(){
return timeFormat(plus(LocalDateTime.now(),1,ChronoUnit.DAYS),TimeConstant.YMD_HMS);
}
/**
* 获取昨天的时间
* @return String 日期时间字符串, 例如 2023-08-10 09:51:53
*/
public static String yesterday(){
return timeFormat(minus(LocalDateTime.now(),1,ChronoUnit.DAYS),TimeConstant.YMD_HMS);
}
/**
* 获取当前日期和时间字符串.
*
* @return String 日期时间字符串，例如 2015-08-11 09:51:53
*/
public static String nowDateTimeFormat() {
return timeFormat(LocalDateTime.now(), TimeConstant.YMD_HMS);
}
/**
* 获取当前日期和时间字符串.
*
* @return String 日期时间字符串，例如 2015-08-11 09:51:53
*/
public static String nowDateFormat() {
return timeFormat(LocalDate.now(), TimeConstant.YMD);
}
/**
* 获取当前时间字符串.
*
* @return String 时间字符串，例如 09:51:53
*/
public static String nowTimeFormat() {
return timeFormat(LocalTime.now(), TimeConstant.HMS);
}
/**
* 获取当前星期字符串.
*
* @return String 当前星期字符串，例如 星期二
*/
public static String nowWeekDayFormat() {return timeFormat(LocalDate.now(), "E"); }
/**
* 获取日期时间字符串
*
* @param temporal 需要转化的日期时间
* @param pattern 时间格式
* @return String 日期时间字符串，例如 2015-08-11 09:51:53
*/
public static String timeFormat(TemporalAccessor temporal, String pattern) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
return dateTimeFormatter.format(temporal);
}
/**
* 日期时间字符串转换为日期时间(java.time.LocalDateTime)
* 默认 yyyy-mm-dd hh:mm:ss
* @param dateTimeStr 日期时间字符串
* @return LocalDateTime 日期时间
*/
public static LocalDateTime parseDateTime(String dateTimeStr) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(TimeConstant.YMD_HMS);
return LocalDateTime.parse(dateTimeStr, dateTimeFormatter);
}
/**
* 日期字符串转换为日期(java.time.LocalDate)
* 默认 yyyy-mm-dd
* @param dateStr 日期字符串
* @return LocalDate 日期
*/
public static LocalDate parseDate(String dateStr) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(TimeConstant.YMD);
return LocalDate.parse(dateStr, dateTimeFormatter);
}
/**
* 日期时间字符串转换为日期时间(java.time.LocalDateTime)
*
* @param dateTimeStr 日期时间字符串
* @param pattern 日期时间格式 例如DATETIME_PATTERN
* @return LocalDateTime 日期时间
*/
public static LocalDateTime parseDateTime(String dateTimeStr, String pattern) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
return LocalDateTime.parse(dateTimeStr, dateTimeFormatter);
}
/**
* 日期字符串转换为日期(java.time.LocalDate)
*
* @param dateStr 日期字符串
* @param pattern 日期格式 例如DATE_PATTERN
* @return LocalDate 日期
*/
public static LocalDate parseDate(String dateStr, String pattern) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
return LocalDate.parse(dateStr, dateTimeFormatter);
}
/**
* 获取指定日期时间加上指定数量日期时间单位之后的日期时间.
*
* @param localDateTime 日期时间
* @param num 数量
* @param chronoUnit 日期时间单位
* @return LocalDateTime 新的日期时间
*/
public static LocalDateTime plus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
return localDateTime.plus(num, chronoUnit);
}
/**
* 获取指定日期时间减去指定数量日期时间单位之后的日期时间.
*
* @param localDateTime 日期时间
* @param num 数量
* @param chronoUnit 日期时间单位
* @return LocalDateTime 新的日期时间
*/
public static LocalDateTime minus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
return localDateTime.minus(num, chronoUnit);
}
/**
* 根据ChronoUnit计算两个日期时间之间相隔日期时间
*
* @param start 开始日期时间
* @param end 结束日期时间
* @param chronoUnit 日期时间单位
* @return long 相隔日期时间
*/
public static long between(LocalDateTime start, LocalDateTime end, ChronoUnit chronoUnit) {
return Math.abs(start.until(end, chronoUnit));
}
/**
* 根据ChronoUnit计算两个日期之间相隔年数或月数或天数
*
* @param start 开始日期
* @param end 结束日期
* @param chronoUnit 日期时间单位,(ChronoUnit.YEARS,ChronoUnit.MONTHS,ChronoUnit.WEEKS,ChronoUnit.DAYS)
* @return long 相隔年数或月数或天数
*/
public static long between(LocalDate start, LocalDate end, ChronoUnit chronoUnit) {
return Math.abs(start.until(end, chronoUnit));
}
/**
* 获取指定日期开始时间的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String startOfDay(LocalDateTime localDateTime) {
return startOfDay(localDateTime, TimeConstant.YMD_HMS);
}
/**
* 获取指定日期结束时间的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String endOfDay(LocalDateTime localDateTime) {
return endOfDay(localDateTime, TimeConstant.YMD_HMS);
}
/**
* 获取指定日期开始时间的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd HH:mm:ss
*/
public static String startOfDay(LocalDateTime localDateTime, String pattern) {
return timeFormat(localDateTime.withHour(0).withMinute(0).withSecond(0), pattern);
}
/**
* 获取指定日期结束时间的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String endOfDay(LocalDateTime localDateTime, String pattern) {
return timeFormat(localDateTime.withHour(23).withMinute(59).withSecond(59), pattern);
}
/**
* 切割日期。按照周期切割成小段日期段。例如：
*
* @param startDate 开始日期（yyyy-MM-dd）
* @param endDate 结束日期（yyyy-MM-dd）
* @param period 周期（天，周，月，年）
* @return 切割之后的日期集合
* input startDate="2019-02-28",endDate="2019-03-05",period="day"
* output [2019-02-28, 2019-03-01, 2019-03-02, 2019-03-03, 2019-03-04, 2019-03-05]
*/
public static List splitDateToList(String startDate, String endDate, String period) {
List result = new ArrayList<>();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(TimeConstant.YMD);
LocalDate end = LocalDate.parse(endDate, dateTimeFormatter);
LocalDate start = LocalDate.parse(startDate, dateTimeFormatter);
LocalDate tmp = start;
switch (period) {
case "day":
while (start.isBefore(end) || start.isEqual(end)) {
result.add(start.toString());
start = start.plusDays(1);
}
break;
case "week":
while (tmp.isBefore(end) || tmp.isEqual(end)) {
if (tmp.plusDays(6).isAfter(end)) {
result.add(tmp.toString() + "," + end);
} else {
result.add(tmp.toString() + "," + tmp.plusDays(6));
}
tmp = tmp.plusDays(7);
}
break;
case "month":
while (tmp.isBefore(end) || tmp.isEqual(end)) {
LocalDate lastDayOfMonth = tmp.with(TemporalAdjusters.lastDayOfMonth());
if (lastDayOfMonth.isAfter(end)) {
result.add(tmp.toString() + "," + end);
} else {
result.add(tmp.toString() + "," + lastDayOfMonth);
}
tmp = lastDayOfMonth.plusDays(1);
}
break;
case "year":
while (tmp.isBefore(end) || tmp.isEqual(end)) {
LocalDate lastDayOfYear = tmp.with(TemporalAdjusters.lastDayOfYear());
if (lastDayOfYear.isAfter(end)) {
result.add(tmp.toString() + "," + end);
} else {
result.add(tmp.toString() + "," + lastDayOfYear);
}
tmp = lastDayOfYear.plusDays(1);
}
break;
default:
break;
}
return result;
}
/**
* 生成多少时间之前的文本 例如: 1 minute ago
* @param dateTime 传递的时间
* @return 1 minute ago
*/
public static String timeAgo(LocalDateTime dateTime) {
LocalDateTime now = LocalDateTime.now();
Duration duration = Duration.between(dateTime, now);
long days = duration.toDays();
long hours = duration.toHours();
long minutes = duration.toMinutes();
if (minutes < 1) {
return "now";
} else if (minutes < 60) {
return minutes + " minute" + (minutes > 1 ? "s" : "") + " ago";
} else if (hours < 24) {
return hours + " hour" + (hours > 1 ? "s" : "") + " ago";
} else if (days < 30){
return days + " day" + (days > 1 ? "s" : "") + " ago";
} else if(days < 365){
long months = days/30;
return months + " month" + (months > 1 ? "s" : "") + " ago";
}else{
long years = days/365;
return years + " year" + (years > 1 ? "s" : "") + " ago";
}
}
/**
* LocalDateTime 转 毫秒
* @param dateTime
* @return long 毫秒
*/
public static long DateTimeToLong(LocalDateTime dateTime) {
return dateTime.toInstant(ZoneOffset.UTC).toEpochMilli();
}
/**
* LocalDateTimeStr 转 毫秒
* 格式: yyyy-mm-dd hh:mm:ss
* @param dateTimeStr
* @return long 毫秒
*/
public static long DateTimeToLong(String dateTimeStr) {
LocalDateTime dateTime = parseDateTime(dateTimeStr);
return dateTime.toInstant(ZoneOffset.UTC).toEpochMilli();
}
public static void main(String[] args) {
System.out.println(today());
System.out.println(tomorrow());
System.out.println(yesterday());
System.out.println(startOfDay(parseDateTime(yesterday())));
System.out.println(endOfDay(parseDateTime(yesterday())));
System.out.println(DateTimeToLong("2023-11-11 12:34:56"));
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy