前言
日常开发中我们经常涉及到对日期的处理，这篇博客整理了常用的日期处理方法。
代码实现：
import lombok.extern.slf4j.Slf4j;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
@Slf4j
public class DateUtils {
/**
* 将某格式的时间字符串转化成毫秒时间戳表示的字符串
*
* @param dateTime 时间字符串
* @param format 时间字符串的格式
* @return 毫秒时间戳表示的字符串，例如"1609459200000ms"
*/
// 将某格式的时间字符串转化成毫秒时间戳表示的字符串
public static String dateTimeStrToMills(String dateTime, String format) {
String dateStr = null;
SimpleDateFormat sdf = new SimpleDateFormat(format);
Calendar calendar = Calendar.getInstance();
calendar.clear();
try {
Date d = new Date();
d = sdf.parse(dateTime);
calendar.setTime(d);
dateStr = calendar.getTimeInMillis() + "ms";
} catch (ParseException e) {
e.printStackTrace();
}
return dateStr;
}
/**
* 将某格式的时间字符串转化成毫秒时间戳的长整型值
*
* @param dateTime 时间字符串
* @param format 时间字符串的格式
* @return 毫秒时间戳的长整型值
* @throws ParseException 如果输入的日期时间字符串格式不正确，则抛出此异常
*/
public static long dateTimeStrToMillsValue(String dateTime, String format) {
long dateValue = 0L;
SimpleDateFormat sdf = new SimpleDateFormat(format);
Calendar calendar = Calendar.getInstance();
calendar.clear();
try {
Date d = new Date();
d = sdf.parse(dateTime);
calendar.setTime(d);
dateValue = calendar.getTimeInMillis();
} catch (ParseException e) {
e.printStackTrace();
}
return dateValue;
}
/**
* 获取某个月的天数
*
* @param year 年份
* @param month 月份（从0开始计数，即1月对应0）
* @return 对应月份的天数
*/
public static int getDayNumOfMonth(int year, int month) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(year, month, 0);
return calendar.get(Calendar.DAY_OF_MONTH);
}
/**
* 获取某日、月、年前后的日期
*
* @param num 表示要增加或减少的时间单位数量，正数表示未来的日期，负数表示过去的日期
* @param date 给定的日期字符串，格式需与format参数一致
* @param format 日期字符串的格式
* @param timeType 时间类型，可以是Calendar.YEAR（年）、Calendar.MONTH（月）、Calendar.DAY_OF_MONTH（日）等
* @return 计算后的日期字符串，格式与输入的date参数一致
* @throws ParseException 如果输入的日期字符串格式不正确，则抛出此异常
*/
public static String getBeforeOrAfterDateType(int num, String date, String format, int timeType) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
String resultDate = "";
Calendar calendar = Calendar.getInstance();
calendar.clear();
try {
Date d = new Date();
d = sdf.parse(date);
calendar.setTime(d);
calendar.add(timeType, num);//一天的结束是第二天的开始
resultDate = sdf.format(calendar.getTime());
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return resultDate;
}
/**
* 根据毫秒时间戳获得格式化后的日期
*
* @param millisecond 毫秒时间戳
* @param dateFormat 日期格式，例如 "yyyy-MM-dd HH:mm:ss"
* @return 格式化后的日期字符串
*/
public static String millisecondToDate(Long millisecond, String dateFormat) {
Date date = new Date(millisecond);
GregorianCalendar gc = new GregorianCalendar();
gc.setTime(date);
SimpleDateFormat format = new SimpleDateFormat(dateFormat);
String sb = format.format(gc.getTime());
return sb;
}
/**
* 将毫秒时间戳转换为指定格式的日期字符串，并应用指定的时区。
*
* @param millisecond 毫秒时间戳
* @param dateFormat 日期格式，如 "yyyy-MM-dd HH:mm:ss"
* @param timeZoneId 时区ID，如 "GMT+8"
* @return 转换后的日期字符串
*/
public static String convertTimestampToFormattedDate(long millisecond, String dateFormat, String timeZoneId) {
Date date = new Date(millisecond);
GregorianCalendar gc = new GregorianCalendar();
gc.setTime(date);
SimpleDateFormat format = new SimpleDateFormat(dateFormat);
TimeZone timeZone = TimeZone.getTimeZone(timeZoneId);
format.setTimeZone(timeZone);
String sb = format.format(gc.getTime());
return sb;
}
/**
* 获取某月的第一天。
*
* @param year 年份
* @param month 月份（注意：月份从1开始计数，但Calendar类内部月份是从0开始计数的，因此需减1）
* @return 返回指定月份第一天的日期字符串，格式为"yyyy-MM-dd"
*/
public static String getFirstDayOfMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
int firstDay = cal.getActualMinimum(Calendar.DAY_OF_MONTH);
cal.set(Calendar.DAY_OF_MONTH, firstDay);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String firstDayOfMonth = sdf.format(cal.getTime());
return firstDayOfMonth;
}
/**
* 获取某月的最后一天。
*
* @param year 年份
* @param month 月份（注意：月份从1开始计数，但Calendar类内部月份是从0开始计数的，因此需减1）
* @param format 日期格式，例如 "yyyy-MM-dd"
* @return 返回指定月份最后一天的日期字符串，格式与输入的format参数一致
*/
public static String getLastDayOfMonth(int year, int month, String format) {
Calendar cal = Calendar.getInstance();
cal.clear();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
int lastDay = 0;
lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
cal.set(Calendar.DAY_OF_MONTH, lastDay);
SimpleDateFormat sdf = new SimpleDateFormat(format);
String lastDayOfMonth = sdf.format(cal.getTime());
return lastDayOfMonth;
}
/**
* 获取起止日期之间的所有日期字符串（可自定义间隔、格式、日期类型）
*
* @param begin 开始日期字符串
* @param end 结束日期字符串
* @param num 日期间隔数量
* @param timeType 日期类型，可以是Calendar.YEAR（年）、Calendar.MONTH（月）、Calendar.DAY_OF_MONTH（日）等
* @param format 日期字符串的格式
* @return 返回起止日期之间的所有日期字符串列表
* @throws ParseException 如果输入的日期字符串格式不正确，则抛出此异常
*/
public static List<String> getDatesBetweenTwoDate(String begin, String end, int num, int timeType, String format) {
List<String> lDates = new ArrayList<>();
if (begin.equals(end)) {
lDates.add(begin);
return lDates;
}
try {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date beginDate = sdf.parse(begin);
Date endDate = sdf.parse(end);
lDates.add(sdf.format(beginDate));
Calendar calendar = Calendar.getInstance();
calendar.setTime(beginDate);
boolean bContinue = true;
while (bContinue) {
calendar.add(timeType, num);
if (endDate.after(calendar.getTime())) {
lDates.add(sdf.format(calendar.getTime()));
} else {
break;
}
}
lDates.add(sdf.format(endDate));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return lDates;
}
/**
* 获取当前日期和时间。
*
* @return 当前日期和时间的Date对象
* @throws ParseException 如果解析日期字符串时发生错误，则抛出此异常
*/
public static Date getCurrentDateTime() throws ParseException {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
return formatter.parse(formatter.format(date));
}
/**
* 获取当前日期和时间的字符串表示。
*
* @return 当前日期和时间的字符串表示，格式为"yyyy-MM-dd HH:mm:ss"
*/
public static String getCurrentDateTimeStr() {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
return formatter.format(date);
}
/**
* 将给定的Date对象转换为字符串形式。
*
* @param dateTime 要转换的Date对象
* @return 转换后的日期字符串，格式为"yyyy-MM-dd HH:mm:ss"
*/
public static String dateToString(Date dateTime) {
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = sdf2.format(dateTime);
return strDate;
}
/**
* 将给定时间转为太平洋时间（美国洛杉矶时间）。
*
* @param date 给定的时间，类型为Date
* @return 转换后的太平洋时间字符串，格式为"yyyy-MM-dd HH:mm:ss"
*/
public static String changeTimeToPacificTime(Date date) {
//将给定时间转为太平洋时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
String pacificTime = sdf.format(date);
return pacificTime;
}
/**
* 将太平洋时间（美国洛杉矶时间）转换为北京时间。
*
* @param time 太平洋时间字符串，格式为"yyyy-MM-dd HH:mm:ss"
* @return 转换后的北京时间字符串，格式为"yyyy-MM-dd HH:mm:ss"
* @throws RuntimeException 如果输入的太平洋时间字符串格式不正确，则抛出此异常
*/
public static String changePacificTimeToCST(String time) {
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf2.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
Date date = null;
try {
date = sdf2.parse(time);
} catch (ParseException e) {
throw new RuntimeException(e);
}
//将太平洋时间转成北京时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String cstTime = sdf.format(date);
return cstTime;
}
/**
* 将太平洋时间（美国洛杉矶时间）转换为UTC时间。
*
* @param time 太平洋时间字符串，格式为"yyyy-MM-dd HH:mm:ss"
* @return 转换后的UTC时间字符串，格式为"dd/MM/yyyy"
* @throws RuntimeException 如果输入的太平洋时间字符串格式不正确，则抛出此异常
*/
public static String changePacificTimeToUTC(String time) {
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf2.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
Date date = null;
try {
date = sdf2.parse(time);
} catch (ParseException e) {
throw new RuntimeException(e);
}
//将太平洋时间转成北京时间
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
return sdf.format(date);
}
/**
* 将给定的太平洋时间字符串转换为时间戳。
*
* @param time 太平洋时间字符串，格式为"yyyy-MM-dd HH:mm:ss"
* @return 转换后的时间戳
* @throws RuntimeException 如果输入的太平洋时间字符串格式不正确，则抛出此异常
*/
public static long getPacificTimeTimestamp(String time) {
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf2.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
Date date = null;
long timestamp;
try {
date = sdf2.parse(time);
timestamp = date.getTime();
} catch (ParseException e) {
throw new RuntimeException(e);
}
return timestamp;
}
/**
* 将给定的时间字符串转换为时间戳。
*
* @param time 时间字符串，格式为"yyyy-MM-dd HH:mm:ss"
* @return 转换后的时间戳
* @throws RuntimeException 如果输入的时间字符串格式不正确，则抛出此异常
*/
public static long getCSTTimestamp(String time) {
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
long timestamp;
try {
date = sdf2.parse(time);
timestamp = date.getTime();
} catch (ParseException e) {
throw new RuntimeException(e);
}
return timestamp;
}
/**
* 将字符串转换为日期对象。
*
* @param dateStr 要转换的日期字符串
* @param format 日期字符串的格式
* @return 转换后的日期对象，如果转换失败则返回null
*/
public static Date StringToDate(String dateStr, String format) {
SimpleDateFormat dateFormat = new SimpleDateFormat(format);
Date date = null;
try {
date = dateFormat.parse(dateStr);
} catch (ParseException ex) {
ex.printStackTrace();
}
return date;
}
/**
* 获取月环比的时间段。
*
* @param startTime 开始时间字符串
* @param endTime 结束时间字符串
* @param format 日期格式
* @return 包含环比开始时间和结束时间的Map，键分别为"comparedStartTime"和"comparedEndTime"
*/
public static Map<String, String> getMoMTimePeriod(String startTime, String endTime, String format) {
// 计算出两个用户日期之间相隔多少天，然后开始时间往前按间隔得到环比的开始时间，环比结束时间为开始时间的前一天
Map<String, String> result = new HashMap<>();
List<String> dates = getDatesBetweenTwoDate(startTime, endTime, 1, Calendar.DAY_OF_MONTH, format);
int intervalDay = dates.size();
result.put("comparedStartTime", getBeforeOrAfterDateType(-intervalDay, startTime, format, Calendar.DAY_OF_MONTH));
result.put("comparedEndTime", getBeforeOrAfterDateType(-1, startTime, format, Calendar.DAY_OF_MONTH));
return result;
}
/**
* 获取当前时间的UTC/GMT时间字符串。
*
* @return 返回当前时间的UTC/GMT时间字符串，格式为"EEE, d MMM yyyy HH:mm:ss 'GMT'"
*/
public static String getUTCGMTTimeStr() {
Calendar cd = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss 'GMT'", Locale.US);
sdf.setTimeZone(TimeZone.getTimeZone("GMT")); // 设置时区为GMT
String str = sdf.format(cd.getTime());
return str;
}
/**
* 将给定的Date对象转换为日期字符串。
*
* @param date 要转换的Date对象
* @return 转换后的日期字符串，格式为"dd/MM/yyyy"
*/
public static String getDateStr(Date date) {
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy", Locale.US);
String str = sdf.format(date);
return str;
}
// 获取当天零点时间戳-----Proxy为Remo获取太平洋时间当天零点时间戳，Proxy为Korea获取首尔时间当天零点时间戳
public static Long getZeroTimestampMillis(String proxy) {
// 获取当前北京时间的毫秒级时间戳
Instant currentInstant = Instant.now();
if ("Korea".equals(proxy)) {
// 将时间戳转换为韩国首尔时间的当天零点的毫秒级时间戳
ZoneId seoulZone = ZoneId.of("Asia/Seoul");
ZonedDateTime seoulDateTime = currentInstant.atZone(seoulZone).toLocalDate().atStartOfDay(seoulZone);
long seoulZeroTimestampMillis = seoulDateTime.toInstant().toEpochMilli();
return seoulZeroTimestampMillis;
} else {
// 将时间戳转换为太平洋时间的当天零点的毫秒级时间戳
ZoneId pacificZone = ZoneId.of("America/Los_Angeles");
ZonedDateTime pacificDateTime = currentInstant.atZone(pacificZone).toLocalDate().atStartOfDay(pacificZone);
long pacificZeroTimestampMillis = pacificDateTime.toInstant().toEpochMilli();
return pacificZeroTimestampMillis;
}
}
public static DayTimestamp getDayStartAndEndTimestamp(Long timestamp, String proxy) {
DayTimestamp result = new DayTimestamp();
// 获取当前北京时间的毫秒级时间戳
if (timestamp == null) {
timestamp = System.currentTimeMillis();
}
Instant currentInstant = Instant.ofEpochMilli(timestamp);
if ("Korea".equals(proxy)) {
result.setProxy("Korea");
// 将时间戳转换为韩国首尔时间的当天零点的毫秒级时间戳
ZoneId seoulZone = ZoneId.of("Asia/Seoul");
LocalDateTime seoulDateTime = currentInstant.atZone(seoulZone).toLocalDateTime();
LocalDateTime seoulStartOfDay = seoulDateTime.toLocalDate().atStartOfDay();
LocalDateTime seoulEndOfDay = seoulStartOfDay.plusDays(1).minus(1, ChronoUnit.SECONDS);
long seoulStartOfDayTimestamp = seoulStartOfDay.atZone(seoulZone).toInstant().toEpochMilli();
long seoulEndOfDayTimestamp = seoulEndOfDay.atZone(seoulZone).toInstant().toEpochMilli();
result.setStartOfDayTimestamp(seoulStartOfDayTimestamp);
result.setEndOfDayTimestamp(seoulEndOfDayTimestamp);
} else {
result.setProxy("Remo");
// 将时间戳转换为太平洋时间的当天零点的毫秒级时间戳
ZoneId pacificZone = ZoneId.of("America/Los_Angeles");
LocalDateTime pacificDateTime = currentInstant.atZone(pacificZone).toLocalDateTime();
LocalDateTime pacificStartOfDay = pacificDateTime.toLocalDate().atStartOfDay();
LocalDateTime pacificEndOfDay = pacificStartOfDay.plusDays(1).minus(1, ChronoUnit.SECONDS);
long pacificStartOfDayTimestamp = pacificStartOfDay.atZone(pacificZone).toInstant().toEpochMilli();
long pacificEndOfDayTimestamp = pacificEndOfDay.atZone(pacificZone).toInstant().toEpochMilli();
result.setStartOfDayTimestamp(pacificStartOfDayTimestamp);
result.setEndOfDayTimestamp(pacificEndOfDayTimestamp);
}
return result;
}
/**
* 找到并返回下一个周五的日期字符串。
*
* @return 下一个周五的日期字符串，格式为 yyyy-MM-dd
*/
public static String findNearestFriday() {
LocalDate currentDate = LocalDate.now();
DayOfWeek currentDayOfWeek = currentDate.getDayOfWeek();
// 计算到下一个周五还有几天
int daysUntilNextFriday = DayOfWeek.FRIDAY.getValue() - currentDayOfWeek.getValue();
if (daysUntilNextFriday <= 0) {
daysUntilNextFriday += 7; // 如果今天就是周五，则加一周
}
// 加上天数得到下一个周五的日期
LocalDate nextFriday = currentDate.plusDays(daysUntilNextFriday);
return nextFriday.toString(); // 返回格式化的日期字符串，格式为 yyyy-MM-dd
}
/**
* 根据给定的日期字符串，获取该日期所在周的周一日期字符串。
*
* @param dateStr 日期字符串，格式为"yyyy-MM-dd"
* @return 返回该日期所在周的周一日期字符串，格式也为"yyyy-MM-dd"
*/
public static String getWeekStrByDayStr(String dateStr) {
String dateValue = null;
String week = DateUtils.getWeek(DateUtils.StringToDate(dateStr, "yyyy-MM-dd"));
int interval = DateUtils.getIntervalFromMonday(week);
if (interval == 0) {
dateValue = dateStr;
} else {
dateValue = DateUtils.getBeforeOrAfterDateType(interval, dateStr, "yyyy-MM-dd", Calendar.DAY_OF_MONTH);
}
return dateValue;
}
/**
* 获取给定日期是星期几。
*
* @param date 给定的日期
* @return 返回给定日期是星期几，用英文缩写表示（例如："Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"）
*/
public static String getWeek(Date date) {
String[] weeks = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
if (week_index < 0) {
week_index = 0;
}
return weeks[week_index];
}
/**
* 根据给定的星期几，计算距离周一的天数间隔。
*
* @param week 给定的星期几，用英文缩写表示（例如："Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"）
* @return 返回距离周一的天数间隔，周一返回0，周二返回-1，周三返回-2，以此类推
*/
public static int getIntervalFromMonday(String week) {
if ("Tue".equals(week)) {
return -1;
} else if ("Wed".equals(week)) {
return -2;
} else if ("Thu".equals(week)) {
return -3;
} else if ("Fri".equals(week)) {
return -4;
} else if ("Sat".equals(week)) {
return -5;
} else if ("Sun".equals(week)) {
return -6;
}
return 0;
}
/**
* 根据给定的月份字符串，获取该月份所在的季度字符串。
*
* @param dateStr 日期字符串，格式为"yyyy-MM"
* @return 返回该月份所在的季度字符串，格式为"yyyy-MM"，其中MM为季度的起始月份
*/
public static String getQuarterStrByMonthStr(String dateStr) {
String dateValue = null;
String subYear = dateStr.substring(0, 4);
String monthStr = dateStr.substring(5);
if ("01".equals(monthStr) || "02".equals(monthStr) || "03".equals(monthStr)) {
dateValue = subYear + "-" + "01";
} else if ("04".equals(monthStr) || "05".equals(monthStr) || "06".equals(monthStr)) {
dateValue = subYear + "-" + "04";
} else if ("07".equals(monthStr) || "08".equals(monthStr) || "09".equals(monthStr)) {
dateValue = subYear + "-" + "07";
} else if ("10".equals(monthStr) || "11".equals(monthStr) || "12".equals(monthStr)) {
dateValue = subYear + "-" + "10";
}
return dateValue;
}
/**
* 根据给定的时间戳、代理和类型，获取太平洋时间当天开始和结束的时间戳。
*
* @param timestamp 给定的时间戳，如果为null，则使用当前系统时间
* @param proxy 代理类型，用于确定时区（"Korea"表示韩国首尔时间，"其他"表示美国洛杉矶时间）
* @param type 类型，用于确定返回当天开始时间戳还是结束时间戳（"startTime"表示开始时间戳，"其他"表示结束时间戳）
* @return 返回太平洋时间当天开始或结束的时间戳
*/
public static Long getDayStartAndEndTimestamp(Long timestamp, String proxy, String type) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 将时间戳转换为Date对象
Date date = new Date(timestamp);
//获取北京时间字符串
String dateStr = sdf.format(date);
// 获取当前北京时间的毫秒级时间戳
if (timestamp == null) {
timestamp = System.currentTimeMillis();
}
Instant currentInstant = Instant.ofEpochMilli(timestamp);
}
/**
* 根据给定的日期字符串，获取太平洋时区该日期当天的开始时间戳（午夜00:00）。
*
* @param dateStr 日期字符串，格式为ISO 8601标准（例如："2023-10-05"）
* @return 返回太平洋时区该日期当天的开始时间戳（以毫秒为单位）
*/
public static long getPacificZoneStartTimestampByDateStr(String dateStr) {
// 解析日期字符串为LocalDate对象
LocalDate date = LocalDate.parse(dateStr, DateTimeFormatter.ISO_LOCAL_DATE);
// 指定目标时区为太平洋时区
ZoneId pacificZone = ZoneId.of("America/Los_Angeles");
// 创建ZonedDateTime对象，将日期和时间设为午夜（00:00）
ZonedDateTime zonedDateTime = ZonedDateTime.of(date, LocalTime.MIDNIGHT, pacificZone);
// 转换为Instant对象（获取时间戳）
Instant instant = zonedDateTime.toInstant();
long timestamp = instant.toEpochMilli();
return timestamp;
}
}
1409
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
