在平常的编程中,经常会遇到时间的各种类型转化,避免每次都使用第三方库或者上网搜索,决定整理一下写篇博客,也是从各处收集或者让AI写的方法,应该可以涵盖平时所有的场景了。
格式化方法
-
String format(Object time)
:- 使用默认格式
yyyy-MM-dd HH:mm:ss
将时间对象格式化为字符串。
- 使用默认格式
-
String format(Object time, String format)
:- 使用指定格式将时间对象格式化为字符串。
-
String formatTimeAgo(String dateTime, String format)
:
- 将时间差转换为个性化的时间表达方式,如“刚刚”、“1分钟前”、“1小时前”、“昨天 14:11”等,使用指定格式。
String formatTimeAgo(String dateTime)
:
- 使用默认格式
yyyy-MM-dd HH:mm:ss
将时间差转换为个性化的时间表达方式。
解析方法
Date parseToDate(String timeStr, String format)
:
- 将时间字符串解析为
Date
对象,使用指定格式。
Date parseToDate(String timeStr)
:
- 使用默认格式
yyyy-MM-dd HH:mm:ss
将时间字符串解析为Date
对象。
LocalDateTime parseToLocalDateTime(String timeStr, String format)
:
- 将时间字符串解析为
LocalDateTime
对象,使用指定格式。
LocalDateTime parseToLocalDateTime(String timeStr)
:
- 使用默认格式
yyyy-MM-dd HH:mm:ss
将时间字符串解析为LocalDateTime
对象。
时间戳方法
long parseToTimestamp(String timeStr, String format, int digits)
:
- 将时间字符串解析为不同位数的时间戳(10位秒级别,13位毫秒级别),使用指定格式。
long parseToTimestamp(String timeStr, int digits)
:
- 使用默认格式
yyyy-MM-dd HH:mm:ss
将时间字符串解析为不同位数的时间戳。
long parseToTimestamp(String timeStr)
:
- 使用默认格式
yyyy-MM-dd HH:mm:ss
将时间字符串解析为13位毫秒级别的时间戳。
long localDateTimeToTimestamp(LocalDateTime localDateTime, int digits)
:
- 将
LocalDateTime
对象转换为不同位数的时间戳(10位秒级别,13位毫秒级别),使用系统默认时区。
long localDateTimeToTimestamp(LocalDateTime localDateTime)
:
- 将
LocalDateTime
对象转换为13位毫秒级别的时间戳,使用系统默认时区。
时间差计算方法
long calculateTimeDifferenceInSeconds(String startTimeStr, String endTimeStr, String format)
:
- 计算两个时间字符串之间的时间差,以秒为单位,使用指定格式。
long calculateTimeDifferenceInSeconds(String startTimeStr, String endTimeStr)
:
- 使用默认格式
yyyy-MM-dd HH:mm:ss
计算两个时间字符串之间的时间差,以秒为单位。
当前时间和日期处理方法
-
String getCurrentTime()
:- 获取当前时间的格式化字符串,使用默认格式
yyyy-MM-dd HH:mm:ss
。
- 获取当前时间的格式化字符串,使用默认格式
-
LocalDateTime getStartOfDay(String dateStr, String format)
:- 获取指定日期的开始时间(零点),使用指定格式。
-
LocalDateTime getStartOfDay(String dateStr)
:- 使用默认格式
yyyy-MM-dd HH:mm:ss
获取指定日期的开始时间(零点)。
- 使用默认格式
-
LocalDateTime getEndOfDay(String dateStr, String format)
:- 获取指定日期的结束时间(23:59:59),使用指定格式。
-
LocalDateTime getEndOfDay(String dateStr)
:- 使用默认格式
yyyy-MM-dd HH:mm:ss
获取指定日期的结束时间(23:59:59)。
- 使用默认格式
具体代码
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
public class DateUtil {
public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
public static String format(Object time) {
try {
return format(time, DATE_TIME_PATTERN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 时间格式化成字符串
*
* @param time 时间
* @param format 格式
* @return {@link String }
*/
public static String format(Object time, String format) {
// 检查 time 是否为 Date 类型
if (time instanceof Date date) {
// 如果是 Date 类型,调用 formatDate 方法
return formatDate(date, format);
}
// 检查 time 是否为 Calendar 类型
else if (time instanceof Calendar calendar) {
// 如果是 Calendar 类型,调用 formatCalendar 方法
return formatCalendar(calendar, format);
}
// 检查 time 是否为 Instant 类型
else if (time instanceof Instant instant) {
// 如果是 Instant 类型,调用 formatInstant 方法
return formatInstant(instant, format);
}
// 检查 time 是否为 ZonedDateTime 类型
else if (time instanceof ZonedDateTime zonedDateTime) {
// 如果是 ZonedDateTime 类型,调用 formatZonedDateTime 方法
return formatZonedDateTime(zonedDateTime, format);
}
// 检查 time 是否为 LocalDateTime 类型
else if (time instanceof LocalDateTime localDateTime) {
// 如果是 LocalDateTime 类型,调用 formatLocalDateTime 方法
return formatLocalDateTime(localDateTime, format);
}
// 检查 time 是否为 Long 类型(时间戳)
else if (time instanceof Long timestamp) {
// 如果是 Long 类型,调用 formatTimestamp 方法
return formatTimestamp(timestamp, format);
}
// 如果 time 类型不支持,则抛出异常
else {
throw new IllegalArgumentException("Unsupported time type: " + time.getClass().getName());
}
}
private static String formatDate(Date date, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(date);
}
private static String formatCalendar(Calendar calendar, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(calendar.getTime());
}
private static String formatInstant(Instant instant, String format) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format).withZone(ZoneId.systemDefault());
return formatter.format(instant);
}
private static String formatZonedDateTime(ZonedDateTime zdt, String format) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
return zdt.format(formatter);
}
private static String formatLocalDateTime(LocalDateTime ldt, String format) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
return ldt.format(formatter);
}
private static String formatTimestamp(long timestamp, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date date = new Date(timestamp);
return sdf.format(date);
}
/**
* 将时间字符串转换为 Date 对象
* @param timeStr 时间字符串
* @param format 格式化字符串
* @return 转换后的 Date 对象
*/
public static Date parseToDate(String timeStr, String format) {
// 使用 SimpleDateFormat 解析时间字符串
try {
SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.parse(timeStr);
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
public static Date parseToDate(String timeStr) {
return parseToDate(timeStr, DATE_TIME_PATTERN);
}
/**
* 将时间字符串转换为 LocalDateTime 对象
* @param timeStr 时间字符串
* @param format 格式化字符串
* @return 转换后的 LocalDateTime 对象
*/
public static LocalDateTime parseToLocalDateTime(String timeStr, String format) {
// 使用 DateTimeFormatter 解析时间字符串
DateTimeFormatter dtf = DateTimeFormatter.ofPattern(format);
return LocalDateTime.parse(timeStr, dtf);
}
public static LocalDateTime parseToLocalDateTime(String timeStr) {
return parseToLocalDateTime(timeStr, DATE_TIME_PATTERN);
}
/**
* 将时间字符串转换为不同位数的时间戳
* @param timeStr 时间字符串
* @param format 格式化字符串
* @param digits 时间戳位数(10位秒级别,13位毫秒级别)
* @return 转换后的时间戳
*/
public static long parseToTimestamp(String timeStr, String format, int digits) {
// 将时间字符串解析为 Date 对象
Date date = parseToDate(timeStr, format);
// 获取时间戳
long timestamp = date.getTime();
// 根据时间戳位数进行处理
if (digits == 10) {
// 如果需要10位时间戳,则转换为秒级别
return timestamp / 1000;
} else if (digits == 13) {
// 如果需要13位时间戳,则返回毫秒级别时间戳
return timestamp;
} else {
// 其他位数不支持,抛出异常
throw new IllegalArgumentException("Unsupported timestamp digits: " + digits);
}
}
public static long parseToTimestamp(String timeStr, int digits) {
return parseToTimestamp(timeStr, DATE_TIME_PATTERN, digits);
}
public static long parseToTimestamp(String timeStr) {
// 默认 13 位时间戳
return parseToTimestamp(timeStr, DATE_TIME_PATTERN, 13);
}
/**
* 将 LocalDateTime 对象转换为时间戳
* @param localDateTime LocalDateTime 对象
* @param zoneId 时区 ID
* @param digits 时间戳位数(10位秒级别,13位毫秒级别)
* @return 转换后的时间戳
*/
private static long localDateTimeToTimestamp(LocalDateTime localDateTime, ZoneId zoneId, int digits) {
ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
long timestamp = zonedDateTime.toInstant().toEpochMilli();
if (digits == 10) {
// 如果需要10位时间戳,则转换为秒级别
return timestamp / 1000;
} else if (digits == 13) {
// 如果需要13位时间戳,则返回毫秒级别时间戳
return timestamp;
} else {
// 其他位数不支持,抛出异常
throw new IllegalArgumentException("Unsupported timestamp digits: " + digits);
}
}
public static long localDateTimeToTimestamp(LocalDateTime localDateTime, int digits) {
return localDateTimeToTimestamp(localDateTime, ZoneId.systemDefault(), digits);
}
public static long localDateTimeToTimestamp(LocalDateTime localDateTime) {
return localDateTimeToTimestamp(localDateTime, 13);
}
private static Duration calculateTimeDifferenceDuration(String startTimeStr, String endTimeStr, String format) {
// 将时间字符串解析为 LocalDateTime 对象
LocalDateTime startTime = parseToLocalDateTime(startTimeStr, format);
LocalDateTime endTime = parseToLocalDateTime(endTimeStr, format);
return calculateTimeDifferenceDuration(startTime, endTime);
}
private static Duration calculateTimeDifferenceDuration(LocalDateTime startTime, LocalDateTime endTime) {
// 计算两个时间点之间的 Duration
return Duration.between(startTime, endTime);
}
/**
* 计算两个时间字符串之间的时间差,以秒为单位
* @param startTimeStr 开始时间字符串
* @param endTimeStr 结束时间字符串
* @param format 时间字符串的格式
* @return 时间差的秒数
*/
public static long calculateTimeDifferenceInSeconds(String startTimeStr, String endTimeStr, String format) {
// 计算两个时间点之间的 Duration
Duration duration = calculateTimeDifferenceDuration(startTimeStr, endTimeStr, format);
// 返回时间差的秒数
return duration.getSeconds();
}
public static long calculateTimeDifferenceInSeconds(String startTimeStr, String endTimeStr) {
return calculateTimeDifferenceInSeconds(startTimeStr, endTimeStr, DATE_TIME_PATTERN);
}
/**
* 将时间差转换为个性化的时间表达方式
* @param dateTime 时间字符串
* @param format 时间字符串的格式
* @return 个性化的时间表达方式
*/
public static String formatTimeAgo(String dateTime, String format) {
LocalDateTime time = parseToLocalDateTime(dateTime, format);
LocalDateTime now = LocalDateTime.now();
Duration duration = calculateTimeDifferenceDuration(time, now);
if (duration.isZero() || duration.getSeconds() < 60) {
return "刚刚";
} else if (duration.toMinutes() < 60) {
return duration.toMinutes() + "分钟前";
} else if (duration.toHours() < 24) {
return duration.toHours() + "小时前";
} else if (duration.toDays() == 1) {
return "昨天 " + time.format(DateTimeFormatter.ofPattern("HH:mm"));
} else if (duration.toDays() < 365) {
return time.format(DateTimeFormatter.ofPattern("MM-dd HH:mm"));
} else {
return time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
}
public static String formatTimeAgo(String dateTime) {
return formatTimeAgo(dateTime, DATE_TIME_PATTERN);
}
/**
* 获取当前时间的格式化字符串
* @return 当前时间的格式化字符串
*/
public static String getCurrentTime() {
return format(LocalDateTime.now(), DATE_TIME_PATTERN);
}
/**
* 获取指定日期的开始时间(零点)
* @param dateStr 日期字符串
* @param format 日期字符串的格式
* @return 指定日期的开始时间
*/
public static LocalDateTime getStartOfDay(String dateStr, String format) {
DateTimeFormatter dtf = DateTimeFormatter.ofPattern(format);
LocalDate date = LocalDate.parse(dateStr, dtf);
return date.atStartOfDay();
}
public static LocalDateTime getStartOfDay(String dateStr) {
return getStartOfDay(dateStr, DATE_TIME_PATTERN);
}
/**
* 获取指定日期的结束时间(23:59:59.999999999)
* @param dateStr 日期字符串
* @param format 日期字符串的格式
* @return 指定日期的结束时间
*/
public static LocalDateTime getEndOfDay(String dateStr, String format) {
DateTimeFormatter dtf = DateTimeFormatter.ofPattern(format);
LocalDate date = LocalDate.parse(dateStr, dtf);
LocalTime endOfDay = LocalTime.of(23, 59, 59, 999_999_999);
return date.atTime(endOfDay);
}
public static LocalDateTime getEndOfDay(String dateStr) {
return getEndOfDay(dateStr, DATE_TIME_PATTERN);
}
}