mirror of
https://gitee.com/chinabugotech/hutool.git
synced 2025-05-09 23:51:34 +08:00
fix code
This commit is contained in:
Looly
parent
f879f3084a
commit
b74b7c682c
@ -635,57 +635,6 @@ public class DateUtil extends CalendarUtil {
|
||||
|
||||
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 ----------------------------------------------
|
||||
|
||||
// ------------------------------------ Parse start ----------------------------------------------
|
||||
|
||||
@ -39,46 +39,46 @@ public class DateUtilTest {
|
||||
@Test
|
||||
public void nowTest() {
|
||||
// 当前时间
|
||||
Date date = DateUtil.date();
|
||||
final Date date = DateUtil.date();
|
||||
Assert.assertNotNull(date);
|
||||
// 当前时间
|
||||
Date date2 = DateUtil.date(Calendar.getInstance());
|
||||
final Date date2 = DateUtil.date(Calendar.getInstance());
|
||||
Assert.assertNotNull(date2);
|
||||
// 当前时间
|
||||
Date date3 = DateUtil.date(System.currentTimeMillis());
|
||||
final Date date3 = DateUtil.date(System.currentTimeMillis());
|
||||
Assert.assertNotNull(date3);
|
||||
|
||||
// 当前日期字符串，格式：yyyy-MM-dd HH:mm:ss
|
||||
String now = DateUtil.now();
|
||||
final String now = DateUtil.now();
|
||||
Assert.assertNotNull(now);
|
||||
// 当前日期字符串，格式：yyyy-MM-dd
|
||||
String today = DateUtil.today();
|
||||
final String today = DateUtil.today();
|
||||
Assert.assertNotNull(today);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void formatAndParseTest() {
|
||||
String dateStr = "2017-03-01";
|
||||
Date date = DateUtil.parse(dateStr);
|
||||
final String dateStr = "2017-03-01";
|
||||
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);
|
||||
|
||||
// 常用格式的格式化
|
||||
String formatDate = DateUtil.formatDate(date);
|
||||
final String formatDate = DateUtil.formatDate(date);
|
||||
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);
|
||||
String formatTime = DateUtil.formatTime(date);
|
||||
final String formatTime = DateUtil.formatTime(date);
|
||||
Assert.assertEquals("00:00:00", formatTime);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void formatAndParseCustomTest() {
|
||||
String dateStr = "2017-03-01";
|
||||
Date date = DateUtil.parse(dateStr);
|
||||
final String dateStr = "2017-03-01";
|
||||
final Date date = DateUtil.parse(dateStr);
|
||||
|
||||
String format = DateUtil.format(date, "#sss");
|
||||
final String format = DateUtil.format(date, "#sss");
|
||||
Assert.assertEquals("1488297600", format);
|
||||
|
||||
final DateTime parse = DateUtil.parse(format, "#sss");
|
||||
@ -87,49 +87,26 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void formatAndParseCustomTest2() {
|
||||
String dateStr = "2017-03-01";
|
||||
Date date = DateUtil.parse(dateStr);
|
||||
final String dateStr = "2017-03-01";
|
||||
final Date date = DateUtil.parse(dateStr);
|
||||
|
||||
String format = DateUtil.format(date, "#SSS");
|
||||
final String format = DateUtil.format(date, "#SSS");
|
||||
Assert.assertEquals("1488297600000", format);
|
||||
|
||||
final DateTime parse = DateUtil.parse(format, "#SSS");
|
||||
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
|
||||
public void beginAndEndTest() {
|
||||
String dateStr = "2017-03-01 00:33:23";
|
||||
Date date = DateUtil.parse(dateStr);
|
||||
final String dateStr = "2017-03-01 00:33:23";
|
||||
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());
|
||||
// 一天的结束
|
||||
Date endOfDay = DateUtil.endOfDay(date);
|
||||
final Date endOfDay = DateUtil.endOfDay(date);
|
||||
Assert.assertEquals("2017-03-01 23:59:59", endOfDay.toString());
|
||||
}
|
||||
|
||||
@ -141,16 +118,16 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void truncateTest() {
|
||||
String dateStr2 = "2020-02-29 12:59:34";
|
||||
Date date2 = DateUtil.parse(dateStr2);
|
||||
final String dateStr2 = "2020-02-29 12:59:34";
|
||||
final Date date2 = DateUtil.parse(dateStr2);
|
||||
final DateTime dateTime = DateUtil.truncate(date2, DateField.MINUTE);
|
||||
Assert.assertEquals("2020-02-29 12:59:00", dateTime.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void ceilingMinuteTest() {
|
||||
String dateStr2 = "2020-02-29 12:59:34";
|
||||
Date date2 = DateUtil.parse(dateStr2);
|
||||
final String dateStr2 = "2020-02-29 12:59:34";
|
||||
final Date date2 = DateUtil.parse(dateStr2);
|
||||
|
||||
|
||||
DateTime dateTime = DateUtil.ceiling(date2, DateField.MINUTE);
|
||||
@ -162,8 +139,8 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void ceilingDayTest() {
|
||||
String dateStr2 = "2020-02-29 12:59:34";
|
||||
Date date2 = DateUtil.parse(dateStr2);
|
||||
final String dateStr2 = "2020-02-29 12:59:34";
|
||||
final Date date2 = DateUtil.parse(dateStr2);
|
||||
|
||||
|
||||
DateTime dateTime = DateUtil.ceiling(date2, DateField.DAY_OF_MONTH);
|
||||
@ -175,64 +152,64 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void beginOfWeekTest() {
|
||||
String dateStr = "2017-03-01 22:33:23";
|
||||
DateTime date = DateUtil.parse(dateStr);
|
||||
final String dateStr = "2017-03-01 22:33:23";
|
||||
final DateTime date = DateUtil.parse(dateStr);
|
||||
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());
|
||||
// 一周的结束
|
||||
Date endOfWeek = DateUtil.endOfWeek(date);
|
||||
final Date endOfWeek = DateUtil.endOfWeek(date);
|
||||
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());
|
||||
// 一周的结束
|
||||
Calendar end = DateUtil.endOfWeek(calendar);
|
||||
final Calendar end = DateUtil.endOfWeek(calendar);
|
||||
Assert.assertEquals("2017-03-05 23:59:59", DateUtil.date(end).toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void beginOfWeekTest2() {
|
||||
String beginStr = "2020-03-11";
|
||||
DateTime date = DateUtil.parseDate(beginStr);
|
||||
Calendar calendar = date.toCalendar();
|
||||
final String beginStr = "2020-03-11";
|
||||
final DateTime date = DateUtil.parseDate(beginStr);
|
||||
final Calendar calendar = date.toCalendar();
|
||||
final Calendar begin = DateUtil.beginOfWeek(calendar, false);
|
||||
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);
|
||||
Assert.assertEquals("2020-03-14 23:59:59", DateUtil.date(end).toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void offsetDateTest() {
|
||||
String dateStr = "2017-03-01 22:33:23";
|
||||
Date date = DateUtil.parse(dateStr);
|
||||
final String dateStr = "2017-03-01 22:33:23";
|
||||
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());
|
||||
|
||||
// 偏移天
|
||||
DateTime newDate2 = DateUtil.offsetDay(date, 3);
|
||||
final DateTime newDate2 = DateUtil.offsetDay(date, 3);
|
||||
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());
|
||||
|
||||
// 偏移月
|
||||
DateTime offsetMonth = DateUtil.offsetMonth(date, -1);
|
||||
final DateTime offsetMonth = DateUtil.offsetMonth(date, -1);
|
||||
Assert.assertEquals("2017-02-01 22:33:23", offsetMonth.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void offsetMonthTest() {
|
||||
DateTime st = DateUtil.parseDate("2018-05-31");
|
||||
List<DateTime> list = new ArrayList<>();
|
||||
final DateTime st = DateUtil.parseDate("2018-05-31");
|
||||
final List<DateTime> list = new ArrayList<>();
|
||||
for (int i = 0; i < 4; i++) {
|
||||
list.add(DateUtil.offsetMonth(st, i));
|
||||
}
|
||||
@ -244,11 +221,11 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void betweenTest() {
|
||||
String dateStr1 = "2017-03-01 22:34:23";
|
||||
Date date1 = DateUtil.parse(dateStr1);
|
||||
final String dateStr1 = "2017-03-01 22:34:23";
|
||||
final Date date1 = DateUtil.parse(dateStr1);
|
||||
|
||||
String dateStr2 = "2017-04-01 23:56:14";
|
||||
Date date2 = DateUtil.parse(dateStr2);
|
||||
final String dateStr2 = "2017-04-01 23:56:14";
|
||||
final Date date2 = DateUtil.parse(dateStr2);
|
||||
|
||||
// 相差月
|
||||
long betweenMonth = DateUtil.betweenMonth(date1, date2, false);
|
||||
@ -295,13 +272,13 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
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);
|
||||
}
|
||||
|
||||
@Test
|
||||
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);
|
||||
}
|
||||
|
||||
@ -325,20 +302,20 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void formatBetweenTest() {
|
||||
String dateStr1 = "2017-03-01 22:34:23";
|
||||
Date date1 = DateUtil.parse(dateStr1);
|
||||
final String dateStr1 = "2017-03-01 22:34:23";
|
||||
final Date date1 = DateUtil.parse(dateStr1);
|
||||
|
||||
String dateStr2 = "2017-04-01 23:56:14";
|
||||
Date date2 = DateUtil.parse(dateStr2);
|
||||
final String dateStr2 = "2017-04-01 23:56:14";
|
||||
final Date date2 = DateUtil.parse(dateStr2);
|
||||
|
||||
long between = DateUtil.between(date1, date2, DateUnit.MS);
|
||||
String formatBetween = DateUtil.formatBetween(between, Level.MINUTE);
|
||||
final long between = DateUtil.between(date1, date2, DateUnit.MS);
|
||||
final String formatBetween = DateUtil.formatBetween(between, Level.MINUTE);
|
||||
Assert.assertEquals("31天1小时21分", formatBetween);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void timerTest() {
|
||||
TimeInterval timer = DateUtil.timer();
|
||||
final TimeInterval timer = DateUtil.timer();
|
||||
|
||||
// ---------------------------------
|
||||
// -------这是执行过程
|
||||
@ -351,23 +328,23 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void currentTest() {
|
||||
long current = DateUtil.current();
|
||||
String currentStr = String.valueOf(current);
|
||||
final long current = DateUtil.current();
|
||||
final String currentStr = String.valueOf(current);
|
||||
Assert.assertEquals(13, currentStr.length());
|
||||
|
||||
long currentNano = DateUtil.current();
|
||||
String currentNanoStr = String.valueOf(currentNano);
|
||||
final long currentNano = DateUtil.current();
|
||||
final String currentNanoStr = String.valueOf(currentNano);
|
||||
Assert.assertNotNull(currentNanoStr);
|
||||
}
|
||||
|
||||
@Test
|
||||
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);
|
||||
|
||||
// 第二周周四
|
||||
int weekOfYear2 = DateUtil.weekOfYear(DateUtil.parse("2016-01-07"));
|
||||
final int weekOfYear2 = DateUtil.weekOfYear(DateUtil.parse("2016-01-07"));
|
||||
Assert.assertEquals(2, weekOfYear2);
|
||||
}
|
||||
|
||||
@ -397,34 +374,34 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void secondToTimeTest2() {
|
||||
String s1 = "55:02:18";
|
||||
String s2 = "55:00:50";
|
||||
int i = DateUtil.timeToSecond(s1) + DateUtil.timeToSecond(s2);
|
||||
String s = DateUtil.secondToTime(i);
|
||||
final String s1 = "55:02:18";
|
||||
final String s2 = "55:00:50";
|
||||
final int i = DateUtil.timeToSecond(s1) + DateUtil.timeToSecond(s2);
|
||||
final String s = DateUtil.secondToTime(i);
|
||||
Assert.assertEquals("110:03:08", s);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseTest2() {
|
||||
// 转换时间与SimpleDateFormat结果保持一致即可
|
||||
String birthday = "700403";
|
||||
Date birthDate = DateUtil.parse(birthday, "yyMMdd");
|
||||
final String birthday = "700403";
|
||||
final Date birthDate = DateUtil.parse(birthday, "yyMMdd");
|
||||
// 获取出生年(完全表现形式,如：2010)
|
||||
int sYear = DateUtil.year(birthDate);
|
||||
final int sYear = DateUtil.year(birthDate);
|
||||
Assert.assertEquals(1970, sYear);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseTest3() {
|
||||
String dateStr = "2018-10-10 12:11:11";
|
||||
Date date = DateUtil.parse(dateStr);
|
||||
String format = DateUtil.format(date, DatePattern.NORM_DATETIME_PATTERN);
|
||||
final String dateStr = "2018-10-10 12:11:11";
|
||||
final Date date = DateUtil.parse(dateStr);
|
||||
final String format = DateUtil.format(date, DatePattern.NORM_DATETIME_PATTERN);
|
||||
Assert.assertEquals(dateStr, format);
|
||||
}
|
||||
|
||||
@Test
|
||||
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);
|
||||
}
|
||||
|
||||
@ -465,8 +442,8 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void parseTest6() {
|
||||
String str = "Tue Jun 4 16:25:15 +0800 2019";
|
||||
DateTime dateTime = DateUtil.parse(str);
|
||||
final String str = "Tue Jun 4 16:25:15 +0800 2019";
|
||||
final DateTime dateTime = DateUtil.parse(str);
|
||||
assert dateTime != null;
|
||||
Assert.assertEquals("2019-06-04 16:25:15", dateTime.toString());
|
||||
}
|
||||
@ -486,8 +463,8 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void parseTest8() {
|
||||
String str = "2020-06-28T02:14:13.000Z";
|
||||
DateTime dateTime = DateUtil.parse(str);
|
||||
final String str = "2020-06-28T02:14:13.000Z";
|
||||
final DateTime dateTime = DateUtil.parse(str);
|
||||
assert dateTime != null;
|
||||
Assert.assertEquals("2020-06-28 02:14:13", dateTime.toString());
|
||||
}
|
||||
@ -523,8 +500,8 @@ public class DateUtilTest {
|
||||
*/
|
||||
@Test
|
||||
public void parseEmptyTest() {
|
||||
String str = " ";
|
||||
DateTime dateTime = DateUtil.parse(str);
|
||||
final String str = " ";
|
||||
final DateTime dateTime = DateUtil.parse(str);
|
||||
Assert.assertNull(dateTime);
|
||||
}
|
||||
|
||||
@ -545,34 +522,34 @@ public class DateUtilTest {
|
||||
@Test
|
||||
public void parseAndOffsetTest() {
|
||||
// 检查UTC时间偏移是否准确
|
||||
String str = "2019-09-17T13:26:17.948Z";
|
||||
DateTime dateTime = DateUtil.parse(str);
|
||||
final String str = "2019-09-17T13:26:17.948Z";
|
||||
final DateTime dateTime = DateUtil.parse(str);
|
||||
assert dateTime != null;
|
||||
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());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseDateTest() {
|
||||
String dateStr = "2018-4-10";
|
||||
Date date = DateUtil.parseDate(dateStr);
|
||||
String format = DateUtil.format(date, DatePattern.NORM_DATE_PATTERN);
|
||||
final String dateStr = "2018-4-10";
|
||||
final Date date = DateUtil.parseDate(dateStr);
|
||||
final String format = DateUtil.format(date, DatePattern.NORM_DATE_PATTERN);
|
||||
Assert.assertEquals("2018-04-10", format);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseToDateTimeTest1() {
|
||||
String dateStr1 = "2017-02-01";
|
||||
String dateStr2 = "2017/02/01";
|
||||
String dateStr3 = "2017.02.01";
|
||||
String dateStr4 = "2017年02月01日";
|
||||
final String dateStr1 = "2017-02-01";
|
||||
final String dateStr2 = "2017/02/01";
|
||||
final String dateStr3 = "2017.02.01";
|
||||
final String dateStr4 = "2017年02月01日";
|
||||
|
||||
DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
DateTime dt3 = DateUtil.parse(dateStr3);
|
||||
DateTime dt4 = DateUtil.parse(dateStr4);
|
||||
final DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
final DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
final DateTime dt3 = DateUtil.parse(dateStr3);
|
||||
final DateTime dt4 = DateUtil.parse(dateStr4);
|
||||
Assert.assertEquals(dt1, dt2);
|
||||
Assert.assertEquals(dt2, dt3);
|
||||
Assert.assertEquals(dt3, dt4);
|
||||
@ -580,15 +557,15 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void parseToDateTimeTest2() {
|
||||
String dateStr1 = "2017-02-01 12:23";
|
||||
String dateStr2 = "2017/02/01 12:23";
|
||||
String dateStr3 = "2017.02.01 12:23";
|
||||
String dateStr4 = "2017年02月01日 12:23";
|
||||
final String dateStr1 = "2017-02-01 12:23";
|
||||
final String dateStr2 = "2017/02/01 12:23";
|
||||
final String dateStr3 = "2017.02.01 12:23";
|
||||
final String dateStr4 = "2017年02月01日 12:23";
|
||||
|
||||
DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
DateTime dt3 = DateUtil.parse(dateStr3);
|
||||
DateTime dt4 = DateUtil.parse(dateStr4);
|
||||
final DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
final DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
final DateTime dt3 = DateUtil.parse(dateStr3);
|
||||
final DateTime dt4 = DateUtil.parse(dateStr4);
|
||||
Assert.assertEquals(dt1, dt2);
|
||||
Assert.assertEquals(dt2, dt3);
|
||||
Assert.assertEquals(dt3, dt4);
|
||||
@ -596,15 +573,15 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void parseToDateTimeTest3() {
|
||||
String dateStr1 = "2017-02-01 12:23:45";
|
||||
String dateStr2 = "2017/02/01 12:23:45";
|
||||
String dateStr3 = "2017.02.01 12:23:45";
|
||||
String dateStr4 = "2017年02月01日 12时23分45秒";
|
||||
final String dateStr1 = "2017-02-01 12:23:45";
|
||||
final String dateStr2 = "2017/02/01 12:23:45";
|
||||
final String dateStr3 = "2017.02.01 12:23:45";
|
||||
final String dateStr4 = "2017年02月01日 12时23分45秒";
|
||||
|
||||
DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
DateTime dt3 = DateUtil.parse(dateStr3);
|
||||
DateTime dt4 = DateUtil.parse(dateStr4);
|
||||
final DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
final DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
final DateTime dt3 = DateUtil.parse(dateStr3);
|
||||
final DateTime dt4 = DateUtil.parse(dateStr4);
|
||||
Assert.assertEquals(dt1, dt2);
|
||||
Assert.assertEquals(dt2, dt3);
|
||||
Assert.assertEquals(dt3, dt4);
|
||||
@ -612,21 +589,21 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void parseToDateTimeTest4() {
|
||||
String dateStr1 = "2017-02-01 12:23:45";
|
||||
String dateStr2 = "20170201122345";
|
||||
final String dateStr1 = "2017-02-01 12:23:45";
|
||||
final String dateStr2 = "20170201122345";
|
||||
|
||||
DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
final DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
final DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
Assert.assertEquals(dt1, dt2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseToDateTimeTest5() {
|
||||
String dateStr1 = "2017-02-01";
|
||||
String dateStr2 = "20170201";
|
||||
final String dateStr1 = "2017-02-01";
|
||||
final String dateStr2 = "20170201";
|
||||
|
||||
DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
final DateTime dt1 = DateUtil.parse(dateStr1);
|
||||
final DateTime dt2 = DateUtil.parse(dateStr2);
|
||||
Assert.assertEquals(dt1, dt2);
|
||||
}
|
||||
|
||||
@ -636,7 +613,7 @@ public class DateUtilTest {
|
||||
DateTime dt = DateUtil.parseUTC(dateStr1);
|
||||
|
||||
// parse方法支持UTC格式测试
|
||||
DateTime dt2 = DateUtil.parse(dateStr1);
|
||||
final DateTime dt2 = DateUtil.parse(dateStr1);
|
||||
Assert.assertEquals(dt, dt2);
|
||||
|
||||
// 默认使用Pattern对应的时区，即UTC时区
|
||||
@ -720,9 +697,9 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
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"，会导致相差一个小时
|
||||
sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
|
||||
final DateTime parse = DateUtil.parse(dateStr, sdf);
|
||||
@ -736,13 +713,13 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
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"));
|
||||
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);
|
||||
|
||||
Assert.assertEquals(parse, parse2);
|
||||
@ -750,29 +727,29 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void parseJDkTest() {
|
||||
String dateStr = "Thu May 16 17:57:18 GMT+08:00 2019";
|
||||
DateTime time = DateUtil.parse(dateStr);
|
||||
final String dateStr = "Thu May 16 17:57:18 GMT+08:00 2019";
|
||||
final DateTime time = DateUtil.parse(dateStr);
|
||||
Assert.assertEquals("2019-05-16 17:57:18", Objects.requireNonNull(time).toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseISOTest() {
|
||||
String dateStr = "2020-04-23T02:31:00.000Z";
|
||||
DateTime time = DateUtil.parse(dateStr);
|
||||
final String dateStr = "2020-04-23T02:31:00.000Z";
|
||||
final DateTime time = DateUtil.parse(dateStr);
|
||||
Assert.assertEquals("2020-04-23 02:31:00", Objects.requireNonNull(time).toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void endOfYearTest() {
|
||||
DateTime date = DateUtil.date();
|
||||
final DateTime date = DateUtil.date();
|
||||
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());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void endOfQuarterTest() {
|
||||
Date date = DateUtil.endOfQuarter(
|
||||
final Date date = DateUtil.endOfQuarter(
|
||||
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"));
|
||||
@ -781,30 +758,30 @@ public class DateUtilTest {
|
||||
@Test
|
||||
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());
|
||||
DateTime endOfWeek = DateUtil.endOfWeek(now);
|
||||
final DateTime endOfWeek = DateUtil.endOfWeek(now);
|
||||
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天
|
||||
Assert.assertEquals(6, between);
|
||||
}
|
||||
|
||||
@Test
|
||||
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);
|
||||
Week week = DateUtil.dayOfWeekEnum(DateUtil.parse("2018-03-07"));
|
||||
final Week week = DateUtil.dayOfWeekEnum(DateUtil.parse("2018-03-07"));
|
||||
Assert.assertEquals(Week.WEDNESDAY, week);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void compareTest() {
|
||||
Date date1 = DateUtil.parse("2021-04-13 23:59:59.999");
|
||||
Date date2 = DateUtil.parse("2021-04-13 23:59:10");
|
||||
final Date date1 = DateUtil.parse("2021-04-13 23:59:59.999");
|
||||
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, DatePattern.NORM_DATETIME_PATTERN));
|
||||
@ -812,45 +789,45 @@ public class DateUtilTest {
|
||||
Assert.assertEquals(0, DateUtil.compare(date1, date2, DatePattern.NORM_DATETIME_MINUTE_PATTERN));
|
||||
|
||||
|
||||
Date date11 = DateUtil.parse("2021-04-13 23:59:59.999");
|
||||
Date date22 = DateUtil.parse("2021-04-11 23:10:10");
|
||||
final Date date11 = DateUtil.parse("2021-04-13 23:59:59.999");
|
||||
final Date date22 = DateUtil.parse("2021-04-11 23:10:10");
|
||||
Assert.assertEquals(0, DateUtil.compare(date11, date22, DatePattern.NORM_MONTH_PATTERN));
|
||||
}
|
||||
|
||||
@Test
|
||||
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);
|
||||
|
||||
LinkedHashSet<String> yearAndQuarters = DateUtil.yearAndQuarter(DateUtil.parse("2018-09-10"), DateUtil.parse("2018-12-20"));
|
||||
List<String> list = CollUtil.list(false, yearAndQuarters);
|
||||
final LinkedHashSet<String> yearAndQuarters = DateUtil.yearAndQuarter(DateUtil.parse("2018-09-10"), DateUtil.parse("2018-12-20"));
|
||||
final List<String> list = CollUtil.list(false, yearAndQuarters);
|
||||
Assert.assertEquals(2, list.size());
|
||||
Assert.assertEquals("20183", list.get(0));
|
||||
Assert.assertEquals("20184", list.get(1));
|
||||
|
||||
LinkedHashSet<String> yearAndQuarters2 = DateUtil.yearAndQuarter(DateUtil.parse("2018-10-10"), DateUtil.parse("2018-12-10"));
|
||||
List<String> list2 = CollUtil.list(false, yearAndQuarters2);
|
||||
final LinkedHashSet<String> yearAndQuarters2 = DateUtil.yearAndQuarter(DateUtil.parse("2018-10-10"), DateUtil.parse("2018-12-10"));
|
||||
final List<String> list2 = CollUtil.list(false, yearAndQuarters2);
|
||||
Assert.assertEquals(1, list2.size());
|
||||
Assert.assertEquals("20184", list2.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
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);
|
||||
}
|
||||
|
||||
@Test
|
||||
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);
|
||||
Assert.assertEquals("2017-05-06T00:30:00Z", instant.toString());
|
||||
|
||||
LocalDate localDate = localDateTime.toLocalDate();
|
||||
final LocalDate localDate = localDateTime.toLocalDate();
|
||||
instant = DateUtil.toInstant(localDate);
|
||||
Assert.assertNotNull(instant);
|
||||
|
||||
LocalTime localTime = localDateTime.toLocalTime();
|
||||
final LocalTime localTime = localDateTime.toLocalTime();
|
||||
instant = DateUtil.toInstant(localTime);
|
||||
Assert.assertNotNull(instant);
|
||||
}
|
||||
@ -858,13 +835,13 @@ public class DateUtilTest {
|
||||
@Test
|
||||
public void dateTest() {
|
||||
//LocalDateTime ==> date
|
||||
LocalDateTime localDateTime = LocalDateTime.parse("2017-05-06T08:30:00", DateTimeFormatter.ISO_DATE_TIME);
|
||||
DateTime date = DateUtil.date(localDateTime);
|
||||
final LocalDateTime localDateTime = LocalDateTime.parse("2017-05-06T08:30:00", DateTimeFormatter.ISO_DATE_TIME);
|
||||
final DateTime date = DateUtil.date(localDateTime);
|
||||
Assert.assertEquals("2017-05-06 08:30:00", date.toString());
|
||||
|
||||
//LocalDate ==> date
|
||||
LocalDate localDate = localDateTime.toLocalDate();
|
||||
DateTime date2 = DateUtil.date(localDate);
|
||||
final LocalDate localDate = localDateTime.toLocalDate();
|
||||
final DateTime date2 = DateUtil.date(localDate);
|
||||
Assert.assertEquals("2017-05-06",
|
||||
DateUtil.format(date2, DatePattern.NORM_DATE_PATTERN));
|
||||
}
|
||||
@ -872,45 +849,45 @@ public class DateUtilTest {
|
||||
@Test
|
||||
public void dateTest2() {
|
||||
// 测试负数日期
|
||||
long dateLong = -1497600000;
|
||||
final long dateLong = -1497600000;
|
||||
final DateTime date = DateUtil.date(dateLong);
|
||||
Assert.assertEquals("1969-12-15 00:00:00", date.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void ageTest() {
|
||||
String d1 = "2000-02-29";
|
||||
String d2 = "2018-02-28";
|
||||
final String d1 = "2000-02-29";
|
||||
final String d2 = "2018-02-28";
|
||||
final int age = DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2));
|
||||
Assert.assertEquals(18, age);
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void ageTest2() {
|
||||
String d1 = "2019-02-29";
|
||||
String d2 = "2018-02-28";
|
||||
final String d1 = "2019-02-29";
|
||||
final String d2 = "2018-02-28";
|
||||
DateUtil.age(DateUtil.parseDate(d1), DateUtil.parseDate(d2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isExpiredTest() {
|
||||
DateTime startDate = DateUtil.parse("2019-12-01 17:02:30");
|
||||
DateTime endDate = DateUtil.parse("2019-12-02 17:02:30");
|
||||
int length = 3;
|
||||
final DateTime startDate = DateUtil.parse("2019-12-01 17:02:30");
|
||||
final DateTime endDate = DateUtil.parse("2019-12-02 17:02:30");
|
||||
final int length = 3;
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void localDateTimeTest() {
|
||||
// 测试字符串与LocalDateTime的互相转换
|
||||
String strDate = "2019-12-01 17:02:30";
|
||||
final String strDate = "2019-12-01 17:02:30";
|
||||
LocalDateTime ldt = DateUtil.parseLocalDateTime(strDate);
|
||||
String strDate1 = DateUtil.formatLocalDateTime(ldt);
|
||||
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);
|
||||
strDate1 = DateUtil.format(ldt, DatePattern.NORM_DATETIME_PATTERN);
|
||||
Assert.assertEquals(strDate, strDate1);
|
||||
@ -919,7 +896,7 @@ public class DateUtilTest {
|
||||
@Test
|
||||
public void localDateTimeTest2() {
|
||||
// 测试字符串与LocalDateTime的互相转换
|
||||
String strDate = "2019-12-01";
|
||||
final String strDate = "2019-12-01";
|
||||
final LocalDateTime localDateTime = DateUtil.parseLocalDateTime(strDate, "yyyy-MM-dd");
|
||||
Assert.assertEquals(strDate, DateUtil.format(localDateTime, DatePattern.NORM_DATE_PATTERN));
|
||||
}
|
||||
@ -936,8 +913,8 @@ public class DateUtilTest {
|
||||
@Test
|
||||
public void betweenDayTest() {
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
String datr = RandomUtil.randomInt(1900, 2099) + "-01-20";
|
||||
long betweenDay = DateUtil.betweenDay(
|
||||
final String datr = RandomUtil.randomInt(1900, 2099) + "-01-20";
|
||||
final long betweenDay = DateUtil.betweenDay(
|
||||
DateUtil.parseDate("1970-01-01"),
|
||||
DateUtil.parseDate(datr), false);
|
||||
Assert.assertEquals(Math.abs(LocalDate.parse(datr).toEpochDay()), betweenDay);
|
||||
@ -946,9 +923,9 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
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);
|
||||
int lengthOfYear = DateUtil.lengthOfYear(2020);
|
||||
final int lengthOfYear = DateUtil.lengthOfYear(2020);
|
||||
Assert.assertEquals(366, lengthOfYear);
|
||||
}
|
||||
|
||||
@ -977,7 +954,7 @@ public class DateUtilTest {
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
@Test
|
||||
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);
|
||||
Assert.assertEquals("2020-06-03 12:32:12", parse.toString());
|
||||
}
|
||||
@ -991,9 +968,9 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void formatTest() {
|
||||
Calendar calendar = new GregorianCalendar();
|
||||
final Calendar calendar = new GregorianCalendar();
|
||||
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_FORMAT));
|
||||
@ -1060,24 +1037,24 @@ public class DateUtilTest {
|
||||
@Test
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
public void isOverlapTest() {
|
||||
DateTime oneStartTime = DateUtil.parse("2022-01-01 10:10:10");
|
||||
DateTime oneEndTime = DateUtil.parse("2022-01-01 11:10:10");
|
||||
final DateTime oneStartTime = DateUtil.parse("2022-01-01 10:10:10");
|
||||
final DateTime oneEndTime = DateUtil.parse("2022-01-01 11:10:10");
|
||||
|
||||
DateTime oneStartTime2 = DateUtil.parse("2022-01-01 11:20:10");
|
||||
DateTime oneEndTime2 = DateUtil.parse("2022-01-01 11:30:10");
|
||||
final DateTime oneStartTime2 = DateUtil.parse("2022-01-01 11:20:10");
|
||||
final DateTime oneEndTime2 = DateUtil.parse("2022-01-01 11:30:10");
|
||||
|
||||
DateTime oneStartTime3 = DateUtil.parse("2022-01-01 11:40:10");
|
||||
DateTime oneEndTime3 = DateUtil.parse("2022-01-01 11:50:10");
|
||||
final DateTime oneStartTime3 = DateUtil.parse("2022-01-01 11:40:10");
|
||||
final DateTime oneEndTime3 = DateUtil.parse("2022-01-01 11:50:10");
|
||||
|
||||
//真实请假数据
|
||||
DateTime realStartTime = DateUtil.parse("2022-01-01 11:49:10");
|
||||
DateTime realEndTime = DateUtil.parse("2022-01-01 12:00:10");
|
||||
final DateTime realStartTime = DateUtil.parse("2022-01-01 11:49:10");
|
||||
final DateTime realEndTime = DateUtil.parse("2022-01-01 12:00:10");
|
||||
|
||||
DateTime realStartTime1 = DateUtil.parse("2022-03-01 08:00:00");
|
||||
DateTime realEndTime1 = DateUtil.parse("2022-03-01 10:00:00");
|
||||
final DateTime realStartTime1 = DateUtil.parse("2022-03-01 08:00:00");
|
||||
final DateTime realEndTime1 = DateUtil.parse("2022-03-01 10:00:00");
|
||||
|
||||
DateTime startTime = DateUtil.parse("2022-03-23 05:00:00");
|
||||
DateTime endTime = DateUtil.parse("2022-03-23 13:00:00");
|
||||
final DateTime startTime = DateUtil.parse("2022-03-23 05: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(oneStartTime2, oneEndTime2, realStartTime, realEndTime));
|
||||
@ -1089,21 +1066,21 @@ public class DateUtilTest {
|
||||
|
||||
@Test
|
||||
public void isOverlapTest2() {
|
||||
DateTime oneStartTime = DateUtil.parseDate("2021-02-01");
|
||||
DateTime oneEndTime = DateUtil.parseDate("2022-06-30");
|
||||
final DateTime oneStartTime = DateUtil.parseDate("2021-02-01");
|
||||
final DateTime oneEndTime = DateUtil.parseDate("2022-06-30");
|
||||
|
||||
DateTime oneStartTime2 = DateUtil.parseDate("2019-04-05");
|
||||
DateTime oneEndTime2 = DateUtil.parseDate("2021-04-05");
|
||||
final DateTime oneStartTime2 = DateUtil.parseDate("2019-04-05");
|
||||
final DateTime oneEndTime2 = DateUtil.parseDate("2021-04-05");
|
||||
|
||||
Assert.assertTrue(DateUtil.isOverlap(oneStartTime, oneEndTime, oneStartTime2, oneEndTime2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isInTest(){
|
||||
String sourceStr = "2022-04-19 00:00:00";
|
||||
String startTimeStr = "2022-04-19 00:00:00";
|
||||
String endTimeStr = "2022-04-19 23:59:59";
|
||||
boolean between = DateUtil.isIn(DateUtil.parse(startTimeStr),
|
||||
final String sourceStr = "2022-04-19 00:00:00";
|
||||
final String startTimeStr = "2022-04-19 00:00:00";
|
||||
final String endTimeStr = "2022-04-19 23:59:59";
|
||||
final boolean between = DateUtil.isIn(DateUtil.parse(startTimeStr),
|
||||
DateUtil.parse(endTimeStr),
|
||||
DateUtil.parse(sourceStr));
|
||||
Assert.assertTrue(between);
|
||||
|
||||
@ -133,7 +133,7 @@ public final class InternalJSONUtil {
|
||||
/**
|
||||
* 将Property的键转化为JSON形式<br>
|
||||
* 用于识别类似于：com.luxiaolei.package.hutool这类用点隔开的键<br>
|
||||
* 注意：不允许重复键
|
||||
* 注意：是否允许重复键，取决于JSONObject配置
|
||||
*
|
||||
* @param jsonObject JSONObject
|
||||
* @param key 键
|
||||
@ -142,18 +142,18 @@ public final class InternalJSONUtil {
|
||||
*/
|
||||
static JSONObject propertyPut(JSONObject jsonObject, Object key, Object value, Filter<MutablePair<String, Object>> filter) {
|
||||
final String[] path = StrUtil.splitToArray(Convert.toStr(key), CharUtil.DOT);
|
||||
int last = path.length - 1;
|
||||
final int last = path.length - 1;
|
||||
JSONObject target = jsonObject;
|
||||
for (int i = 0; i < last; i += 1) {
|
||||
String segment = path[i];
|
||||
final String segment = path[i];
|
||||
JSONObject nextTarget = target.getJSONObject(segment);
|
||||
if (nextTarget == null) {
|
||||
nextTarget = new JSONObject(target.getConfig());
|
||||
target.setOnce(segment, nextTarget, filter);
|
||||
target.set(segment, nextTarget, filter, target.getConfig().isCheckDuplicate());
|
||||
}
|
||||
target = nextTarget;
|
||||
}
|
||||
target.setOnce(path[last], value, filter);
|
||||
target.set(path[last], value, filter, target.getConfig().isCheckDuplicate());
|
||||
return jsonObject;
|
||||
}
|
||||
|
||||
|
||||
@ -45,9 +45,9 @@ public class JSONConfig implements Serializable {
|
||||
private boolean stripTrailingZeros = true;
|
||||
|
||||
/**
|
||||
* 是否忽略多个相同的key
|
||||
* 是否检查重复key
|
||||
*/
|
||||
private boolean ignoreDuplicateKey = false;
|
||||
private boolean checkDuplicate;
|
||||
|
||||
/**
|
||||
* 创建默认的配置项
|
||||
@ -242,20 +242,24 @@ public class JSONConfig implements Serializable {
|
||||
}
|
||||
|
||||
/**
|
||||
* 是否忽略多个相同的key
|
||||
* @return
|
||||
* 是否检查多个相同的key
|
||||
*
|
||||
* @return 是否检查多个相同的key
|
||||
* @since 5.8.5
|
||||
*/
|
||||
public boolean isIgnoreDuplicateKey() {
|
||||
return ignoreDuplicateKey;
|
||||
public boolean isCheckDuplicate() {
|
||||
return checkDuplicate;
|
||||
}
|
||||
|
||||
/**
|
||||
* 是否忽略多个相同的key
|
||||
* @param ignoreDuplicateKey
|
||||
* @return
|
||||
* 是否检查多个相同的key
|
||||
*
|
||||
* @param checkDuplicate 是否检查多个相同的key
|
||||
* @return this
|
||||
* @since 5.8.5
|
||||
*/
|
||||
public JSONConfig setIgnoreDuplicateKey(boolean ignoreDuplicateKey) {
|
||||
this.ignoreDuplicateKey = ignoreDuplicateKey;
|
||||
public JSONConfig setCheckDuplicate(boolean checkDuplicate) {
|
||||
this.checkDuplicate = checkDuplicate;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
@ -236,7 +236,7 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
|
||||
Object value;
|
||||
for (String name : names) {
|
||||
value = ((Map<?, ?>) source).get(name);
|
||||
this.putOnce(name, value);
|
||||
this.set(name, value, null, getConfig().isCheckDuplicate());
|
||||
}
|
||||
} else {
|
||||
for (String name : names) {
|
||||
@ -392,9 +392,7 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
|
||||
// 忽略值模式下如果值为空清除key
|
||||
this.remove(key);
|
||||
} else {
|
||||
/*如果允许多个key，就不抛出异常，使用后面的值覆盖前面的值*/
|
||||
boolean ignoreDuplicateKey = this.config.isIgnoreDuplicateKey();
|
||||
if (checkDuplicate && containsKey(key) && false == ignoreDuplicateKey) {
|
||||
if (checkDuplicate && containsKey(key)) {
|
||||
throw new JSONException("Duplicate key \"{}\"", key);
|
||||
}
|
||||
|
||||
|
||||
@ -69,7 +69,7 @@ public class JSONParser {
|
||||
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 ','.
|
||||
|
||||
|
||||
@ -88,11 +88,11 @@ public class ObjectMapper {
|
||||
if (source instanceof Map) {
|
||||
// Map
|
||||
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) {
|
||||
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) {
|
||||
// 可能为JSON字符串
|
||||
mapFromStr((CharSequence) source, jsonObject, filter);
|
||||
|
||||
@ -26,7 +26,7 @@ public class JSONUtilTest {
|
||||
*/
|
||||
@Test(expected = JSONException.class)
|
||||
public void parseTest() {
|
||||
JSONArray jsonArray = JSONUtil.parseArray("[{\"a\":\"a\\x]");
|
||||
final JSONArray jsonArray = JSONUtil.parseArray("[{\"a\":\"a\\x]");
|
||||
Console.log(jsonArray);
|
||||
}
|
||||
|
||||
@ -35,7 +35,7 @@ public class JSONUtilTest {
|
||||
*/
|
||||
@Test(expected = JSONException.class)
|
||||
public void parseNumberTest() {
|
||||
JSONArray json = JSONUtil.parseArray(123L);
|
||||
final JSONArray json = JSONUtil.parseArray(123L);
|
||||
Assert.assertNotNull(json);
|
||||
}
|
||||
|
||||
@ -44,42 +44,42 @@ public class JSONUtilTest {
|
||||
*/
|
||||
@Test
|
||||
public void parseNumberTest2() {
|
||||
JSONObject json = JSONUtil.parseObj(123L);
|
||||
final JSONObject json = JSONUtil.parseObj(123L);
|
||||
Assert.assertEquals(new JSONObject(), json);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toJsonStrTest() {
|
||||
UserA a1 = new UserA();
|
||||
final UserA a1 = new UserA();
|
||||
a1.setA("aaaa");
|
||||
a1.setDate(DateUtil.date());
|
||||
a1.setName("AAAAName");
|
||||
UserA a2 = new UserA();
|
||||
final UserA a2 = new UserA();
|
||||
a2.setA("aaaa222");
|
||||
a2.setDate(DateUtil.date());
|
||||
a2.setName("AAAA222Name");
|
||||
|
||||
ArrayList<UserA> list = CollectionUtil.newArrayList(a1, a2);
|
||||
HashMap<String, Object> map = MapUtil.newHashMap();
|
||||
final ArrayList<UserA> list = CollectionUtil.newArrayList(a1, a2);
|
||||
final HashMap<String, Object> map = MapUtil.newHashMap();
|
||||
map.put("total", 13);
|
||||
map.put("rows", list);
|
||||
|
||||
String str = JSONUtil.toJsonPrettyStr(map);
|
||||
final String str = JSONUtil.toJsonPrettyStr(map);
|
||||
JSONUtil.parse(str);
|
||||
Assert.assertNotNull(str);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toJsonStrTest2() {
|
||||
Map<String, Object> model = new HashMap<>();
|
||||
final Map<String, Object> model = new HashMap<>();
|
||||
model.put("mobile", "17610836523");
|
||||
model.put("type", 1);
|
||||
|
||||
Map<String, Object> data = new HashMap<>();
|
||||
final Map<String, Object> data = new HashMap<>();
|
||||
data.put("model", model);
|
||||
data.put("model2", model);
|
||||
|
||||
JSONObject jsonObject = JSONUtil.parseObj(data);
|
||||
final JSONObject jsonObject = JSONUtil.parseObj(data);
|
||||
|
||||
Assert.assertTrue(jsonObject.containsKey("model"));
|
||||
Assert.assertEquals(1, jsonObject.getJSONObject("model").getInt("type").intValue());
|
||||
@ -90,25 +90,25 @@ public class JSONUtilTest {
|
||||
@Test
|
||||
public void toJsonStrTest3() {
|
||||
// 验证某个字段为JSON字符串时转义是否规范
|
||||
JSONObject object = new JSONObject(true);
|
||||
final JSONObject object = new JSONObject(true);
|
||||
object.set("name", "123123");
|
||||
object.set("value", "\\");
|
||||
object.set("value2", "</");
|
||||
|
||||
HashMap<String, String> map = MapUtil.newHashMap();
|
||||
final HashMap<String, String> map = MapUtil.newHashMap();
|
||||
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("{\"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"));
|
||||
}
|
||||
|
||||
@Test
|
||||
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;
|
||||
|
||||
{
|
||||
@ -125,20 +125,20 @@ public class JSONUtilTest {
|
||||
*/
|
||||
@Test
|
||||
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));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toBeanTest2() {
|
||||
// 测试JSONObject转为Bean中字符串字段的情况
|
||||
String json = "{\"id\":123,\"name\":\"张三\",\"prop\":{\"gender\":\"男\", \"age\":18}}";
|
||||
UserC user = JSONUtil.toBean(json, UserC.class);
|
||||
final String json = "{\"id\":123,\"name\":\"张三\",\"prop\":{\"gender\":\"男\", \"age\":18}}";
|
||||
final UserC user = JSONUtil.toBean(json, UserC.class);
|
||||
Assert.assertNotNull(user.getProp());
|
||||
String prop = user.getProp();
|
||||
JSONObject propJson = JSONUtil.parseObj(prop);
|
||||
final String prop = user.getProp();
|
||||
final JSONObject propJson = JSONUtil.parseObj(prop);
|
||||
Assert.assertEquals("男", propJson.getStr("gender"));
|
||||
Assert.assertEquals(18, propJson.getInt("age").intValue());
|
||||
// Assert.assertEquals("{\"age\":18,\"gender\":\"男\"}", user.getProp());
|
||||
@ -146,22 +146,22 @@ public class JSONUtilTest {
|
||||
|
||||
@Test
|
||||
public void getStrTest() {
|
||||
String html = "{\"name\":\"Something must have been changed since you leave\"}";
|
||||
JSONObject jsonObject = JSONUtil.parseObj(html);
|
||||
final String html = "{\"name\":\"Something must have been changed since you leave\"}";
|
||||
final JSONObject jsonObject = JSONUtil.parseObj(html);
|
||||
Assert.assertEquals("Something must have been changed since you leave", jsonObject.getStr("name"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getStrTest2() {
|
||||
String html = "{\"name\":\"Something\\u00a0must have been changed since you leave\"}";
|
||||
JSONObject jsonObject = JSONUtil.parseObj(html);
|
||||
final String html = "{\"name\":\"Something\\u00a0must have been changed since you leave\"}";
|
||||
final JSONObject jsonObject = JSONUtil.parseObj(html);
|
||||
Assert.assertEquals("Something\\u00a0must\\u00a0have\\u00a0been\\u00a0changed\\u00a0since\\u00a0you\\u00a0leave", jsonObject.getStrEscaped("name"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseFromXmlTest() {
|
||||
String s = "<sfzh>640102197312070614</sfzh><sfz>640102197312070614X</sfz><name>aa</name><gender>1</gender>";
|
||||
JSONObject json = JSONUtil.parseFromXml(s);
|
||||
final String s = "<sfzh>640102197312070614</sfzh><sfz>640102197312070614X</sfz><name>aa</name><gender>1</gender>";
|
||||
final JSONObject json = JSONUtil.parseFromXml(s);
|
||||
Assert.assertEquals(640102197312070614L, json.get("sfzh"));
|
||||
Assert.assertEquals("640102197312070614X", json.get("sfz"));
|
||||
Assert.assertEquals("aa", json.get("name"));
|
||||
@ -170,7 +170,7 @@ public class JSONUtilTest {
|
||||
|
||||
@Test
|
||||
public void doubleTest() {
|
||||
String json = "{\"test\": 12.00}";
|
||||
final String json = "{\"test\": 12.00}";
|
||||
final JSONObject jsonObject = JSONUtil.parseObj(json);
|
||||
//noinspection BigDecimalMethodWithoutRoundingCalled
|
||||
Assert.assertEquals("12.00", jsonObject.getBigDecimal("test").setScale(2).toString());
|
||||
@ -222,7 +222,7 @@ public class JSONUtilTest {
|
||||
@Test
|
||||
public void parseBigNumberTest(){
|
||||
// 科学计数法使用BigDecimal处理，默认输出非科学计数形式
|
||||
String str = "{\"test\":100000054128897953e4}";
|
||||
final String str = "{\"test\":100000054128897953e4}";
|
||||
Assert.assertEquals("{\"test\":1000000541288979530000}", JSONUtil.parseObj(str).toString());
|
||||
}
|
||||
|
||||
@ -236,12 +236,18 @@ public class JSONUtilTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDuplicateKey(){
|
||||
String str = "{id:123, name:\"张三\", name:\"李四\"}";
|
||||
public void duplicateKeyFalseTest(){
|
||||
final String str = "{id:123, name:\"张三\", name:\"李四\"}";
|
||||
|
||||
JSONObject jsonObject = JSONUtil.parseObj(str, JSONConfig.create().setIgnoreDuplicateKey(true));
|
||||
System.out.println(jsonObject.toString());
|
||||
final JSONObject jsonObject = JSONUtil.parseObj(str, JSONConfig.create().setCheckDuplicate(false));
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user