史上最全Java8日期时间工具类(分享)

2023-07-08 06:39:03 81
这是我总结的Java8日期工具类，应该是比较全面的，满足日常开发绝大部分需求，分享给大家，有错误之处，还望大神指教。
/**
*Java8日期时间工具类
*
*@authorJourWon
*@date2020/12/13
*/
publicclassLocalDateUtils{

/**
*显示年月日时分秒，例如2015-08-1109:51:53.
*/
publicstaticfinalStringDATETIME_PATTERN="yyyy-MM-ddHH:mm:ss";

/**
*仅显示年月日，例如2015-08-11.
*/
publicstaticfinalStringDATE_PATTERN="yyyy-MM-dd";

/**
*仅显示时分秒，例如09:51:53.
*/
publicstaticfinalStringTIME_PATTERN="HH:mm:ss";

/**
*显示年月日时分秒(无符号)，例如20150811095153.
*/
publicstaticfinalStringUNSIGNED_DATETIME_PATTERN="yyyyMMddHHmmss";

/**
*仅显示年月日(无符号)，例如20150811.
*/
publicstaticfinalStringUNSIGNED_DATE_PATTERN="yyyyMMdd";

/**
*春天;
*/
publicstaticfinalIntegerSPRING=1;

/**
*夏天;
*/
publicstaticfinalIntegerSUMMER=2;

/**
*秋天;
*/
publicstaticfinalIntegerAUTUMN=3;

/**
*冬天;
*/
publicstaticfinalIntegerWINTER=4;

/**
*星期日;
*/
publicstaticfinalStringSUNDAY="星期日";

/**
*星期一;
*/
publicstaticfinalStringMONDAY="星期一";

/**
*星期二;
*/
publicstaticfinalStringTUESDAY="星期二";

/**
*星期三;
*/
publicstaticfinalStringWEDNESDAY="星期三";

/**
*星期四;
*/
publicstaticfinalStringTHURSDAY="星期四";

/**
*星期五;
*/
publicstaticfinalStringFRIDAY="星期五";

/**
*星期六;
*/
publicstaticfinalStringSATURDAY="星期六";

/**
*年
*/
privatestaticfinalStringYEAR="year";

/**
*月
*/
privatestaticfinalStringMONTH="month";

/**
*周
*/
privatestaticfinalStringWEEK="week";

/**
*日
*/
privatestaticfinalStringDAY="day";

/**
*时
*/
privatestaticfinalStringHOUR="hour";

/**
*分
*/
privatestaticfinalStringMINUTE="minute";

/**
*秒
*/
privatestaticfinalStringSECOND="second";

/**
*获取当前日期和时间字符串.
*
*@returnString日期时间字符串，例如2015-08-1109:51:53
*/
publicstaticStringgetLocalDateTimeStr(){
returnformat(LocalDateTime.now(),DATETIME_PATTERN);
}

/**
*获取当前日期字符串.
*
*@returnString日期字符串，例如2015-08-11
*/
publicstaticStringgetLocalDateStr(){
returnformat(LocalDate.now(),DATE_PATTERN);
}

/**
*获取当前时间字符串.
*
*@returnString时间字符串，例如09:51:53
*/
publicstaticStringgetLocalTimeStr(){
returnformat(LocalTime.now(),TIME_PATTERN);
}

/**
*获取当前星期字符串.
*
*@returnString当前星期字符串，例如星期二
*/
publicstaticStringgetDayOfWeekStr(){
returnformat(LocalDate.now(),"E");
}

/**
*获取指定日期是星期几
*
*@paramlocalDate日期
*@returnString星期几
*/
publicstaticStringgetDayOfWeekStr(LocalDatelocalDate){
String[]weekOfDays={MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY};
intdayOfWeek=localDate.getDayOfWeek().getValue()-1;
returnweekOfDays[dayOfWeek];
}

/**
*获取日期时间字符串
*
*@paramtemporal需要转化的日期时间
*@parampattern时间格式
*@returnString日期时间字符串，例如2015-08-1109:51:53
*/
publicstaticStringformat(TemporalAccessortemporal,Stringpattern){
DateTimeFormatterdateTimeFormatter=DateTimeFormatter.ofPattern(pattern);
returndateTimeFormatter.format(temporal);
}

/**
*日期时间字符串转换为日期时间(java.time.LocalDateTime)
*
*@paramlocalDateTimeStr日期时间字符串
*@parampattern日期时间格式例如DATETIME_PATTERN
*@returnLocalDateTime日期时间
*/
publicstaticLocalDateTimeparseLocalDateTime(StringlocalDateTimeStr,Stringpattern){
DateTimeFormatterdateTimeFormatter=DateTimeFormatter.ofPattern(pattern);
returnLocalDateTime.parse(localDateTimeStr,dateTimeFormatter);
}

/**
*日期字符串转换为日期(java.time.LocalDate)
*
*@paramlocalDateStr日期字符串
*@parampattern日期格式例如DATE_PATTERN
*@returnLocalDate日期
*/
publicstaticLocalDateparseLocalDate(StringlocalDateStr,Stringpattern){
DateTimeFormatterdateTimeFormatter=DateTimeFormatter.ofPattern(pattern);
returnLocalDate.parse(localDateStr,dateTimeFormatter);
}

/**
*获取指定日期时间加上指定数量日期时间单位之后的日期时间.
*
*@paramlocalDateTime日期时间
*@paramnum数量
*@paramchronoUnit日期时间单位
*@returnLocalDateTime新的日期时间
*/
publicstaticLocalDateTimeplus(LocalDateTimelocalDateTime,intnum,ChronoUnitchronoUnit){
returnlocalDateTime.plus(num,chronoUnit);
}

/**
*获取指定日期时间减去指定数量日期时间单位之后的日期时间.
*
*@paramlocalDateTime日期时间
*@paramnum数量
*@paramchronoUnit日期时间单位
*@returnLocalDateTime新的日期时间
*/
publicstaticLocalDateTimeminus(LocalDateTimelocalDateTime,intnum,ChronoUnitchronoUnit){
returnlocalDateTime.minus(num,chronoUnit);
}

/**
*根据ChronoUnit计算两个日期时间之间相隔日期时间
*
*@paramstart开始日期时间
*@paramend结束日期时间
*@paramchronoUnit日期时间单位
*@returnlong相隔日期时间
*/
publicstaticlonggetChronoUnitBetween(LocalDateTimestart,LocalDateTimeend,ChronoUnitchronoUnit){
returnMath.abs(start.until(end,chronoUnit));
}

/**
*根据ChronoUnit计算两个日期之间相隔年数或月数或天数
*
*@paramstart开始日期
*@paramend结束日期
*@paramchronoUnit日期时间单位,(ChronoUnit.YEARS,ChronoUnit.MONTHS,ChronoUnit.WEEKS,ChronoUnit.DAYS)
*@returnlong相隔年数或月数或天数
*/
publicstaticlonggetChronoUnitBetween(LocalDatestart,LocalDateend,ChronoUnitchronoUnit){
returnMath.abs(start.until(end,chronoUnit));
}

/**
*获取本年第一天的日期字符串
*
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfYearStr(){
returngetFirstDayOfYearStr(LocalDateTime.now());
}

/**
*获取本年最后一天的日期字符串
*
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfYearStr(){
returngetLastDayOfYearStr(LocalDateTime.now());
}

/**
*获取指定日期当年第一天的日期字符串
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfYearStr(LocalDateTimelocalDateTime){
returngetFirstDayOfYearStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期当年最后一天的日期字符串
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfYearStr(LocalDateTimelocalDateTime){
returngetLastDayOfYearStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期当年第一天的日期字符串,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@parampattern日期时间格式
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfYearStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.withDayOfYear(1).withHour(0).withMinute(0).withSecond(0),pattern);
}

/**
*获取指定日期当年最后一天的日期字符串,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@parampattern日期时间格式
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfYearStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.with(TemporalAdjusters.lastDayOfYear()).withHour(23).withMinute(59).withSecond(59),pattern);
}

/**
*获取本月第一天的日期字符串
*
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfMonthStr(){
returngetFirstDayOfMonthStr(LocalDateTime.now());
}

/**
*获取本月最后一天的日期字符串
*
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfMonthStr(){
returngetLastDayOfMonthStr(LocalDateTime.now());
}

/**
*获取指定日期当月第一天的日期字符串
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetFirstDayOfMonthStr(LocalDateTimelocalDateTime){
returngetFirstDayOfMonthStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期当月最后一天的日期字符串
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfMonthStr(LocalDateTimelocalDateTime){
returngetLastDayOfMonthStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期当月第一天的日期字符串,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfMonthStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0),pattern);
}

/**
*获取指定日期当月最后一天的日期字符串,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@parampattern日期时间格式
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfMonthStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.with(TemporalAdjusters.lastDayOfMonth()).withHour(23).withMinute(59).withSecond(59),pattern);
}

/**
*获取本周第一天的日期字符串
*
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfWeekStr(){
returngetFirstDayOfWeekStr(LocalDateTime.now());
}

/**
*获取本周最后一天的日期字符串
*
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfWeekStr(){
returngetLastDayOfWeekStr(LocalDateTime.now());
}

/**
*获取指定日期当周第一天的日期字符串,这里第一天为周一
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfWeekStr(LocalDateTimelocalDateTime){
returngetFirstDayOfWeekStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期当周最后一天的日期字符串,这里最后一天为周日
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfWeekStr(LocalDateTimelocalDateTime){
returngetLastDayOfWeekStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期当周第一天的日期字符串,这里第一天为周一,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@parampattern日期时间格式
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetFirstDayOfWeekStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.with(DayOfWeek.MONDAY).withHour(0).withMinute(0).withSecond(0),pattern);
}

/**
*获取指定日期当周最后一天的日期字符串,这里最后一天为周日,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@parampattern日期时间格式
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetLastDayOfWeekStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.with(DayOfWeek.SUNDAY).withHour(23).withMinute(59).withSecond(59),pattern);
}

/**
*获取今天开始时间的日期字符串
*
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetStartTimeOfDayStr(){
returngetStartTimeOfDayStr(LocalDateTime.now());
}

/**
*获取今天结束时间的日期字符串
*
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetEndTimeOfDayStr(){
returngetEndTimeOfDayStr(LocalDateTime.now());
}

/**
*获取指定日期开始时间的日期字符串
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd00:00:00
*/
publicstaticStringgetStartTimeOfDayStr(LocalDateTimelocalDateTime){
returngetStartTimeOfDayStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期结束时间的日期字符串
*
*@paramlocalDateTime指定日期时间
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetEndTimeOfDayStr(LocalDateTimelocalDateTime){
returngetEndTimeOfDayStr(localDateTime,DATETIME_PATTERN);
}

/**
*获取指定日期开始时间的日期字符串,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@parampattern日期时间格式
*@returnString格式：yyyy-MM-ddHH:mm:ss
*/
publicstaticStringgetStartTimeOfDayStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.withHour(0).withMinute(0).withSecond(0),pattern);
}

/**
*获取指定日期结束时间的日期字符串,带日期格式化参数
*
*@paramlocalDateTime指定日期时间
*@parampattern日期时间格式
*@returnString格式：yyyy-MM-dd23:59:59
*/
publicstaticStringgetEndTimeOfDayStr(LocalDateTimelocalDateTime,Stringpattern){
returnformat(localDateTime.withHour(23).withMinute(59).withSecond(59),pattern);
}

/**
*切割日期。按照周期切割成小段日期段。例如：

*
*@paramstartDate开始日期（yyyy-MM-dd）
*@paramendDate结束日期（yyyy-MM-dd）
*@paramperiod周期（天，周，月，年）
*@return切割之后的日期集合
*startDate="2019-02-28",endDate="2019-03-05",period="day"
*结果为：[2019-02-28,2019-03-01,2019-03-02,2019-03-03,2019-03-04,2019-03-05]


*startDate="2019-02-28",endDate="2019-03-25",period="week"
*结果为：[2019-02-28,2019-03-06,2019-03-07,2019-03-13,2019-03-14,2019-03-20,
*2019-03-21,2019-03-25]


*startDate="2019-02-28",endDate="2019-05-25",period="month"
*结果为：[2019-02-28,2019-02-28,2019-03-01,2019-03-31,2019-04-01,2019-04-30,
*2019-05-01,2019-05-25]


*startDate="2019-02-28",endDate="2020-05-25",period="year"
*结果为：[2019-02-28,2019-12-31,2020-01-01,2020-05-25]


*/
publicstaticListlistDateStrs(StringstartDate,StringendDate,Stringperiod){
Listresult=newArrayList<>();
DateTimeFormatterdateTimeFormatter=DateTimeFormatter.ofPattern(DATE_PATTERN);
LocalDateend=LocalDate.parse(endDate,dateTimeFormatter);
LocalDatestart=LocalDate.parse(startDate,dateTimeFormatter);
LocalDatetmp=start;
switch(period){
caseDAY:
while(start.isBefore(end)||start.isEqual(end)){
result.add(start.toString());
start=start.plusDays(1);
}
break;
caseWEEK:
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;
caseMONTH:
while(tmp.isBefore(end)||tmp.isEqual(end)){
LocalDatelastDayOfMonth=tmp.with(TemporalAdjusters.lastDayOfMonth());
if(lastDayOfMonth.isAfter(end)){
result.add(tmp.toString()+","+end);
}else{
result.add(tmp.toString()+","+lastDayOfMonth);
}
tmp=lastDayOfMonth.plusDays(1);
}
break;
caseYEAR:
while(tmp.isBefore(end)||tmp.isEqual(end)){
LocalDatelastDayOfYear=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;
}
returnresult;
}

publicstaticvoidmain(String[]args){
System.out.println(getLocalDateTimeStr());
System.out.println(getLocalDateStr());
System.out.println(getLocalTimeStr());
System.out.println(getDayOfWeekStr());
System.out.println(getDayOfWeekStr(LocalDate.now()));

System.out.println("========");
System.out.println(format(LocalDate.now(),UNSIGNED_DATE_PATTERN));

System.out.println("========");
System.out.println(parseLocalDateTime("2020-12-1311:14:12",DATETIME_PATTERN));
System.out.println(parseLocalDate("2020-12-13",DATE_PATTERN));

System.out.println("========");
System.out.println(plus(LocalDateTime.now(),3,ChronoUnit.HOURS));
System.out.println(minus(LocalDateTime.now(),4,ChronoUnit.DAYS));

System.out.println("========");
System.out.println(getChronoUnitBetween(LocalDateTime.now(),parseLocalDateTime("2020-12-1212:03:12",DATETIME_PATTERN),ChronoUnit.MINUTES));
System.out.println(getChronoUnitBetween(LocalDate.now(),parseLocalDate("2021-12-12",DATE_PATTERN),ChronoUnit.WEEKS));

System.out.println("========");
System.out.println(getFirstDayOfYearStr());
System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println(getLastDayOfYearStr());
System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println("========");
System.out.println(getFirstDayOfMonthStr());
System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println(getLastDayOfMonthStr());
System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println("========");
System.out.println(getFirstDayOfWeekStr());
System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println(getLastDayOfWeekStr());
System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println("========");
System.out.println(getStartTimeOfDayStr());
System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println(getEndTimeOfDayStr());
System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN)));
System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-1212:03:12",DATETIME_PATTERN),UNSIGNED_DATETIME_PATTERN));

System.out.println("========");
ListdateStrs=listDateStrs("2019-01-30","2020-12-13",YEAR);
for(StringdateStr:dateStrs){
System.out.println(dateStr);
}

System.out.println("========");
ListdateStrs1=listDateStrs("2019-01-30","2020-12-13",MONTH);
for(StringdateStr:dateStrs1){
System.out.println(dateStr);
}

System.out.println("========");
ListdateStrs2=listDateStrs("2020-12-01","2020-12-13",DAY);
for(StringdateStr:dateStrs2){
System.out.println(dateStr);
}
}
}
到此这篇关于史上最全Java8日期时间工具类(分享)的文章就介绍到这了,更多相关Java8日期时间工具类内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！
史上最全Java8日期时间工具类(分享)

热门推荐

随机推荐
