ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-05-09 23:51:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix code

Browse Source
This commit is contained in:
Looly 2022-07-22 16:58:52 +08:00
parent f879f3084a
commit b74b7c682c
8 changed files with 261 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
hutool-core/src/main/java/cn/hutool/core/date/DateUtil.java
View File

@ -635,57 +635,6 @@ public class DateUtil extends CalendarUtil {
return CalendarUtil.formatChineseDate(CalendarUtil.calendar(date), withTime); return CalendarUtil.formatChineseDate(CalendarUtil.calendar(date), withTime);
} }
/**
* 返回可读的时间间隔，如1天20小时3分48秒
* @param milliSecond 毫秒
* @author zrh 455741807@qq.com
* @return
*/
public static String formatDuring(long milliSecond) {
final int i1000=1000;
if (milliSecond <= 0) {
return "小于1毫秒";
}
if (milliSecond < i1000) {
return milliSecond + "毫秒";
}
String result = "";
long days = milliSecond / (1000 * 60 * 60 * 24);
long hours = (milliSecond % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60);
long minutes = (milliSecond % (1000 * 60 * 60)) / (1000 * 60);
long seconds = (milliSecond % (1000 * 60)) / 1000;
if (days > 0) {
result += days + "天";
}
if (hours > 0) {
result += hours + "小时";
}
if (minutes > 0) {
result += minutes + "分";
}
if (seconds >= 0) {
result += seconds + "秒";
}
return result;
}
/**
* 返回两个日期之间间隔时间
* @param begin 开始日期
* @param end 结束日期
* @author zrh 455741807@qq.com
* @return
*/
public static String formatDuring(Date begin, Date end) {
if(begin == null || end == null) {
return "";
}
return formatDuring(end.getTime()-begin.getTime());
}
// ------------------------------------ Format end ---------------------------------------------- // ------------------------------------ Format end ----------------------------------------------
// ------------------------------------ Parse start ---------------------------------------------- // ------------------------------------ Parse start ----------------------------------------------

413
hutool-core/src/test/java/cn/hutool/core/date/DateUtilTest.java
View File

@ -39,46 +39,46 @@ public class DateUtilTest {
@Test @Test
public void nowTest() { public void nowTest() {
// 当前时间 // 当前时间
Date date = DateUtil.date(); final Date date = DateUtil.date();
Assert.assertNotNull(date); Assert.assertNotNull(date);
// 当前时间 // 当前时间
Date date2 = DateUtil.date(Calendar.getInstance()); final Date date2 = DateUtil.date(Calendar.getInstance());
Assert.assertNotNull(date2); Assert.assertNotNull(date2);
// 当前时间 // 当前时间
Date date3 = DateUtil.date(System.currentTimeMillis()); final Date date3 = DateUtil.date(System.currentTimeMillis());
Assert.assertNotNull(date3); Assert.assertNotNull(date3);
// 当前日期字符串，格式：yyyy-MM-dd HH:mm:ss // 当前日期字符串，格式：yyyy-MM-dd HH:mm:ss
String now = DateUtil.now(); final String now = DateUtil.now();
Assert.assertNotNull(now); Assert.assertNotNull(now);
// 当前日期字符串，格式：yyyy-MM-dd // 当前日期字符串，格式：yyyy-MM-dd
String today = DateUtil.today(); final String today = DateUtil.today();
Assert.assertNotNull(today); Assert.assertNotNull(today);
} }
@Test @Test
public void formatAndParseTest() { public void formatAndParseTest() {
String dateStr = "2017-03-01"; final String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr); final Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, "yyyy/MM/dd"); final String format = DateUtil.format(date, "yyyy/MM/dd");
Assert.assertEquals("2017/03/01", format); Assert.assertEquals("2017/03/01", format);
// 常用格式的格式化 // 常用格式的格式化
String formatDate = DateUtil.formatDate(date); final String formatDate = DateUtil.formatDate(date);
Assert.assertEquals("2017-03-01", formatDate); Assert.assertEquals("2017-03-01", formatDate);
String formatDateTime = DateUtil.formatDateTime(date); final String formatDateTime = DateUtil.formatDateTime(date);
Assert.assertEquals("2017-03-01 00:00:00", formatDateTime); Assert.assertEquals("2017-03-01 00:00:00", formatDateTime);
String formatTime = DateUtil.formatTime(date); final String formatTime = DateUtil.formatTime(date);
Assert.assertEquals("00:00:00", formatTime); Assert.assertEquals("00:00:00", formatTime);
} }
@Test @Test
public void formatAndParseCustomTest() { public void formatAndParseCustomTest() {
String dateStr = "2017-03-01"; final String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr); final Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, "#sss"); final String format = DateUtil.format(date, "#sss");
Assert.assertEquals("1488297600", format); Assert.assertEquals("1488297600", format);
final DateTime parse = DateUtil.parse(format, "#sss"); final DateTime parse = DateUtil.parse(format, "#sss");
@ -87,49 +87,26 @@ public class DateUtilTest {
@Test @Test
public void formatAndParseCustomTest2() { public void formatAndParseCustomTest2() {
String dateStr = "2017-03-01"; final String dateStr = "2017-03-01";
Date date = DateUtil.parse(dateStr); final Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, "#SSS"); final String format = DateUtil.format(date, "#SSS");
Assert.assertEquals("1488297600000", format); Assert.assertEquals("1488297600000", format);
final DateTime parse = DateUtil.parse(format, "#SSS"); final DateTime parse = DateUtil.parse(format, "#SSS");
Assert.assertEquals(date, parse); Assert.assertEquals(date, parse);
} }
@Test
public void formatDuring() {
long d = 56123456;
String s = DateUtil.formatDuring(d);
Assert.assertEquals("15小时35分23秒", s);
}
@Test
public void testFormatDuring() {
Calendar c = Calendar.getInstance();
Date s = c.getTime();
c.add(Calendar.DAY_OF_MONTH, 1);
c.add(Calendar.MINUTE, 2);
c.add(Calendar.SECOND, 3);
Date e = c.getTime();
String str = DateUtil.formatDuring(s, e);
Assert.assertEquals("1天2分3秒", str);
}
@Test @Test
public void beginAndEndTest() { public void beginAndEndTest() {
String dateStr = "2017-03-01 00:33:23"; final String dateStr = "2017-03-01 00:33:23";
Date date = DateUtil.parse(dateStr); final Date date = DateUtil.parse(dateStr);
// 一天的开始 // 一天的开始
Date beginOfDay = DateUtil.beginOfDay(date); final Date beginOfDay = DateUtil.beginOfDay(date);
Assert.assertEquals("2017-03-01 00:00:00", beginOfDay.toString()); Assert.assertEquals("2017-03-01 00:00:00", beginOfDay.toString());
// 一天的结束 // 一天的结束
Date endOfDay = DateUtil.endOfDay(date); final Date endOfDay = DateUtil.endOfDay(date);
Assert.assertEquals("2017-03-01 23:59:59", endOfDay.toString()); Assert.assertEquals("2017-03-01 23:59:59", endOfDay.toString());
} }
@ -141,16 +118,16 @@ public class DateUtilTest {
@Test @Test
public void truncateTest() { public void truncateTest() {
String dateStr2 = "2020-02-29 12:59:34"; final String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2); final Date date2 = DateUtil.parse(dateStr2);
final DateTime dateTime = DateUtil.truncate(date2, DateField.MINUTE); final DateTime dateTime = DateUtil.truncate(date2, DateField.MINUTE);
Assert.assertEquals("2020-02-29 12:59:00", dateTime.toString()); Assert.assertEquals("2020-02-29 12:59:00", dateTime.toString());
} }
@Test @Test
public void ceilingMinuteTest() { public void ceilingMinuteTest() {
String dateStr2 = "2020-02-29 12:59:34"; final String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2); final Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.ceiling(date2, DateField.MINUTE); DateTime dateTime = DateUtil.ceiling(date2, DateField.MINUTE);
@ -162,8 +139,8 @@ public class DateUtilTest {
@Test @Test
public void ceilingDayTest() { public void ceilingDayTest() {
String dateStr2 = "2020-02-29 12:59:34"; final String dateStr2 = "2020-02-29 12:59:34";
Date date2 = DateUtil.parse(dateStr2); final Date date2 = DateUtil.parse(dateStr2);
DateTime dateTime = DateUtil.ceiling(date2, DateField.DAY_OF_MONTH); DateTime dateTime = DateUtil.ceiling(date2, DateField.DAY_OF_MONTH);
@ -175,64 +152,64 @@ public class DateUtilTest {
@Test @Test
public void beginOfWeekTest() { public void beginOfWeekTest() {
String dateStr = "2017-03-01 22:33:23"; final String dateStr = "2017-03-01 22:33:23";
DateTime date = DateUtil.parse(dateStr); final DateTime date = DateUtil.parse(dateStr);
Objects.requireNonNull(date).setFirstDayOfWeek(Week.MONDAY); Objects.requireNonNull(date).setFirstDayOfWeek(Week.MONDAY);
// 一周的开始 // 一周的开始
Date beginOfWeek = DateUtil.beginOfWeek(date); final Date beginOfWeek = DateUtil.beginOfWeek(date);
Assert.assertEquals("2017-02-27 00:00:00", beginOfWeek.toString()); Assert.assertEquals("2017-02-27 00:00:00", beginOfWeek.toString());
// 一周的结束 // 一周的结束
Date endOfWeek = DateUtil.endOfWeek(date); final Date endOfWeek = DateUtil.endOfWeek(date);
Assert.assertEquals("2017-03-05 23:59:59", endOfWeek.toString()); Assert.assertEquals("2017-03-05 23:59:59", endOfWeek.toString());
Calendar calendar = DateUtil.calendar(date); final Calendar calendar = DateUtil.calendar(date);
// 一周的开始 // 一周的开始
Calendar begin = DateUtil.beginOfWeek(calendar); final Calendar begin = DateUtil.beginOfWeek(calendar);
Assert.assertEquals("2017-02-27 00:00:00", DateUtil.date(begin).toString()); Assert.assertEquals("2017-02-27 00:00:00", DateUtil.date(begin).toString());
// 一周的结束 // 一周的结束
Calendar end = DateUtil.endOfWeek(calendar); final Calendar end = DateUtil.endOfWeek(calendar);
Assert.assertEquals("2017-03-05 23:59:59", DateUtil.date(end).toString()); Assert.assertEquals("2017-03-05 23:59:59", DateUtil.date(end).toString());
} }
@Test @Test
public void beginOfWeekTest2() { public void beginOfWeekTest2() {
String beginStr = "2020-03-11"; final String beginStr = "2020-03-11";
DateTime date = DateUtil.parseDate(beginStr); final DateTime date = DateUtil.parseDate(beginStr);
Calendar calendar = date.toCalendar(); final Calendar calendar = date.toCalendar();
final Calendar begin = DateUtil.beginOfWeek(calendar, false); final Calendar begin = DateUtil.beginOfWeek(calendar, false);
Assert.assertEquals("2020-03-08 00:00:00", DateUtil.date(begin).toString()); Assert.assertEquals("2020-03-08 00:00:00", DateUtil.date(begin).toString());
Calendar calendar2 = date.toCalendar(); final Calendar calendar2 = date.toCalendar();
final Calendar end = DateUtil.endOfWeek(calendar2, false); final Calendar end = DateUtil.endOfWeek(calendar2, false);
Assert.assertEquals("2020-03-14 23:59:59", DateUtil.date(end).toString()); Assert.assertEquals("2020-03-14 23:59:59", DateUtil.date(end).toString());
} }
@Test @Test
public void offsetDateTest() { public void offsetDateTest() {
String dateStr = "2017-03-01 22:33:23"; final String dateStr = "2017-03-01 22:33:23";
Date date = DateUtil.parse(dateStr); final Date date = DateUtil.parse(dateStr);
Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2); final Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);
Assert.assertEquals("2017-03-03 22:33:23", newDate.toString()); Assert.assertEquals("2017-03-03 22:33:23", newDate.toString());
// 偏移天 // 偏移天
DateTime newDate2 = DateUtil.offsetDay(date, 3); final DateTime newDate2 = DateUtil.offsetDay(date, 3);
Assert.assertEquals("2017-03-04 22:33:23", newDate2.toString()); Assert.assertEquals("2017-03-04 22:33:23", newDate2.toString());
// 偏移小时 // 偏移小时
DateTime newDate3 = DateUtil.offsetHour(date, -3); final DateTime newDate3 = DateUtil.offsetHour(date, -3);
Assert.assertEquals("2017-03-01 19:33:23", newDate3.toString()); Assert.assertEquals("2017-03-01 19:33:23", newDate3.toString());
// 偏移月 // 偏移月
DateTime offsetMonth = DateUtil.offsetMonth(date, -1); final DateTime offsetMonth = DateUtil.offsetMonth(date, -1);
Assert.assertEquals("2017-02-01 22:33:23", offsetMonth.toString()); Assert.assertEquals("2017-02-01 22:33:23", offsetMonth.toString());
} }
@Test @Test
public void offsetMonthTest() { public void offsetMonthTest() {
DateTime st = DateUtil.parseDate("2018-05-31"); final DateTime st = DateUtil.parseDate("2018-05-31");
List<DateTime> list = new ArrayList<>(); final List<DateTime> list = new ArrayList<>();
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
list.add(DateUtil.offsetMonth(st, i)); list.add(DateUtil.offsetMonth(st, i));
} }
@ -244,11 +221,11 @@ public class DateUtilTest {
@Test @Test
public void betweenTest() { public void betweenTest() {
String dateStr1 = "2017-03-01 22:34:23"; final String dateStr1 = "2017-03-01 22:34:23";
Date date1 = DateUtil.parse(dateStr1); final Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14"; final String dateStr2 = "2017-04-01 23:56:14";
Date date2 = DateUtil.parse(dateStr2); final Date date2 = DateUtil.parse(dateStr2);
// 相差月 // 相差月
long betweenMonth = DateUtil.betweenMonth(date1, date2, false); long betweenMonth = DateUtil.betweenMonth(date1, date2, false);
@ -295,13 +272,13 @@ public class DateUtilTest {
@Test @Test
public void betweenTest2() { public void betweenTest2() {
long between = DateUtil.between(DateUtil.parse("2019-05-06 02:15:00"), DateUtil.parse("2019-05-06 02:20:00"), DateUnit.HOUR); final long between = DateUtil.between(DateUtil.parse("2019-05-06 02:15:00"), DateUtil.parse("2019-05-06 02:20:00"), DateUnit.HOUR);
Assert.assertEquals(0, between); Assert.assertEquals(0, between);
} }
@Test @Test
public void betweenTest3() { public void betweenTest3() {
long between = DateUtil.between(DateUtil.parse("2020-03-31 23:59:59"), DateUtil.parse("2020-04-01 00:00:00"), DateUnit.SECOND); final long between = DateUtil.between(DateUtil.parse("2020-03-31 23:59:59"), DateUtil.parse("2020-04-01 00:00:00"), DateUnit.SECOND);
Assert.assertEquals(1, between); Assert.assertEquals(1, between);
} }
@ -325,20 +302,20 @@ public class DateUtilTest {
@Test @Test
public void formatBetweenTest() { public void formatBetweenTest() {
String dateStr1 = "2017-03-01 22:34:23"; final String dateStr1 = "2017-03-01 22:34:23";
Date date1 = DateUtil.parse(dateStr1); final Date date1 = DateUtil.parse(dateStr1);
String dateStr2 = "2017-04-01 23:56:14"; final String dateStr2 = "2017-04-01 23:56:14";
Date date2 = DateUtil.parse(dateStr2); final Date date2 = DateUtil.parse(dateStr2);
long between = DateUtil.between(date1, date2, DateUnit.MS); final long between = DateUtil.between(date1, date2, DateUnit.MS);
String formatBetween = DateUtil.formatBetween(between, Level.MINUTE); final String formatBetween = DateUtil.formatBetween(between, Level.MINUTE);
Assert.assertEquals("31天1小时21分", formatBetween); Assert.assertEquals("31天1小时21分", formatBetween);
} }
@Test @Test
public void timerTest() { public void timerTest() {
TimeInterval timer = DateUtil.timer(); final TimeInterval timer = DateUtil.timer();
// --------------------------------- // ---------------------------------
// -------这是执行过程 // -------这是执行过程
@ -351,23 +328,23 @@ public class DateUtilTest {
@Test @Test
public void currentTest() { public void currentTest() {
long current = DateUtil.current(); final long current = DateUtil.current();
String currentStr = String.valueOf(current); final String currentStr = String.valueOf(current);
Assert.assertEquals(13, currentStr.length()); Assert.assertEquals(13, currentStr.length());
long currentNano = DateUtil.current(); final long currentNano = DateUtil.current();
String currentNanoStr = String.valueOf(currentNano); final String currentNanoStr = String.valueOf(currentNano);
Assert.assertNotNull(currentNanoStr); Assert.assertNotNull(currentNanoStr);
} }
@Test @Test
public void weekOfYearTest() { public void weekOfYearTest() {
// 第一周周日 // 第一周周日
int weekOfYear1 = DateUtil.weekOfYear(DateUtil.parse("2016-01-03")); final int weekOfYear1 = DateUtil.weekOfYear(DateUtil.parse("2016-01-03"));
Assert.assertEquals(1, weekOfYear1); Assert.assertEquals(1, weekOfYear1);
// 第二周周四 // 第二周周四
int weekOfYear2 = DateUtil.weekOfYear(DateUtil.parse("2016-01-07")); final int weekOfYear2 = DateUtil.weekOfYear(DateUtil.parse("2016-01-07"));
Assert.assertEquals(2, weekOfYear2); Assert.assertEquals(2, weekOfYear2);
} }
@ -397,34 +374,34 @@ public class DateUtilTest {
@Test @Test
public void secondToTimeTest2() { public void secondToTimeTest2() {
String s1 = "55:02:18"; final String s1 = "55:02:18";
String s2 = "55:00:50"; final String s2 = "55:00:50";
int i = DateUtil.timeToSecond(s1) + DateUtil.timeToSecond(s2); final int i = DateUtil.timeToSecond(s1) + DateUtil.timeToSecond(s2);
String s = DateUtil.secondToTime(i); final String s = DateUtil.secondToTime(i);
Assert.assertEquals("110:03:08", s); Assert.assertEquals("110:03:08", s);
} }
@Test @Test
public void parseTest2() { public void parseTest2() {
// 转换时间与SimpleDateFormat结果保持一致即可 // 转换时间与SimpleDateFormat结果保持一致即可
String birthday = "700403"; final String birthday = "700403";
Date birthDate = DateUtil.parse(birthday, "yyMMdd"); final Date birthDate = DateUtil.parse(birthday, "yyMMdd");
// 获取出生年(完全表现形式,如：2010) // 获取出生年(完全表现形式,如：2010)
int sYear = DateUtil.year(birthDate); final int sYear = DateUtil.year(birthDate);
Assert.assertEquals(1970, sYear); Assert.assertEquals(1970, sYear);
} }
@Test @Test
public void parseTest3() { public void parseTest3() {
String dateStr = "2018-10-10 12:11:11"; final String dateStr = "2018-10-10 12:11:11";
Date date = DateUtil.parse(dateStr); final Date date = DateUtil.parse(dateStr);
String format = DateUtil.format(date, DatePattern.NORM_DATETIME_PATTERN); final String format = DateUtil.format(date, DatePattern.NORM_DATETIME_PATTERN);
Assert.assertEquals(dateStr, format); Assert.assertEquals(dateStr, format);
} }
@Test @Test
public void parseTest4() { public void parseTest4() {
String ymd = DateUtil.parse("2019-3-21 12:20:15", "yyyy-MM-dd").toString(DatePattern.PURE_DATE_PATTERN); final String ymd = DateUtil.parse("2019-3-21 12:20:15", "yyyy-MM-dd").toString(DatePattern.PURE_DATE_PATTERN);
Assert.assertEquals("20190321", ymd); Assert.assertEquals("20190321", ymd);
} }
@ -465,8 +442,8 @@ public class DateUtilTest {
@Test @Test
public void parseTest6() { public void parseTest6() {
String str = "Tue Jun 4 16:25:15 +0800 2019"; final String str = "Tue Jun 4 16:25:15 +0800 2019";
DateTime dateTime = DateUtil.parse(str); final DateTime dateTime = DateUtil.parse(str);
assert dateTime != null; assert dateTime != null;
Assert.assertEquals("2019-06-04 16:25:15", dateTime.toString()); Assert.assertEquals("2019-06-04 16:25:15", dateTime.toString());
} }
@ -486,8 +463,8 @@ public class DateUtilTest {
@Test @Test
public void parseTest8() { public void parseTest8() {
String str = "2020-06-28T02:14:13.000Z"; final String str = "2020-06-28T02:14:13.000Z";
DateTime dateTime = DateUtil.parse(str); final DateTime dateTime = DateUtil.parse(str);
assert dateTime != null; assert dateTime != null;
Assert.assertEquals("2020-06-28 02:14:13", dateTime.toString()); Assert.assertEquals("2020-06-28 02:14:13", dateTime.toString());
} }
@ -523,8 +500,8 @@ public class DateUtilTest {
*/ */
@Test @Test
public void parseEmptyTest() { public void parseEmptyTest() {
String str = " "; final String str = " ";
DateTime dateTime = DateUtil.parse(str); final DateTime dateTime = DateUtil.parse(str);
Assert.assertNull(dateTime); Assert.assertNull(dateTime);
} }
@ -545,34 +522,34 @@ public class DateUtilTest {
@Test @Test
public void parseAndOffsetTest() { public void parseAndOffsetTest() {
// 检查UTC时间偏移是否准确 // 检查UTC时间偏移是否准确
String str = "2019-09-17T13:26:17.948Z"; final String str = "2019-09-17T13:26:17.948Z";
DateTime dateTime = DateUtil.parse(str); final DateTime dateTime = DateUtil.parse(str);
assert dateTime != null; assert dateTime != null;
Assert.assertEquals("2019-09-17 13:26:17", dateTime.toString()); Assert.assertEquals("2019-09-17 13:26:17", dateTime.toString());
DateTime offset = DateUtil.offsetHour(dateTime, 8); final DateTime offset = DateUtil.offsetHour(dateTime, 8);
Assert.assertEquals("2019-09-17 21:26:17", offset.toString()); Assert.assertEquals("2019-09-17 21:26:17", offset.toString());
} }
@Test @Test
public void parseDateTest() { public void parseDateTest() {
String dateStr = "2018-4-10"; final String dateStr = "2018-4-10";
Date date = DateUtil.parseDate(dateStr); final Date date = DateUtil.parseDate(dateStr);
String format = DateUtil.format(date, DatePattern.NORM_DATE_PATTERN); final String format = DateUtil.format(date, DatePattern.NORM_DATE_PATTERN);
Assert.assertEquals("2018-04-10", format); Assert.assertEquals("2018-04-10", format);
} }
@Test @Test
public void parseToDateTimeTest1() { public void parseToDateTimeTest1() {
String dateStr1 = "2017-02-01"; final String dateStr1 = "2017-02-01";
String dateStr2 = "2017/02/01"; final String dateStr2 = "2017/02/01";
String dateStr3 = "2017.02.01"; final String dateStr3 = "2017.02.01";
String dateStr4 = "2017年02月01日"; final String dateStr4 = "2017年02月01日";
DateTime dt1 = DateUtil.parse(dateStr1); final DateTime dt1 = DateUtil.parse(dateStr1);
DateTime dt2 = DateUtil.parse(dateStr2); final DateTime dt2 = DateUtil.parse(dateStr2);
DateTime dt3 = DateUtil.parse(dateStr3); final DateTime dt3 = DateUtil.parse(dateStr3);
DateTime dt4 = DateUtil.parse(dateStr4); final DateTime dt4 = DateUtil.parse(dateStr4);
Assert.assertEquals(dt1, dt2); Assert.assertEquals(dt1, dt2);
Assert.assertEquals(dt2, dt3); Assert.assertEquals(dt2, dt3);
Assert.assertEquals(dt3, dt4); Assert.assertEquals(dt3, dt4);
@ -580,15 +557,15 @@ public class DateUtilTest {
@Test @Test
public void parseToDateTimeTest2() { public void parseToDateTimeTest2() {
String dateStr1 = "2017-02-01 12:23"; final String dateStr1 = "2017-02-01 12:23";
String dateStr2 = "2017/02/01 12:23"; final String dateStr2 = "2017/02/01 12:23";
String dateStr3 = "2017.02.01 12:23"; final String dateStr3 = "2017.02.01 12:23";
String dateStr4 = "2017年02月01日 12:23"; final String dateStr4 = "2017年02月01日 12:23";
DateTime dt1 = DateUtil.parse(dateStr1); final DateTime dt1 = DateUtil.parse(dateStr1);
DateTime dt2 = DateUtil.parse(dateStr2); final DateTime dt2 = DateUtil.parse(dateStr2);
DateTime dt3 = DateUtil.parse(dateStr3); final DateTime dt3 = DateUtil.parse(dateStr3);
DateTime dt4 = DateUtil.parse(dateStr4); final DateTime dt4 = DateUtil.parse(dateStr4);
Assert.assertEquals(dt1, dt2); Assert.assertEquals(dt1, dt2);
Assert.assertEquals(dt2, dt3); Assert.assertEquals(dt2, dt3);
Assert.assertEquals(dt3, dt4); Assert.assertEquals(dt3, dt4);
@ -596,15 +573,15 @@ public class DateUtilTest {
@Test @Test
public void parseToDateTimeTest3() { public void parseToDateTimeTest3() {
String dateStr1 = "2017-02-01 12:23:45"; final String dateStr1 = "2017-02-01 12:23:45";
String dateStr2 = "2017/02/01 12:23:45"; final String dateStr2 = "2017/02/01 12:23:45";
String dateStr3 = "2017.02.01 12:23:45"; final String dateStr3 = "2017.02.01 12:23:45";
String dateStr4 = "2017年02月01日 12时23分45秒"; final String dateStr4 = "2017年02月01日 12时23分45秒";
DateTime dt1 = DateUtil.parse(dateStr1); final DateTime dt1 = DateUtil.parse(dateStr1);
DateTime dt2 = DateUtil.parse(dateStr2); final DateTime dt2 = DateUtil.parse(dateStr2);
DateTime dt3 = DateUtil.parse(dateStr3); final DateTime dt3 = DateUtil.parse(dateStr3);
DateTime dt4 = DateUtil.parse(dateStr4); final DateTime dt4 = DateUtil.parse(dateStr4);
Assert.assertEquals(dt1, dt2); Assert.assertEquals(dt1, dt2);
Assert.assertEquals(dt2, dt3); Assert.assertEquals(dt2, dt3);
Assert.assertEquals(dt3, dt4); Assert.assertEquals(dt3, dt4);
@ -612,21 +589,21 @@ public class DateUtilTest {
@Test @Test
public void parseToDateTimeTest4() { public void parseToDateTimeTest4() {
String dateStr1 = "2017-02-01 12:23:45"; final String dateStr1 = "2017-02-01 12:23:45";
String dateStr2 = "20170201122345"; final String dateStr2 = "20170201122345";
DateTime dt1 = DateUtil.parse(dateStr1); final DateTime dt1 = DateUtil.parse(dateStr1);
DateTime dt2 = DateUtil.parse(dateStr2); final DateTime dt2 = DateUtil.parse(dateStr2);
Assert.assertEquals(dt1, dt2); Assert.assertEquals(dt1, dt2);
} }
@Test @Test
public void parseToDateTimeTest5() { public void parseToDateTimeTest5() {
String dateStr1 = "2017-02-01"; final String dateStr1 = "2017-02-01";
String dateStr2 = "20170201"; final String dateStr2 = "20170201";
DateTime dt1 = DateUtil.parse(dateStr1); final DateTime dt1 = DateUtil.parse(dateStr1);
DateTime dt2 = DateUtil.parse(dateStr2); final DateTime dt2 = DateUtil.parse(dateStr2);
Assert.assertEquals(dt1, dt2); Assert.assertEquals(dt1, dt2);
} }
@ -636,7 +613,7 @@ public class DateUtilTest {
DateTime dt = DateUtil.parseUTC(dateStr1); DateTime dt = DateUtil.parseUTC(dateStr1);
// parse方法支持UTC格式测试 // parse方法支持UTC格式测试
DateTime dt2 = DateUtil.parse(dateStr1); final DateTime dt2 = DateUtil.parse(dateStr1);
Assert.assertEquals(dt, dt2); Assert.assertEquals(dt, dt2);
// 默认使用Pattern对应的时区，即UTC时区 // 默认使用Pattern对应的时区，即UTC时区
@ -720,9 +697,9 @@ public class DateUtilTest {
@Test @Test
public void parseCSTTest() { public void parseCSTTest() {
String dateStr = "Wed Sep 16 11:26:23 CST 2009"; final String dateStr = "Wed Sep 16 11:26:23 CST 2009";
SimpleDateFormat sdf = new SimpleDateFormat(DatePattern.JDK_DATETIME_PATTERN, Locale.US); final SimpleDateFormat sdf = new SimpleDateFormat(DatePattern.JDK_DATETIME_PATTERN, Locale.US);
// Asia/Shanghai是以地区命名的地区标准时，在中国叫CST，因此如果解析CST时不使用"Asia/Shanghai"而使用"GMT+08:00"，会导致相差一个小时 // Asia/Shanghai是以地区命名的地区标准时，在中国叫CST，因此如果解析CST时不使用"Asia/Shanghai"而使用"GMT+08:00"，会导致相差一个小时
sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai")); sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
final DateTime parse = DateUtil.parse(dateStr, sdf); final DateTime parse = DateUtil.parse(dateStr, sdf);
@ -736,13 +713,13 @@ public class DateUtilTest {
@Test @Test
public void parseCSTTest2() { public void parseCSTTest2() {
String dateStr = "Wed Sep 16 11:26:23 CST 2009"; final String dateStr = "Wed Sep 16 11:26:23 CST 2009";
SimpleDateFormat sdf = new SimpleDateFormat(DatePattern.JDK_DATETIME_PATTERN, Locale.US); final SimpleDateFormat sdf = new SimpleDateFormat(DatePattern.JDK_DATETIME_PATTERN, Locale.US);
sdf.setTimeZone(TimeZone.getTimeZone("America/Chicago")); sdf.setTimeZone(TimeZone.getTimeZone("America/Chicago"));
final DateTime parse = DateUtil.parse(dateStr, sdf); final DateTime parse = DateUtil.parse(dateStr, sdf);
FastDateFormat fdf = FastDateFormat.getInstance(DatePattern.JDK_DATETIME_PATTERN, TimeZone.getTimeZone("America/Chicago"), Locale.US); final FastDateFormat fdf = FastDateFormat.getInstance(DatePattern.JDK_DATETIME_PATTERN, TimeZone.getTimeZone("America/Chicago"), Locale.US);
final DateTime parse2 = DateUtil.parse(dateStr, fdf); final DateTime parse2 = DateUtil.parse(dateStr, fdf);
Assert.assertEquals(parse, parse2); Assert.assertEquals(parse, parse2);
@ -750,29 +727,29 @@ public class DateUtilTest {
@Test @Test
public void parseJDkTest() { public void parseJDkTest() {
String dateStr = "Thu May 16 17:57:18 GMT+08:00 2019"; final String dateStr = "Thu May 16 17:57:18 GMT+08:00 2019";
DateTime time = DateUtil.parse(dateStr); final DateTime time = DateUtil.parse(dateStr);
Assert.assertEquals("2019-05-16 17:57:18", Objects.requireNonNull(time).toString()); Assert.assertEquals("2019-05-16 17:57:18", Objects.requireNonNull(time).toString());
} }
@Test @Test
public void parseISOTest() { public void parseISOTest() {
String dateStr = "2020-04-23T02:31:00.000Z"; final String dateStr = "2020-04-23T02:31:00.000Z";
DateTime time = DateUtil.parse(dateStr); final DateTime time = DateUtil.parse(dateStr);
Assert.assertEquals("2020-04-23 02:31:00", Objects.requireNonNull(time).toString()); Assert.assertEquals("2020-04-23 02:31:00", Objects.requireNonNull(time).toString());
} }
@Test @Test
public void endOfYearTest() { public void endOfYearTest() {
DateTime date = DateUtil.date(); final DateTime date = DateUtil.date();
date.setField(DateField.YEAR, 2019); date.setField(DateField.YEAR, 2019);
DateTime endOfYear = DateUtil.endOfYear(date); final DateTime endOfYear = DateUtil.endOfYear(date);
Assert.assertEquals("2019-12-31 23:59:59", endOfYear.toString()); Assert.assertEquals("2019-12-31 23:59:59", endOfYear.toString());
} }
@Test @Test
public void endOfQuarterTest() { public void endOfQuarterTest() {
Date date = DateUtil.endOfQuarter( final Date date = DateUtil.endOfQuarter(
DateUtil.parse("2020-05-31 00:00:00")); DateUtil.parse("2020-05-31 00:00:00"));
Assert.assertEquals("2020-06-30 23:59:59", DateUtil.format(date, "yyyy-MM-dd HH:mm:ss")); Assert.assertEquals("2020-06-30 23:59:59", DateUtil.format(date, "yyyy-MM-dd HH:mm:ss"));
@ -781,30 +758,30 @@ public class DateUtilTest {
@Test @Test
public void endOfWeekTest() { public void endOfWeekTest() {
// 周日 // 周日
DateTime now = DateUtil.parse("2019-09-15 13:00"); final DateTime now = DateUtil.parse("2019-09-15 13:00");
DateTime startOfWeek = DateUtil.beginOfWeek(now); final DateTime startOfWeek = DateUtil.beginOfWeek(now);
Assert.assertEquals("2019-09-09 00:00:00", startOfWeek.toString()); Assert.assertEquals("2019-09-09 00:00:00", startOfWeek.toString());
DateTime endOfWeek = DateUtil.endOfWeek(now); final DateTime endOfWeek = DateUtil.endOfWeek(now);
Assert.assertEquals("2019-09-15 23:59:59", endOfWeek.toString()); Assert.assertEquals("2019-09-15 23:59:59", endOfWeek.toString());
long between = DateUtil.between(endOfWeek, startOfWeek, DateUnit.DAY); final long between = DateUtil.between(endOfWeek, startOfWeek, DateUnit.DAY);
// 周一和周日相距6天 // 周一和周日相距6天
Assert.assertEquals(6, between); Assert.assertEquals(6, between);
} }
@Test @Test
public void dayOfWeekTest() { public void dayOfWeekTest() {
int dayOfWeek = DateUtil.dayOfWeek(DateUtil.parse("2018-03-07")); final int dayOfWeek = DateUtil.dayOfWeek(DateUtil.parse("2018-03-07"));
Assert.assertEquals(Calendar.WEDNESDAY, dayOfWeek); Assert.assertEquals(Calendar.WEDNESDAY, dayOfWeek);
Week week = DateUtil.dayOfWeekEnum(DateUtil.parse("2018-03-07")); final Week week = DateUtil.dayOfWeekEnum(DateUtil.parse("2018-03-07"));
Assert.assertEquals(Week.WEDNESDAY, week); Assert.assertEquals(Week.WEDNESDAY, week);
} }
@Test @Test
public void compareTest() { public void compareTest() {
Date date1 = DateUtil.parse("2021-04-13 23:59:59.999"); final Date date1 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date2 = DateUtil.parse("2021-04-13 23:59:10"); final Date date2 = DateUtil.parse("2021-04-13 23:59:10");
Assert.assertEquals(1, DateUtil.compare(date1, date2)); Assert.assertEquals(1, DateUtil.compare(date1, date2));
Assert.assertEquals(1, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_PATTERN)); Assert.assertEquals(1, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_PATTERN));
@ -812,45 +789,45 @@ public class DateUtilTest {
Assert.assertEquals(0, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_MINUTE_PATTERN)); Assert.assertEquals(0, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_MINUTE_PATTERN));
Date date11 = DateUtil.parse("2021-04-13 23:59:59.999"); final Date date11 = DateUtil.parse("2021-04-13 23:59:59.999");
Date date22 = DateUtil.parse("2021-04-11 23:10:10"); final Date date22 = DateUtil.parse("2021-04-11 23:10:10");
Assert.assertEquals(0, DateUtil.compare(date11, date22, DatePattern.NORM_MONTH_PATTERN)); Assert.assertEquals(0, DateUtil.compare(date11, date22, DatePattern.NORM_MONTH_PATTERN));
} }
@Test @Test
public void yearAndQTest() { public void yearAndQTest() {
String yearAndQuarter = DateUtil.yearAndQuarter(DateUtil.parse("2018-12-01")); final String yearAndQuarter = DateUtil.yearAndQuarter(DateUtil.parse("2018-12-01"));
Assert.assertEquals("20184", yearAndQuarter); Assert.assertEquals("20184", yearAndQuarter);
LinkedHashSet<String> yearAndQuarters = DateUtil.yearAndQuarter(DateUtil.parse("2018-09-10"), DateUtil.parse("2018-12-20")); final LinkedHashSet<String> yearAndQuarters = DateUtil.yearAndQuarter(DateUtil.parse("2018-09-10"), DateUtil.parse("2018-12-20"));
List<String> list = CollUtil.list(false, yearAndQuarters); final List<String> list = CollUtil.list(false, yearAndQuarters);
Assert.assertEquals(2, list.size()); Assert.assertEquals(2, list.size());
Assert.assertEquals("20183", list.get(0)); Assert.assertEquals("20183", list.get(0));
Assert.assertEquals("20184", list.get(1)); Assert.assertEquals("20184", list.get(1));
LinkedHashSet<String> yearAndQuarters2 = DateUtil.yearAndQuarter(DateUtil.parse("2018-10-10"), DateUtil.parse("2018-12-10")); final LinkedHashSet<String> yearAndQuarters2 = DateUtil.yearAndQuarter(DateUtil.parse("2018-10-10"), DateUtil.parse("2018-12-10"));
List<String> list2 = CollUtil.list(false, yearAndQuarters2); final List<String> list2 = CollUtil.list(false, yearAndQuarters2);
Assert.assertEquals(1, list2.size()); Assert.assertEquals(1, list2.size());
Assert.assertEquals("20184", list2.get(0)); Assert.assertEquals("20184", list2.get(0));
} }
@Test @Test
public void formatHttpDateTest() { public void formatHttpDateTest() {
String formatHttpDate = DateUtil.formatHttpDate(DateUtil.parse("2019-01-02 22:32:01")); final String formatHttpDate = DateUtil.formatHttpDate(DateUtil.parse("2019-01-02 22:32:01"));
Assert.assertEquals("Wed, 02 Jan 2019 14:32:01 GMT", formatHttpDate); Assert.assertEquals("Wed, 02 Jan 2019 14:32:01 GMT", formatHttpDate);
} }
@Test @Test
public void toInstantTest() { public void toInstantTest() {
LocalDateTime localDateTime = LocalDateTime.parse("2017-05-06T08:30:00", DateTimeFormatter.ISO_DATE_TIME); final LocalDateTime localDateTime = LocalDateTime.parse("2017-05-06T08:30:00", DateTimeFormatter.ISO_DATE_TIME);
Instant instant = DateUtil.toInstant(localDateTime); Instant instant = DateUtil.toInstant(localDateTime);
Assert.assertEquals("2017-05-06T00:30:00Z", instant.toString()); Assert.assertEquals("2017-05-06T00:30:00Z", instant.toString());
LocalDate localDate = localDateTime.toLocalDate(); final LocalDate localDate = localDateTime.toLocalDate();
instant = DateUtil.toInstant(localDate); instant = DateUtil.toInstant(localDate);
Assert.assertNotNull(instant); Assert.assertNotNull(instant);
LocalTime localTime = localDateTime.toLocalTime(); final LocalTime localTime = localDateTime.toLocalTime();
instant = DateUtil.toInstant(localTime); instant = DateUtil.toInstant(localTime);
Assert.assertNotNull(instant); Assert.assertNotNull(instant);
} }
@ -858,13 +835,13 @@ public class DateUtilTest {
@Test @Test
public void dateTest() { public void dateTest() {
//LocalDateTime ==> date //LocalDateTime ==> date
LocalDateTime localDateTime = LocalDateTime.parse("2017-05-06T08:30:00", DateTimeFormatter.ISO_DATE_TIME); final LocalDateTime localDateTime = LocalDateTime.parse("2017-05-06T08:30:00", DateTimeFormatter.ISO_DATE_TIME);
DateTime date = DateUtil.date(localDateTime); final DateTime date = DateUtil.date(localDateTime);
Assert.assertEquals("2017-05-06 08:30:00", date.toString()); Assert.assertEquals("2017-05-06 08:30:00", date.toString());
//LocalDate ==> date //LocalDate ==> date
LocalDate localDate = localDateTime.toLocalDate(); final LocalDate localDate = localDateTime.toLocalDate();
DateTime date2 = DateUtil.date(localDate); final DateTime date2 = DateUtil.date(localDate);
Assert.assertEquals("2017-05-06", Assert.assertEquals("2017-05-06",
DateUtil.format(date2, DatePattern.NORM_DATE_PATTERN)); DateUtil.format(date2, DatePattern.NORM_DATE_PATTERN));
} }
@ -872,45 +849,45 @@ public class DateUtilTest {
@Test @Test
public void dateTest2() { public void dateTest2() {
// 测试负数日期 // 测试负数日期
long dateLong = -1497600000; final long dateLong = -1497600000;
final DateTime date = DateUtil.date(dateLong); final DateTime date = DateUtil.date(dateLong);
Assert.assertEquals("1969-12-15 00:00:00", date.toString()); Assert.assertEquals("1969-12-15 00:00:00", date.toString());
} }
@Test @Test
public void ageTest() { public void ageTest() {
String d1 = "2000-02-29"; final String d1 = "2000-02-29";
String d2 = "2018-02-28"; final String d2 = "2018-02-28";
final int age = DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2)); final int age = DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2));
Assert.assertEquals(18, age); Assert.assertEquals(18, age);
} }
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)
public void ageTest2() { public void ageTest2() {
String d1 = "2019-02-29"; final String d1 = "2019-02-29";
String d2 = "2018-02-28"; final String d2 = "2018-02-28";
DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2)); DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2));
} }
@Test @Test
public void isExpiredTest() { public void isExpiredTest() {
DateTime startDate = DateUtil.parse("2019-12-01 17:02:30"); final DateTime startDate = DateUtil.parse("2019-12-01 17:02:30");
DateTime endDate = DateUtil.parse("2019-12-02 17:02:30"); final DateTime endDate = DateUtil.parse("2019-12-02 17:02:30");
int length = 3; final int length = 3;
//noinspection deprecation //noinspection deprecation
boolean expired = DateUtil.isExpired(startDate, DateField.DAY_OF_YEAR, length, endDate); final boolean expired = DateUtil.isExpired(startDate, DateField.DAY_OF_YEAR, length, endDate);
Assert.assertTrue(expired); Assert.assertTrue(expired);
} }
@Test @Test
public void localDateTimeTest() { public void localDateTimeTest() {
// 测试字符串与LocalDateTime的互相转换 // 测试字符串与LocalDateTime的互相转换
String strDate = "2019-12-01 17:02:30"; final String strDate = "2019-12-01 17:02:30";
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate); LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
String strDate1 = DateUtil.formatLocalDateTime(ldt); String strDate1 = DateUtil.formatLocalDateTime(ldt);
Assert.assertEquals(strDate, strDate1); Assert.assertEquals(strDate, strDate1);
String strDate2 = "2019-12-01 17:02:30.111"; final String strDate2 = "2019-12-01 17:02:30.111";
ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN); ldt = DateUtil.parseLocalDateTime(strDate2, DatePattern.NORM_DATETIME_MS_PATTERN);
strDate1 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN); strDate1 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
Assert.assertEquals(strDate, strDate1); Assert.assertEquals(strDate, strDate1);
@ -919,7 +896,7 @@ public class DateUtilTest {
@Test @Test
public void localDateTimeTest2() { public void localDateTimeTest2() {
// 测试字符串与LocalDateTime的互相转换 // 测试字符串与LocalDateTime的互相转换
String strDate = "2019-12-01"; final String strDate = "2019-12-01";
final LocalDateTime localDateTime = DateUtil.parseLocalDateTime(strDate, "yyyy-MM-dd"); final LocalDateTime localDateTime = DateUtil.parseLocalDateTime(strDate, "yyyy-MM-dd");
Assert.assertEquals(strDate, DateUtil.format(localDateTime, DatePattern.NORM_DATE_PATTERN)); Assert.assertEquals(strDate, DateUtil.format(localDateTime, DatePattern.NORM_DATE_PATTERN));
} }
@ -936,8 +913,8 @@ public class DateUtilTest {
@Test @Test
public void betweenDayTest() { public void betweenDayTest() {
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
String datr = RandomUtil.randomInt(1900, 2099) + "-01-20"; final String datr = RandomUtil.randomInt(1900, 2099) + "-01-20";
long betweenDay = DateUtil.betweenDay( final long betweenDay = DateUtil.betweenDay(
DateUtil.parseDate("1970-01-01"), DateUtil.parseDate("1970-01-01"),
DateUtil.parseDate(datr), false); DateUtil.parseDate(datr), false);
Assert.assertEquals(Math.abs(LocalDate.parse(datr).toEpochDay()), betweenDay); Assert.assertEquals(Math.abs(LocalDate.parse(datr).toEpochDay()), betweenDay);
@ -946,9 +923,9 @@ public class DateUtilTest {
@Test @Test
public void dayOfYearTest() { public void dayOfYearTest() {
int dayOfYear = DateUtil.dayOfYear(DateUtil.parse("2020-01-01")); final int dayOfYear = DateUtil.dayOfYear(DateUtil.parse("2020-01-01"));
Assert.assertEquals(1, dayOfYear); Assert.assertEquals(1, dayOfYear);
int lengthOfYear = DateUtil.lengthOfYear(2020); final int lengthOfYear = DateUtil.lengthOfYear(2020);
Assert.assertEquals(366, lengthOfYear); Assert.assertEquals(366, lengthOfYear);
} }
@ -977,7 +954,7 @@ public class DateUtilTest {
@SuppressWarnings("ConstantConditions") @SuppressWarnings("ConstantConditions")
@Test @Test
public void parseISO8601Test() { public void parseISO8601Test() {
String dt = "2020-06-03 12:32:12,333"; final String dt = "2020-06-03 12:32:12,333";
final DateTime parse = DateUtil.parse(dt); final DateTime parse = DateUtil.parse(dt);
Assert.assertEquals("2020-06-03 12:32:12", parse.toString()); Assert.assertEquals("2020-06-03 12:32:12", parse.toString());
} }
@ -991,9 +968,9 @@ public class DateUtilTest {
@Test @Test
public void formatTest() { public void formatTest() {
Calendar calendar = new GregorianCalendar(); final Calendar calendar = new GregorianCalendar();
calendar.set(2021, Calendar.JULY, 14, 23, 59, 59); calendar.set(2021, Calendar.JULY, 14, 23, 59, 59);
Date date = new DateTime(calendar); final Date date = new DateTime(calendar);
Assert.assertEquals("2021-07-14 23:59:59", DateUtil.format(date, DatePattern.NORM_DATETIME_FORMATTER)); Assert.assertEquals("2021-07-14 23:59:59", DateUtil.format(date, DatePattern.NORM_DATETIME_FORMATTER));
Assert.assertEquals("2021-07-14 23:59:59", DateUtil.format(date, DatePattern.NORM_DATETIME_FORMAT)); Assert.assertEquals("2021-07-14 23:59:59", DateUtil.format(date, DatePattern.NORM_DATETIME_FORMAT));
@ -1060,24 +1037,24 @@ public class DateUtilTest {
@Test @Test
@SuppressWarnings("ConstantConditions") @SuppressWarnings("ConstantConditions")
public void isOverlapTest() { public void isOverlapTest() {
DateTime oneStartTime = DateUtil.parse("2022-01-01 10:10:10"); final DateTime oneStartTime = DateUtil.parse("2022-01-01 10:10:10");
DateTime oneEndTime = DateUtil.parse("2022-01-01 11:10:10"); final DateTime oneEndTime = DateUtil.parse("2022-01-01 11:10:10");
DateTime oneStartTime2 = DateUtil.parse("2022-01-01 11:20:10"); final DateTime oneStartTime2 = DateUtil.parse("2022-01-01 11:20:10");
DateTime oneEndTime2 = DateUtil.parse("2022-01-01 11:30:10"); final DateTime oneEndTime2 = DateUtil.parse("2022-01-01 11:30:10");
DateTime oneStartTime3 = DateUtil.parse("2022-01-01 11:40:10"); final DateTime oneStartTime3 = DateUtil.parse("2022-01-01 11:40:10");
DateTime oneEndTime3 = DateUtil.parse("2022-01-01 11:50:10"); final DateTime oneEndTime3 = DateUtil.parse("2022-01-01 11:50:10");
//真实请假数据 //真实请假数据
DateTime realStartTime = DateUtil.parse("2022-01-01 11:49:10"); final DateTime realStartTime = DateUtil.parse("2022-01-01 11:49:10");
DateTime realEndTime = DateUtil.parse("2022-01-01 12:00:10"); final DateTime realEndTime = DateUtil.parse("2022-01-01 12:00:10");
DateTime realStartTime1 = DateUtil.parse("2022-03-01 08:00:00"); final DateTime realStartTime1 = DateUtil.parse("2022-03-01 08:00:00");
DateTime realEndTime1 = DateUtil.parse("2022-03-01 10:00:00"); final DateTime realEndTime1 = DateUtil.parse("2022-03-01 10:00:00");
DateTime startTime = DateUtil.parse("2022-03-23 05:00:00"); final DateTime startTime = DateUtil.parse("2022-03-23 05:00:00");
DateTime endTime = DateUtil.parse("2022-03-23 13:00:00"); final DateTime endTime = DateUtil.parse("2022-03-23 13:00:00");
Assert.assertFalse(DateUtil.isOverlap(oneStartTime, oneEndTime, realStartTime, realEndTime)); Assert.assertFalse(DateUtil.isOverlap(oneStartTime, oneEndTime, realStartTime, realEndTime));
Assert.assertFalse(DateUtil.isOverlap(oneStartTime2, oneEndTime2, realStartTime, realEndTime)); Assert.assertFalse(DateUtil.isOverlap(oneStartTime2, oneEndTime2, realStartTime, realEndTime));
@ -1089,21 +1066,21 @@ public class DateUtilTest {
@Test @Test
public void isOverlapTest2() { public void isOverlapTest2() {
DateTime oneStartTime = DateUtil.parseDate("2021-02-01"); final DateTime oneStartTime = DateUtil.parseDate("2021-02-01");
DateTime oneEndTime = DateUtil.parseDate("2022-06-30"); final DateTime oneEndTime = DateUtil.parseDate("2022-06-30");
DateTime oneStartTime2 = DateUtil.parseDate("2019-04-05"); final DateTime oneStartTime2 = DateUtil.parseDate("2019-04-05");
DateTime oneEndTime2 = DateUtil.parseDate("2021-04-05"); final DateTime oneEndTime2 = DateUtil.parseDate("2021-04-05");
Assert.assertTrue(DateUtil.isOverlap(oneStartTime, oneEndTime, oneStartTime2, oneEndTime2)); Assert.assertTrue(DateUtil.isOverlap(oneStartTime, oneEndTime, oneStartTime2, oneEndTime2));
} }
@Test @Test
public void isInTest(){ public void isInTest(){
String sourceStr = "2022-04-19 00:00:00"; final String sourceStr = "2022-04-19 00:00:00";
String startTimeStr = "2022-04-19 00:00:00"; final String startTimeStr = "2022-04-19 00:00:00";
String endTimeStr = "2022-04-19 23:59:59"; final String endTimeStr = "2022-04-19 23:59:59";
boolean between = DateUtil.isIn(DateUtil.parse(startTimeStr), final boolean between = DateUtil.isIn(DateUtil.parse(startTimeStr),
DateUtil.parse(endTimeStr), DateUtil.parse(endTimeStr),
DateUtil.parse(sourceStr)); DateUtil.parse(sourceStr));
Assert.assertTrue(between); Assert.assertTrue(between);

10
hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java
View File

@ -133,7 +133,7 @@ public final class InternalJSONUtil {
/** /**
* 将Property的键转化为JSON形式<br> * 将Property的键转化为JSON形式<br>
* 用于识别类似于：com.luxiaolei.package.hutool这类用点隔开的键<br> * 用于识别类似于：com.luxiaolei.package.hutool这类用点隔开的键<br>
* 注意：不允许重复键 * 注意：是否允许重复键，取决于JSONObject配置
* *
* @param jsonObject JSONObject * @param jsonObject JSONObject
* @param key 键 * @param key 键
@ -142,18 +142,18 @@ public final class InternalJSONUtil {
*/ */
static JSONObject propertyPut(JSONObject jsonObject, Object key, Object value, Filter<MutablePair<String, Object>> filter) { static JSONObject propertyPut(JSONObject jsonObject, Object key, Object value, Filter<MutablePair<String, Object>> filter) {
final String[] path = StrUtil.splitToArray(Convert.toStr(key), CharUtil.DOT); final String[] path = StrUtil.splitToArray(Convert.toStr(key), CharUtil.DOT);
int last = path.length - 1; final int last = path.length - 1;
JSONObject target = jsonObject; JSONObject target = jsonObject;
for (int i = 0; i < last; i += 1) { for (int i = 0; i < last; i += 1) {
String segment = path[i]; final String segment = path[i];
JSONObject nextTarget = target.getJSONObject(segment); JSONObject nextTarget = target.getJSONObject(segment);
if (nextTarget == null) { if (nextTarget == null) {
nextTarget = new JSONObject(target.getConfig()); nextTarget = new JSONObject(target.getConfig());
target.setOnce(segment, nextTarget, filter); target.set(segment, nextTarget, filter, target.getConfig().isCheckDuplicate());
} }
target = nextTarget; target = nextTarget;
} }
target.setOnce(path[last], value, filter); target.set(path[last], value, filter, target.getConfig().isCheckDuplicate());
return jsonObject; return jsonObject;
} }

26
hutool-json/src/main/java/cn/hutool/json/JSONConfig.java
View File

@ -45,9 +45,9 @@ public class JSONConfig implements Serializable {
private boolean stripTrailingZeros = true; private boolean stripTrailingZeros = true;
/** /**
* 是否忽略多个相同的key * 是否检查重复key
*/ */
private boolean ignoreDuplicateKey = false; private boolean checkDuplicate;
/** /**
* 创建默认的配置项 * 创建默认的配置项
@ -242,20 +242,24 @@ public class JSONConfig implements Serializable {
} }
/** /**
* 是否忽略多个相同的key * 是否检查多个相同的key
* @return *
* @return 是否检查多个相同的key
* @since 5.8.5
*/ */
public boolean isIgnoreDuplicateKey() { public boolean isCheckDuplicate() {
return ignoreDuplicateKey; return checkDuplicate;
} }
/** /**
* 是否忽略多个相同的key * 是否检查多个相同的key
* @param ignoreDuplicateKey *
* @return * @param checkDuplicate 是否检查多个相同的key
* @return this
* @since 5.8.5
*/ */
public JSONConfig setIgnoreDuplicateKey(boolean ignoreDuplicateKey) { public JSONConfig setCheckDuplicate(boolean checkDuplicate) {
this.ignoreDuplicateKey = ignoreDuplicateKey; this.checkDuplicate = checkDuplicate;
return this; return this;
} }
} }

6
hutool-json/src/main/java/cn/hutool/json/JSONObject.java
View File

@ -236,7 +236,7 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
Object value; Object value;
for (String name : names) { for (String name : names) {
value = ((Map<?, ?>) source).get(name); value = ((Map<?, ?>) source).get(name);
this.putOnce(name, value); this.set(name, value, null, getConfig().isCheckDuplicate());
} }
} else { } else {
for (String name : names) { for (String name : names) {
@ -392,9 +392,7 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
// 忽略值模式下如果值为空清除key // 忽略值模式下如果值为空清除key
this.remove(key); this.remove(key);
} else { } else {
/*如果允许多个key，就不抛出异常，使用后面的值覆盖前面的值*/ if (checkDuplicate && containsKey(key)) {
boolean ignoreDuplicateKey = this.config.isIgnoreDuplicateKey();
if (checkDuplicate && containsKey(key) && false == ignoreDuplicateKey) {
throw new JSONException("Duplicate key \"{}\"", key); throw new JSONException("Duplicate key \"{}\"", key);
} }

2
hutool-json/src/main/java/cn/hutool/json/JSONParser.java
View File

@ -69,7 +69,7 @@ public class JSONParser {
throw tokener.syntaxError("Expected a ':' after a key"); throw tokener.syntaxError("Expected a ':' after a key");
} }
jsonObject.setOnce(key, tokener.nextValue(), filter); jsonObject.set(key, tokener.nextValue(), filter, jsonObject.getConfig().isCheckDuplicate());
// Pairs are separated by ','. // Pairs are separated by ','.

4
hutool-json/src/main/java/cn/hutool/json/ObjectMapper.java
View File

@ -88,11 +88,11 @@ public class ObjectMapper {
if (source instanceof Map) { if (source instanceof Map) {
// Map // Map
for (final Map.Entry<?, ?> e : ((Map<?, ?>) source).entrySet()) { for (final Map.Entry<?, ?> e : ((Map<?, ?>) source).entrySet()) {
jsonObject.set(Convert.toStr(e.getKey()), e.getValue(), filter, false); jsonObject.set(Convert.toStr(e.getKey()), e.getValue(), filter, jsonObject.getConfig().isCheckDuplicate());
} }
} else if (source instanceof Map.Entry) { } else if (source instanceof Map.Entry) {
final Map.Entry entry = (Map.Entry) source; final Map.Entry entry = (Map.Entry) source;
jsonObject.set(Convert.toStr(entry.getKey()), entry.getValue(), filter, false); jsonObject.set(Convert.toStr(entry.getKey()), entry.getValue(), filter, jsonObject.getConfig().isCheckDuplicate());
} else if (source instanceof CharSequence) { } else if (source instanceof CharSequence) {
// 可能为JSON字符串 // 可能为JSON字符串
mapFromStr((CharSequence) source, jsonObject, filter); mapFromStr((CharSequence) source, jsonObject, filter);

76
hutool-json/src/test/java/cn/hutool/json/JSONUtilTest.java
View File

@ -26,7 +26,7 @@ public class JSONUtilTest {
*/ */
@Test(expected = JSONException.class) @Test(expected = JSONException.class)
public void parseTest() { public void parseTest() {
JSONArray jsonArray = JSONUtil.parseArray("[{\"a\":\"a\\x]"); final JSONArray jsonArray = JSONUtil.parseArray("[{\"a\":\"a\\x]");
Console.log(jsonArray); Console.log(jsonArray);
} }
@ -35,7 +35,7 @@ public class JSONUtilTest {
*/ */
@Test(expected = JSONException.class) @Test(expected = JSONException.class)
public void parseNumberTest() { public void parseNumberTest() {
JSONArray json = JSONUtil.parseArray(123L); final JSONArray json = JSONUtil.parseArray(123L);
Assert.assertNotNull(json); Assert.assertNotNull(json);
} }
@ -44,42 +44,42 @@ public class JSONUtilTest {
*/ */
@Test @Test
public void parseNumberTest2() { public void parseNumberTest2() {
JSONObject json = JSONUtil.parseObj(123L); final JSONObject json = JSONUtil.parseObj(123L);
Assert.assertEquals(new JSONObject(), json); Assert.assertEquals(new JSONObject(), json);
} }
@Test @Test
public void toJsonStrTest() { public void toJsonStrTest() {
UserA a1 = new UserA(); final UserA a1 = new UserA();
a1.setA("aaaa"); a1.setA("aaaa");
a1.setDate(DateUtil.date()); a1.setDate(DateUtil.date());
a1.setName("AAAAName"); a1.setName("AAAAName");
UserA a2 = new UserA(); final UserA a2 = new UserA();
a2.setA("aaaa222"); a2.setA("aaaa222");
a2.setDate(DateUtil.date()); a2.setDate(DateUtil.date());
a2.setName("AAAA222Name"); a2.setName("AAAA222Name");
ArrayList<UserA> list = CollectionUtil.newArrayList(a1, a2); final ArrayList<UserA> list = CollectionUtil.newArrayList(a1, a2);
HashMap<String, Object> map = MapUtil.newHashMap(); final HashMap<String, Object> map = MapUtil.newHashMap();
map.put("total", 13); map.put("total", 13);
map.put("rows", list); map.put("rows", list);
String str = JSONUtil.toJsonPrettyStr(map); final String str = JSONUtil.toJsonPrettyStr(map);
JSONUtil.parse(str); JSONUtil.parse(str);
Assert.assertNotNull(str); Assert.assertNotNull(str);
} }
@Test @Test
public void toJsonStrTest2() { public void toJsonStrTest2() {
Map<String, Object> model = new HashMap<>(); final Map<String, Object> model = new HashMap<>();
model.put("mobile", "17610836523"); model.put("mobile", "17610836523");
model.put("type", 1); model.put("type", 1);
Map<String, Object> data = new HashMap<>(); final Map<String, Object> data = new HashMap<>();
data.put("model", model); data.put("model", model);
data.put("model2", model); data.put("model2", model);
JSONObject jsonObject = JSONUtil.parseObj(data); final JSONObject jsonObject = JSONUtil.parseObj(data);
Assert.assertTrue(jsonObject.containsKey("model")); Assert.assertTrue(jsonObject.containsKey("model"));
Assert.assertEquals(1, jsonObject.getJSONObject("model").getInt("type").intValue()); Assert.assertEquals(1, jsonObject.getJSONObject("model").getInt("type").intValue());
@ -90,25 +90,25 @@ public class JSONUtilTest {
@Test @Test
public void toJsonStrTest3() { public void toJsonStrTest3() {
// 验证某个字段为JSON字符串时转义是否规范 // 验证某个字段为JSON字符串时转义是否规范
JSONObject object = new JSONObject(true); final JSONObject object = new JSONObject(true);
object.set("name", "123123"); object.set("name", "123123");
object.set("value", "\\"); object.set("value", "\\");
object.set("value2", "</"); object.set("value2", "</");
HashMap<String, String> map = MapUtil.newHashMap(); final HashMap<String, String> map = MapUtil.newHashMap();
map.put("user", object.toString()); map.put("user", object.toString());
JSONObject json = JSONUtil.parseObj(map); final JSONObject json = JSONUtil.parseObj(map);
Assert.assertEquals("{\"name\":\"123123\",\"value\":\"\\\\\",\"value2\":\"</\"}", json.get("user")); Assert.assertEquals("{\"name\":\"123123\",\"value\":\"\\\\\",\"value2\":\"</\"}", json.get("user"));
Assert.assertEquals("{\"user\":\"{\\\"name\\\":\\\"123123\\\",\\\"value\\\":\\\"\\\\\\\\\\\",\\\"value2\\\":\\\"</\\\"}\"}", json.toString()); Assert.assertEquals("{\"user\":\"{\\\"name\\\":\\\"123123\\\",\\\"value\\\":\\\"\\\\\\\\\\\",\\\"value2\\\":\\\"</\\\"}\"}", json.toString());
JSONObject json2 = JSONUtil.parseObj(json.toString()); final JSONObject json2 = JSONUtil.parseObj(json.toString());
Assert.assertEquals("{\"name\":\"123123\",\"value\":\"\\\\\",\"value2\":\"</\"}", json2.get("user")); Assert.assertEquals("{\"name\":\"123123\",\"value\":\"\\\\\",\"value2\":\"</\"}", json2.get("user"));
} }
@Test @Test
public void toJsonStrFromSortedTest() { public void toJsonStrFromSortedTest() {
SortedMap<Object, Object> sortedMap = new TreeMap<Object, Object>() { final SortedMap<Object, Object> sortedMap = new TreeMap<Object, Object>() {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
{ {
@ -125,20 +125,20 @@ public class JSONUtilTest {
*/ */
@Test @Test
public void toBeanTest() { public void toBeanTest() {
String json = "{\"ADT\":[[{\"BookingCode\":[\"N\",\"N\"]}]]}"; final String json = "{\"ADT\":[[{\"BookingCode\":[\"N\",\"N\"]}]]}";
Price price = JSONUtil.toBean(json, Price.class); final Price price = JSONUtil.toBean(json, Price.class);
Assert.assertEquals("N", price.getADT().get(0).get(0).getBookingCode().get(0)); Assert.assertEquals("N", price.getADT().get(0).get(0).getBookingCode().get(0));
} }
@Test @Test
public void toBeanTest2() { public void toBeanTest2() {
// 测试JSONObject转为Bean中字符串字段的情况 // 测试JSONObject转为Bean中字符串字段的情况
String json = "{\"id\":123,\"name\":\"张三\",\"prop\":{\"gender\":\"男\", \"age\":18}}"; final String json = "{\"id\":123,\"name\":\"张三\",\"prop\":{\"gender\":\"男\", \"age\":18}}";
UserC user = JSONUtil.toBean(json, UserC.class); final UserC user = JSONUtil.toBean(json, UserC.class);
Assert.assertNotNull(user.getProp()); Assert.assertNotNull(user.getProp());
String prop = user.getProp(); final String prop = user.getProp();
JSONObject propJson = JSONUtil.parseObj(prop); final JSONObject propJson = JSONUtil.parseObj(prop);
Assert.assertEquals("男", propJson.getStr("gender")); Assert.assertEquals("男", propJson.getStr("gender"));
Assert.assertEquals(18, propJson.getInt("age").intValue()); Assert.assertEquals(18, propJson.getInt("age").intValue());
// Assert.assertEquals("{\"age\":18,\"gender\":\"男\"}", user.getProp()); // Assert.assertEquals("{\"age\":18,\"gender\":\"男\"}", user.getProp());
@ -146,22 +146,22 @@ public class JSONUtilTest {
@Test @Test
public void getStrTest() { public void getStrTest() {
String html = "{\"name\":\"Something must have been changed since you leave\"}"; final String html = "{\"name\":\"Something must have been changed since you leave\"}";
JSONObject jsonObject = JSONUtil.parseObj(html); final JSONObject jsonObject = JSONUtil.parseObj(html);
Assert.assertEquals("Something must have been changed since you leave", jsonObject.getStr("name")); Assert.assertEquals("Something must have been changed since you leave", jsonObject.getStr("name"));
} }
@Test @Test
public void getStrTest2() { public void getStrTest2() {
String html = "{\"name\":\"Something\\u00a0must have been changed since you leave\"}"; final String html = "{\"name\":\"Something\\u00a0must have been changed since you leave\"}";
JSONObject jsonObject = JSONUtil.parseObj(html); final JSONObject jsonObject = JSONUtil.parseObj(html);
Assert.assertEquals("Something\\u00a0must\\u00a0have\\u00a0been\\u00a0changed\\u00a0since\\u00a0you\\u00a0leave", jsonObject.getStrEscaped("name")); Assert.assertEquals("Something\\u00a0must\\u00a0have\\u00a0been\\u00a0changed\\u00a0since\\u00a0you\\u00a0leave", jsonObject.getStrEscaped("name"));
} }
@Test @Test
public void parseFromXmlTest() { public void parseFromXmlTest() {
String s = "<sfzh>640102197312070614</sfzh><sfz>640102197312070614X</sfz><name>aa</name><gender>1</gender>"; final String s = "<sfzh>640102197312070614</sfzh><sfz>640102197312070614X</sfz><name>aa</name><gender>1</gender>";
JSONObject json = JSONUtil.parseFromXml(s); final JSONObject json = JSONUtil.parseFromXml(s);
Assert.assertEquals(640102197312070614L, json.get("sfzh")); Assert.assertEquals(640102197312070614L, json.get("sfzh"));
Assert.assertEquals("640102197312070614X", json.get("sfz")); Assert.assertEquals("640102197312070614X", json.get("sfz"));
Assert.assertEquals("aa", json.get("name")); Assert.assertEquals("aa", json.get("name"));
@ -170,7 +170,7 @@ public class JSONUtilTest {
@Test @Test
public void doubleTest() { public void doubleTest() {
String json = "{\"test\": 12.00}"; final String json = "{\"test\": 12.00}";
final JSONObject jsonObject = JSONUtil.parseObj(json); final JSONObject jsonObject = JSONUtil.parseObj(json);
//noinspection BigDecimalMethodWithoutRoundingCalled //noinspection BigDecimalMethodWithoutRoundingCalled
Assert.assertEquals("12.00", jsonObject.getBigDecimal("test").setScale(2).toString()); Assert.assertEquals("12.00", jsonObject.getBigDecimal("test").setScale(2).toString());
@ -222,7 +222,7 @@ public class JSONUtilTest {
@Test @Test
public void parseBigNumberTest(){ public void parseBigNumberTest(){
// 科学计数法使用BigDecimal处理，默认输出非科学计数形式 // 科学计数法使用BigDecimal处理，默认输出非科学计数形式
String str = "{\"test\":100000054128897953e4}"; final String str = "{\"test\":100000054128897953e4}";
Assert.assertEquals("{\"test\":1000000541288979530000}", JSONUtil.parseObj(str).toString()); Assert.assertEquals("{\"test\":1000000541288979530000}", JSONUtil.parseObj(str).toString());
} }
@ -236,12 +236,18 @@ public class JSONUtilTest {
} }
@Test @Test
public void testDuplicateKey(){ public void duplicateKeyFalseTest(){
String str = "{id:123, name:\"张三\", name:\"李四\"}"; final String str = "{id:123, name:\"张三\", name:\"李四\"}";
JSONObject jsonObject = JSONUtil.parseObj(str, JSONConfig.create().setIgnoreDuplicateKey(true)); final JSONObject jsonObject = JSONUtil.parseObj(str, JSONConfig.create().setCheckDuplicate(false));
System.out.println(jsonObject.toString()); Assert.assertEquals("{\"id\":123,\"name\":\"李四\"}", jsonObject.toString());
}
Assert.assertNotNull(jsonObject); @Test(expected = JSONException.class)
public void duplicateKeyTrueTest(){
final String str = "{id:123, name:\"张三\", name:\"李四\"}";
final JSONObject jsonObject = JSONUtil.parseObj(str, JSONConfig.create().setCheckDuplicate(true));
Assert.assertEquals("{\"id\":123,\"name\":\"李四\"}", jsonObject.toString());
} }
} }