我家自动化

这个屌丝很懒，什么也没留下！

热门标签

Java中的日期转化格式DateUtil工具类-（87个方法）_java dateutil

作者：我家自动化 | 2024-03-18 05:04:14

踩

java dateutil

Java中的日期转化格式DateUtil工具类-（87个方法）

一、Java中的日期转化格式DateUtil工具类 - 简介
二、Java中的日期转化格式DateUtil工具类 - 详细功能介绍
三、Java中的日期转化格式DateUtil工具类 - 完整的 DateUtil.java 代码

一、Java中的日期转化格式DateUtil工具类 - 简介

日期工具类：DateUtil.java
主要记录一些常用的日期转换功能，下面一一阐述。

二、Java中的日期转化格式DateUtil工具类 - 详细功能介绍

1、clearDate(Date date, int clearNum) - 根据传入的日期和参数将日期对应字段后面所有日期字段清零

方法代码如下：

	/**
	 * 根据传入的日期和参数将日期对应字段后面所有日期字段清零 参数对应字段说明：1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
	 * 返回的是Calendar类型
	 * 
	 * 样例: 1 Thu Mar 04 10:38:25 CST 2021 2 Thu Mar 04 10:38:00 CST 2021 3 Thu Mar
	 * 04 10:00:00 CST 2021 4 Thu Mar 04 00:00:00 CST 2021 5 Mon Mar 01 00:00:00 CST
	 * 2021 6 Fri Jan 01 00:00:00 CST 2021
	 *
	 * @param date     传入的日期时间
	 * @param clearNum 1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
	 * @return
	 */
	public static Calendar clearDate(Date date, int clearNum) {
		Calendar cal = new GregorianCalendar();
		cal.setTime(date);
		// 毫秒
		if (clearNum > 0) {
			cal.set(Calendar.MILLISECOND, 0);
		}
		// 秒

		if (clearNum > 1) {
			cal.set(Calendar.SECOND, 0);
		}
		// 分钟
		if (clearNum > 2) {
			cal.set(Calendar.MINUTE, 0);
		}
		// 小时
		if (clearNum > 3) {
			cal.set(Calendar.HOUR_OF_DAY, 0);
		}
		// 天

		if (clearNum > 4) {
			cal.set(Calendar.DATE, 1);
		}
		// 月份
		if (clearNum > 5) {
			cal.set(Calendar.MONTH, 0);
		}
		return cal;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2、dateToStrLong(Date date) - 将传入的Date格式化为"yyyy-MM-dd HH:mm:ss"形式，Date没有非空判断

方法代码如下：

	/**
	 * 将传入的Date格式化为"yyyy-MM-dd HH:mm:ss"形式，Date没有非空判断
	 *
	 * @param dateDate
	 * @return
	 */
	public static String dateToStrLong(Date date) {
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dateString = formatter.format(date);
		return dateString;
	}
1
2
3
4
5
6
7
8
9
10
11

3、format(Calendar date) - 将Calendar类型的时间转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Calendar有非空判断

方法代码如下：

	/**
	 * 将Calendar类型的时间转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Calendar有非空判断
	 * 
	 * @param date
	 * @return
	 */
	public static String format(Calendar date) {
		if (date == null) {
			return "";
		}
		return format(date.getTime(), "yyyy-MM-dd HH:mm:ss");
	}
1
2
3
4
5
6
7
8
9
10
11
12

4、format(Date date) - 将Date类型转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Date有非空判断

方法代码如下：

	/**
	 * 将Date类型转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Date有非空判断
	 *
	 * @param date 日期类型
	 * @return 日期字符串
	 */
	public static String format(Date date) {
		if (date == null) {
			return "";
		}
		return format(date, "yyyy-MM-dd HH:mm:ss");
	}
1
2
3
4
5
6
7
8
9
10
11
12

5、format(Date date, String pattern) - 将Date类型时间转换为指定格式的字符串

方法代码如下：

	/**
	 * 将Date类型时间转换为指定格式的字符串，
	 *
	 * @param date    日期类型
	 * @param pattern 日期格式化的字符串格式 可以不输入，不输入 默认是"yyyy-MM-dd HH:mm:ss"
	 * @return 返回的日期字符串
	 */
	public static String format(Date date, String pattern) {
		if (date == null) {
			return "";
		}
		if (pattern == null || pattern.equals("") || pattern.equals("null")) {
			pattern = "yyyy-MM-dd HH:mm:ss";
		}
		return new SimpleDateFormat(pattern).format(date);
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6、format(String date) - 将字符串类型时间转换为Date类型字符串格式为"yyyy-MM-dd HH:mm:ss"

方法代码如下：

	/**
	 * 将字符串类型时间转换为Date类型 字符串格式为"yyyy-MM-dd HH:mm:ss"
	 *
	 * @param date 字符串类型 格式为"yyyy-MM-dd HH:mm:ss"
	 * @return 日期类型
	 */
	public static Date format(String date) {
		return format(date, null);
	}
1
2
3
4
5
6
7
8
9

7、format(String date, String pattern) - 将指定格式的字符串时间类型转换为Date类型

方法代码如下：

	/**
	 * 将指定格式的字符串时间类型转换为Date类型
	 * 
	 * @param date    字符串类型 时间字符串 不输入默认返回当前时间
	 * @param pattern 时间字符串格式 不输入默认是yyyy-MM-dd HH:mm:ss
	 * @return 日期类型
	 */
	public static Date format(String date, String pattern) {
		if (pattern == null || pattern.equals("") || pattern.equals("null")) {
			pattern = "yyyy-MM-dd HH:mm:ss";
		}
		if (date == null || date.equals("") || date.equals("null")) {
			return new Date();
		}
		Date d = null;
		try {
			d = new SimpleDateFormat(pattern).parse(date);
		} catch (ParseException pe) {
			System.out.println("日期解析失败  date:" + date + "  pattern:" + pattern);
		}
		return d;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8、getCurDateTimeStr() - 取得当前的时间，格式为 yyyy-MM-dd HH:mm:ss

方法代码如下：

	/**
	 * 取得当前的时间，格式为 yyyy-MM-dd HH:mm:ss
	 *
	 * @return
	 */
	public static String getCurDateTimeStr() {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
	}
1
2
3
4
5
6
7
8

9、getCurrDate() - 返回当前时间的格式化字符串字符串格式为：“yyyy-MM-dd HH:mm:ss”

方法代码如下：

	/**
	 * 返回当前时间的格式化字符串 字符串格式为："yyyy-MM-dd HH:mm:ss"
	 * 
	 * @return
	 */
	public static String getCurrDate() {
		return format(new Date(), "yyyy-MM-dd HH:mm:ss");
	}
1
2
3
4
5
6
7
8

10、getCurrentQuarterEndTime() - 获取当前季度的结束时间

方法代码如下：

	/**
	 * 获取当前季度的结束时间
	 *
	 * @return
	 */
	public static Date getCurrentQuarterEndTime() {
		Calendar c = Calendar.getInstance();
		int currentMonth = c.get(Calendar.MONTH) + 1;
		try {
			if (currentMonth >= 1 && currentMonth <= 3) {
				c.set(Calendar.MONTH, 2);
				c.set(Calendar.DATE, 31);
			} else if (currentMonth >= 4 && currentMonth <= 6) {
				c.set(Calendar.MONTH, 5);
				c.set(Calendar.DATE, 30);
			} else if (currentMonth >= 7 && currentMonth <= 9) {
				c.set(Calendar.MONTH, 8);
				c.set(Calendar.DATE, 30);
			} else if (currentMonth >= 10 && currentMonth <= 12) {
				c.set(Calendar.MONTH, 11);
				c.set(Calendar.DATE, 31);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		c.set(Calendar.MILLISECOND, 000);
		return c.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

11、getCurrentQuarterStartTime() - 获取当前季度的开始时间

方法代码如下：

	/**
	 * 获取当前季度的开始时间
	 *
	 * @return
	 */
	public static Date getCurrentQuarterStartTime() {
		Calendar c = Calendar.getInstance();
		int currentMonth = c.get(Calendar.MONTH) + 1;
		Date now = null;
		try {
			if (currentMonth >= 1 && currentMonth <= 3)
				c.set(Calendar.MONTH, 0);
			else if (currentMonth >= 4 && currentMonth <= 6)
				c.set(Calendar.MONTH, 3);
			else if (currentMonth >= 7 && currentMonth <= 9)
				c.set(Calendar.MONTH, 6);
			else if (currentMonth >= 10 && currentMonth <= 12)
				c.set(Calendar.MONTH, 9);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return clearDate(c.getTime(), 5).getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

12、getCurrStartAndEndOfWeek() - 获取当期日期的一周开始至结束日期返回一个Calendar数组，长度为7 星期一作为一周的开始

方法代码如下：

	/**
	 * 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
	 * 
	 * @return
	 */
	public static Calendar[] getCurrStartAndEndOfWeek() {
		Calendar cal = Calendar.getInstance();
		// 向后推一天（从星期一到周末）
		cal.add(Calendar.DATE, -1);
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		Calendar tuesday = (Calendar) cal.clone();// 周二
		tuesday.add(Calendar.DATE, 2 - nw + 1);
		Calendar wednesday = (Calendar) cal.clone();// 周三
		wednesday.add(Calendar.DATE, 3 - nw + 1);
		Calendar thursday = (Calendar) cal.clone();// 周四
		thursday.add(Calendar.DATE, 4 - nw + 1);
		Calendar friday = (Calendar) cal.clone();// 周五
		friday.add(Calendar.DATE, 5 - nw + 1);
		Calendar saturday = (Calendar) cal.clone();// 周六
		saturday.add(Calendar.DATE, 6 - nw + 1);
		Calendar end = (Calendar) cal.clone();
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
		return darr;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

13、getCurrStartEndDate() - 获取当期日期的一周开始和结束日期返回一个Calendar数组，长度为2 分别是开始日期和结束日期星期一作为一周的开始

方法代码如下：

	/**
	 * 获取当期日期的一周 开始和结束日期 返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始
	 * 
	 * @return
	 */
	public static Calendar[] getCurrStartEndDate() {
		Calendar cal = Calendar.getInstance();
		// 向后推一天（从星期一到周末）
		cal.add(Calendar.DATE, -1);
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		Calendar end = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, end };
		return darr;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

14、getDatePoorHour(Date nowDate, Date endDate) - 计算俩个时间差多少天多少小时

方法代码如下：

	/**
	 * 计算俩个时间差多少天多少小时
	 *
	 * @param endDate 结束时间
	 * @param nowDate 开始时间
	 * @return 差几天的字符串
	 */
	public static String getDatePoorHour(Date nowDate, Date endDate) {

		long nd = 1000 * 24 * 60 * 60l;
		long nh = 1000 * 60 * 60l;
		long nm = 1000 * 60l;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = endDate.getTime() - nowDate.getTime();
		// 计算差多少天
		long day = diff / nd;
		// 计算差多少小时
		long hour = (diff % nd) / nh;
		// 计算差多少分钟
		long min = (diff % nd % nh) / nm;
		// 计算差多少秒//输出结果
		// long sec = diff % nd % nh % nm / ns;
		return day + "天" + hour + "小时";
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

15、getDatePoorMinute(Date nowDate, Date endDate) - 计算俩个时间差多少天多少小时多少分钟

方法代码如下：

	/**
	 * 计算俩个时间差多少天多少小时多少分钟
	 *
	 * @param endDate 结束时间
	 * @param nowDate 开始时间
	 * @return
	 */
	public static String getDatePoorMinute(Date nowDate, Date endDate) {

		long nd = 1000 * 24 * 60 * 60l;
		long nh = 1000 * 60 * 60l;
		long nm = 1000 * 60l;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = endDate.getTime() - nowDate.getTime();
		// 计算差多少天
		long day = diff / nd;
		// 计算差多少小时
		long hour = (diff % nd) / nh;
		// 计算差多少分钟
		long min = (diff % nd % nh) / nm;
		// 计算差多少秒//输出结果
		// long sec = diff % nd % nh % nm / ns;
		String tempStr = "";
		if (day > 0) {
			tempStr = day + "天";
		}
		if (hour > 0) {
			tempStr += hour + "小时";
		}
		if (min > 0) {
			tempStr += min + "分钟";
		}
		return tempStr;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

16、getDatePoorTotalMinute(Date nowDate, Date endDate) - 计算俩个时间相差多少分钟

方法代码如下：

	/**
	 * 计算俩个时间相差多少分钟
	 *
	 * @param endDate 结束时间
	 * @param nowDate 开始时间
	 * @return
	 */
	public static long getDatePoorTotalMinute(Date nowDate, Date endDate) {
		long nm = 1000 * 60l;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = endDate.getTime() - nowDate.getTime();
		Long tempLong = diff / nm;
		return tempLong;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

17、getDatetimeDayLimit(String day) - 根据指定的天字符串算出天开始和天结束的时间，精确到秒

方法代码如下：

	/**
	 * 根据指定的天字符串算出天开始和天结束的时间，精确到秒
	 * 
	 * @param day 指定的天字符串 格式为：2020-01-01
	 * @return 算出天开始和天结束的时间
	 */
	public static Date[] getDatetimeDayLimit(String day) {
		String startStr = day + " 00:00:00";
		Date start = DateUtil.parseDate(startStr);
		return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
	}

1
2
3
4
5
6
7
8
9
10
11
12

18、getDatetimeMonthLimit(String monthStr) - 根据指定的月字符串算出月初和月未的时间，精确到秒实例：输入：2020-01 输出：Wed Jan 01 00:00:00 CST 2020 Fri

方法代码如下：

	/**
	 * 根据指定的月字符串算出月初和月未的时间，精确到秒 实例：输入：2020-01 输出：Wed Jan 01 00:00:00 CST 2020 Fri
	 * Jan 31 23:59:59 CST 2020
	 * 
	 *
	 * @param monthStr 格式为:2020-01形式
	 * @return 月初和月末时间数组
	 */
	public static Date[] getDatetimeMonthLimit(String monthStr) {
		String start = monthStr + "-01 00:00:00";
		Date startTime = DateUtil.format(start);

		Calendar cal = Calendar.getInstance();
		cal.setTime(startTime);
		cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE) + 1);
		cal.add(Calendar.SECOND, -1);
		Date endTime = cal.getTime();
		return new Date[] { startTime, endTime };
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

19、getDatetimePreDayLimit(String day) - 根据指定的天字符串算出昨天开始和昨天结束的时间，精确到秒

方法代码如下：

	/**
	 * 根据指定的天字符串算出昨天开始和昨天结束的时间，精确到秒
	 * 
	 * @param day 指定的天字符串 格式为：2020-01-01
	 * @return 算出昨天开始和昨天结束的时间
	 */
	public static Date[] getDatetimePreDayLimit(String day) {
		String startStr = day + " 00:00:00";
		Date start = new Date(DateUtil.parseDate(startStr).getTime() - 24 * 60 * 60 * 1000l);
		return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
	}
1
2
3
4
5
6
7
8
9
10
11

20、getDatetimePreMonthLimit(String monthStr) - 根据指定的月字符串算出上月月初和月未的时间，精确到秒

方法代码如下：

	/**
	 * 根据指定的月字符串算出上月月初和月未的时间，精确到秒
	 *
	 * @param monthStr 格式为:2020-01形式
	 * @return 上月月初和月未的时间
	 */
	public static Date[] getDatetimePreMonthLimit(String monthStr) {
		String start = monthStr + "-01 00:00:00";
		Date startTime = DateUtil.format(start);

		Calendar cal = Calendar.getInstance();
		cal.setTime(startTime);
		cal.add(Calendar.MONTH, -1);
		startTime = cal.getTime();

		cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE));
		Date endTime = new Date(cal.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		return new Date[] { startTime, endTime };
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

21、getDatetimePreSeasonLimit(int year, int nSeason) - 根据指定的年份和季度算出上一季度季度初和季度未的时间，精确到秒

方法代码如下：

	/**
	 * 根据指定的年份和季度 算出上一季度 季度初和季度未的时间，精确到秒
	 *
	 * @param year    年份
	 * @param nSeason 第几季度
	 * @return
	 */
	public static Date[] getDatetimePreSeasonLimit(int year, int nSeason) {
		if (nSeason == 1) {
			nSeason = 4;
			year = year - 1;
		} else {
			nSeason = nSeason - 1;
		}
		return getDatetimeSeasonLimit(year, nSeason);
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

22、getDatetimePreYearLimit(int year) - 根据指定的年份数据算出去年年初和年未的时间，精确到秒

方法代码如下：

	/**
	 * 根据指定的年份数据算出去年年初和年未的时间，精确到秒
	 *
	 * @param year 年份
	 * @return
	 */
	public static Date[] getDatetimePreYearLimit(int year) {
		return getDatetimeYearLimit(year - 1);
	}
1
2
3
4
5
6
7
8
9

23、getDatetimeSeasonLimit(int year, int nSeason) - 根据指定的年份和季度算出季度初和季度未的时间，精确到秒

方法代码如下：

	/**
	 * 根据指定的年份和季度 算出季度初和季度未的时间，精确到秒
	 *
	 * @param year    年份
	 * @param nSeason 第几季度
	 * @return 季度开始和结束时间
	 */
	public static Date[] getDatetimeSeasonLimit(int year, int nSeason) {
		Calendar c = Calendar.getInstance();
		Date[] season = new Date[2];
		c.set(year, Calendar.JANUARY, 1, 0, 0, 0);
		c.set(Calendar.MILLISECOND, 0);
		if (nSeason == 1) {// 第一季度
			c.set(Calendar.MONTH, Calendar.JANUARY);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.MARCH);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		} else if (nSeason == 2) {// 第二季度
			c.set(Calendar.MONTH, Calendar.APRIL);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.JUNE);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		} else if (nSeason == 3) {// 第三季度
			c.set(Calendar.MONTH, Calendar.JULY);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.SEPTEMBER);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		} else if (nSeason == 4) {// 第四季度
			c.set(Calendar.MONTH, Calendar.OCTOBER);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.DECEMBER);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		}

		return season;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

24、getDateTimeStr(Date date) - 取得指定时间的时间串，格式为 yyyy-MM-dd HH:mm:ss

方法代码如下：

	/**
	 * 取得指定时间的时间串，格式为 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param date 指定时间
	 * @return 格式化后时间字符串
	 */
	public static String getDateTimeStr(Date date) {
		if (date == null) {
			return getCurDateTimeStr();
		}
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
	}
1
2
3
4
5
6
7
8
9
10
11
12

25、getDatetimeYearLimit(int year) - 根据指定的年份数据算出年初和年未的时间，精确到秒

方法代码如下：

	/**
	 * 根据指定的年份数据算出年初和年未的时间，精确到秒
	 *
	 * @param year 年份
	 * @return
	 */
	public static Date[] getDatetimeYearLimit(int year) {
		Calendar c = Calendar.getInstance();
		Date[] res = new Date[2];
		c.set(Calendar.YEAR, year);
		c.set(Calendar.MONTH, Calendar.JANUARY);
		res[0] = clearDate(c.getTime(), 5).getTime();
		c.setTime(res[0]);
		c.set(Calendar.MONTH, Calendar.DECEMBER);
		c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
		res[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		return res;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

26、getDayAfter(Date date, int dayCnt) - 给定日期，得出该日期偏移多少天后的日期

方法代码如下：

	/**
	 * 给定日期，得出该日期偏移多少天后的日期
	 *
	 * @param date   给定日期
	 * @param dayCnt 偏移天数
	 * @return
	 */
	public static Date getDayAfter(Date date, int dayCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.DATE, dayCnt);
		return cal.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

27、getDayAfter(String dateStr, int dayCnt) - 给定的日期字符串，得出该日期字符串偏移多少天后的日期时间

方法代码如下：

	/**
	 * 给定的日期字符串，得出该日期字符串偏移多少天后的日期时间
	 *
	 * @param dateStr 日期字符串
	 * @param dayCnt  偏移天数
	 * @return 偏移后日期
	 */
	public static Date getDayAfter(String dateStr, int dayCnt) {
		return getDayAfter(parseDate(dateStr), dayCnt);
	}
1
2
3
4
5
6
7
8
9
10

28、getDayDiff(Date date, int dayCnt) - 根据传入的指定日期，给出该日期指定天数后的日期

方法代码如下：

	/**
	 * 根据传入的指定日期，给出该日期指定天数后的日期
	 *
	 * @param date   指定日期
	 * @param dayCnt 指定天数
	 * @return
	 */
	public static Date getDayDiff(Date date, int dayCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.DATE, dayCnt);
		return cal.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

29、getDayDiff(String dateStr, int dayCnt) - 根据传入的日期字符串，给出该日期指定天数后的日期实际就是日期相加减

方法代码如下：

	/**
	 * 根据传入的日期字符串，给出该日期指定天数后的日期 实际就是日期相加减
	 *
	 * @param dateStr 日期字符串
	 * @param dayCnt  指定天数
	 * @return
	 */
	public static Date getDayDiff(String dateStr, int dayCnt) {
		return getDayDiff(parseDate(dateStr), dayCnt);
	}
1
2
3
4
5
6
7
8
9
10

30、getDayHourAfter(Date date, int hourCnt) - 指定日期偏移指定小时后的日期

方法代码如下：

	/**
	 * 指定日期偏移指定小时后的日期
	 *
	 * @param date    指定日期时间
	 * @param hourCnt 指定小时数
	 * @return 偏移后时间
	 */
	public static Date getDayHourAfter(Date date, int hourCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.HOUR, hourCnt);
		return cal.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

31、getDayListAfter(Date date, int dayCnt) - 取得指定日期多少天后所有日期的集合不包含指定日期的时间

方法代码如下：

	/**
	 * 取得指定日期多少天后所有日期的集合 不 包含指定日期的时间
	 * 
	 * 比如 输入 20210225 2 输出：[Fri Feb 26 16:04:06 CST 2021, Sat Feb 27 16:04:06 CST
	 * 2021]
	 *
	 * @param date   指定日期
	 * @param dayCnt 指定天数
	 * @return 日期集合
	 */
	public static List<Date> getDayListAfter(Date date, int dayCnt) {
		List<Date> list = new ArrayList<Date>();
		GregorianCalendar cal = new GregorianCalendar();
		for (int i = 1; i <= dayCnt; i++) {
			cal.setTime(date);
			cal.add(Calendar.DATE, i);
			list.add(cal.getTime());
		}
		return list;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

32、getDaysBetween(Date startDate, Date endDate) - 算出俩个时间，所间隔的多少天

方法代码如下：

	/**
	 * 算出俩个时间，所间隔的多少天
	 * 
	 * @param startDate
	 * @param endDate
	 * @return
	 */
	public static Long getDaysBetween(Date startDate, Date endDate) {
		Calendar fromCalendar = Calendar.getInstance();
		fromCalendar.setTime(startDate);
		fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
		fromCalendar.set(Calendar.MINUTE, 0);
		fromCalendar.set(Calendar.SECOND, 0);
		fromCalendar.set(Calendar.MILLISECOND, 0);

		Calendar toCalendar = Calendar.getInstance();
		toCalendar.setTime(endDate);
		toCalendar.set(Calendar.HOUR_OF_DAY, 0);
		toCalendar.set(Calendar.MINUTE, 0);
		toCalendar.set(Calendar.SECOND, 0);
		toCalendar.set(Calendar.MILLISECOND, 0);

		return (toCalendar.getTime().getTime() - fromCalendar.getTime().getTime()) / (1000 * 60 * 60 * 24);
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

33、getDaysBetweenmm(String startDate, String endDate) - 两个时间相差多少天多少小时多少分多少秒

方法代码如下：

	/**
	 * 两个时间相差多少天多少小时多少分多少秒
	 *
	 * @param startDate 时间参数 1 格式：1990-01-01 12:00:00
	 * @param endDate   时间参数 2 格式：2009-01-01 12:00:00
	 * @return long[] 返回值为：{天, 时, 分, 秒}
	 */
	public static long[] getDaysBetweenmm(String startDate, String endDate) {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date one;
		Date two;
		long day = 0;
		long hour = 0;
		long min = 0;
		long sec = 0;
		try {
			one = df.parse(startDate);
			two = df.parse(endDate);
			long time1 = one.getTime();
			long time2 = two.getTime();
			long diff;
			if (time1 < time2) {
				diff = time2 - time1;
			} else {
				diff = time1 - time2;
			}
			day = diff / (24 * 60 * 60 * 1000);
			hour = (diff / (60 * 60 * 1000) - day * 24);
			min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
			sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		long[] times = { day, hour, min, sec };
		return times;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

34、getEnd7Days() - 取得前7天结束时间包含今天比如 20210303 返回 20210225 23:59:59

方法代码如下：

	/**
	 * 取得前7天结束时间 包含今天 比如 20210303 返回 20210225 23:59:59
	 * 
	 * @param date
	 * @return
	 */
	public static Date getEnd7Days() {

		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.DAY_OF_YEAR, -5);
		tempEnd.add(Calendar.SECOND, -1);
		Date time = tempEnd.getTime();

		return time;

	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

35、getEndToday() - 取得今天23:59:59秒时间

方法代码如下：

	/**
	 * 取得今天23:59:59秒时间
	 * 
	 * @param date
	 * @return
	 */
	public static Date getEndToday() {
		Calendar todayEnd = Calendar.getInstance();
		todayEnd.set(Calendar.HOUR_OF_DAY, 23);
		todayEnd.set(Calendar.MINUTE, 59);
		todayEnd.set(Calendar.SECOND, 59);
		todayEnd.set(Calendar.MILLISECOND, 999);
		return todayEnd.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

36、getEndYestday() - 取得昨天结束时间 23:59:59

方法代码如下：

	/**
	 * 取得昨天结束时间 23:59:59
	 * 
	 * @param date
	 * @return
	 */
	public static Date getEndYestday() {

		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.SECOND, -1);
		Date time = tempEnd.getTime();
		return time;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

37、getFirstDayOfWeek(Date date) - 取得指定日期所在周的第一天此处认为星期一是一周的第一天时间是00:00:00

方法代码如下：

	/**
	 * 取得指定日期所在周的第一天 此处认为星期一是一周的第一天 时间是00:00:00
	 *
	 * @param date
	 * @return
	 */
	public static Date getFirstDayOfWeek(Date date) {
		Calendar c = clearDate(date, 4);
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
		return c.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12

38、getIntervalOfDays(Date fDate, Date oDate) - 获取两个日期相隔天数去掉时分秒，直接比对日

方法代码如下：

	/**
	 * 获取两个日期相隔天数 去掉时分秒，直接比对日
	 *
	 * @param fDate 开始时间
	 * @param oDate 结束时间
	 * @return 返回相差几天
	 */
	public static int getIntervalOfDays(Date fDate, Date oDate) {
		if (null == fDate || null == oDate) {
			return -1;
		}
		fDate = DateUtil.clearDate(fDate, 4).getTime();
		oDate = DateUtil.clearDate(oDate, 4).getTime();
		long intervalMilli = oDate.getTime() - fDate.getTime();
		return (int) (intervalMilli / (24 * 60 * 60 * 1000));
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

39、getLastDayOfWeek(Date date) - 取得指定日期所在周的最后一天此处认为星期日是最后一天时间到23:59:59 示例：输入：20210225 返回：Sun Feb 28

方法代码如下：

	/**
	 * 取得指定日期所在周的最后一天 此处认为星期日是最后一天 时间到23:59:59 示例： 输入：20210225 返回：Sun Feb 28
	 * 23:59:59 CST 2021
	 * 
	 *
	 * @param date
	 * @return
	 */
	public static Date getLastDayOfWeek(Date date) {
		Calendar c = clearDate(date, 4);
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		c.set(Calendar.MILLISECOND, 000);
		return c.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

40、getMaxWeekOfYear(int year) - 根据传入的年份，给出该年的最大周

方法代码如下：

	/**
	 * 根据传入的年份，给出该年的最大周
	 * 
	 * @param year
	 * @return
	 */
	public static int getMaxWeekOfYear(int year) {
		Calendar c = new GregorianCalendar();
		c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
		return getWeekOfYear(c.getTime());
	}
1
2
3
4
5
6
7
8
9
10
11

41、getMongoDate(Date date) - 取得指定日期 23:59:59的时间解析失败返回当前时间

方法代码如下：

	/**
	 * 取得指定日期 23:59:59的时间 解析失败返回当前时间
	 * 
	 * @param date 指定日期
	 * @return 指定日期 23:59:59的时间
	 */
	public static Date getMongoDate(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Calendar ca = Calendar.getInstance();
		ca.setTime(date);
		ca.set(Calendar.HOUR_OF_DAY, 23);
		ca.set(Calendar.MINUTE, 59);
		ca.set(Calendar.SECOND, 59);
		ca.set(Calendar.MILLISECOND, 999);
		try {
			return sdf.parse(sdf.format(ca.getTime()));
		} catch (ParseException e) {
			System.out.println("日期解析错误......");
		}
		return new Date();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

42、getMonth(Date date) - 获取指定时间的月份数据

方法代码如下：

	/**
	 * 获取指定时间的月份数据
	 * 
	 * @param date 指定时间
	 * @return 月份数据
	 */
	public static int getMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.MONTH) + 1;
	}
1
2
3
4
5
6
7
8
9
10
11

43、getMonthAfter(Date date, int monthCnt) - 取得后多少月的时间

方法代码如下：

	/**
	 * 取得后多少月的时间
	 *
	 * @param date
	 * @param monthCnt
	 * @return
	 */
	public static Date getMonthAfter(Date date, int monthCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.MONTH, monthCnt);
		return cal.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

44、getMonthEnd() - 获取本月最后一天

方法代码如下：

	/**
	 * 获取本月最后一天
	 * 
	 * @return String
	 **/
	public static String getMonthEnd() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 23:59:59";
	}
1
2
3
4
5
6
7
8
9
10
11

45、getMonthLimit(Date date) - 取得指定日期的当月起始时间从00:00:00开始到23:59:59 为止

方法代码如下：

	/**
	 * 取得指定日期的当月起始时间 从00:00:00开始 到23:59:59 为止
	 * 
	 * 示例 输入 20210225 输出 Mon Feb 01 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
	 *
	 * @param date 指定日期时间
	 * @return
	 */
	public static Date[] getMonthLimit(Date date) {
		Calendar cal = clearDate(date, 5);
		Date date1 = cal.getTime();

		cal.add(Calendar.MONTH, 1);
		cal.add(Calendar.SECOND, -1);
		Date date2 = cal.getTime();

		return new Date[] { date1, date2 };
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

46、getMonthLimitStr(Date date) - 取得指定日期当月的起始时间字符串格式是：yyyy-MM-dd HH:mm:ss

方法代码如下：

	/**
	 * 取得指定日期当月的起始时间字符串 格式是：yyyy-MM-dd HH:mm:ss
	 *
	 * @param date
	 * @return
	 */
	public static String[] getMonthLimitStr(Date date) {
		Date[] rtDateArray = getMonthLimit(date);
		return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
	}
1
2
3
4
5
6
7
8
9
10

47、getMonthStart() - 获取本月开始日期

方法代码如下：

	/**
	 * 获取本月开始日期
	 * 
	 * @return String
	 **/
	public static String getMonthStart() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MONTH, 0);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 00:00:00";
	}
1
2
3
4
5
6
7
8
9
10
11
12

48、getNeedTime(int hour, int minute, int second, int day) - 传入天、时、份、秒获取当月指定天数后的指定时间

方法代码如下：

	/**
	 * 
	 * 传入天、时、份、秒 获取当月指定天数后的指定时间
	 * 
	 * @param hour   小时数
	 * @param minute 分钟数
	 * @param second 秒钟数
	 * @param day    指定天数后
	 * @return 指定时间
	 */
	public static Date getNeedTime(int hour, int minute, int second, int day) {
		Calendar calendar = Calendar.getInstance();
		if (day != 0) {
			calendar.add(Calendar.DATE, day);
		}
		calendar.set(Calendar.HOUR_OF_DAY, hour);
		calendar.set(Calendar.MINUTE, minute);
		calendar.set(Calendar.SECOND, second);

		return calendar.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

49、getNextDay(Date date, int number) - 日期相加减

方法代码如下：

	/**
	 * 日期相加减
	 *
	 * @param date
	 * @param number 天数数量
	 * @return
	 */
	public static Date getNextDay(Date date, int number) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, number);// +1今天的时间加一天
		date = calendar.getTime();
		return date;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

50、getNow() - 获取现在的日期时间

方法代码如下：

	/**
	 * 获取现在的日期时间
	 * 
	 * @return String
	 */
	public static String getNow() {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
	}
1
2
3
4
5
6
7
8

51、getNowAllString() - 获取现在的日期时间(详细到毫秒)

方法代码如下：

public static String getNowAllString() {
		return new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E").format(new Date());
	}
1
2
3

52、getSeason(Date date) - 根据传入的日期，判断日期是第几季度 1 第一季度 2 第二季度 3 第三季度 4 第四季度

方法代码如下：

	/**
	 * 
	 * 根据传入的日期，判断日期是第几季度 1 第一季度 2 第二季度 3 第三季度 4 第四季度
	 *
	 * @param date 传入的日期
	 * @return 季度数
	 */
	public static int getSeason(Date date) {

		int season = 0;

		Calendar c = Calendar.getInstance();
		c.setTime(date);
		int month = c.get(Calendar.MONTH);
		switch (month) {
		case Calendar.JANUARY:
		case Calendar.FEBRUARY:
		case Calendar.MARCH:
			season = 1;
			break;
		case Calendar.APRIL:
		case Calendar.MAY:
		case Calendar.JUNE:
			season = 2;
			break;
		case Calendar.JULY:
		case Calendar.AUGUST:
		case Calendar.SEPTEMBER:
			season = 3;
			break;
		case Calendar.OCTOBER:
		case Calendar.NOVEMBER:
		case Calendar.DECEMBER:
			season = 4;
			break;
		default:
			break;
		}
		return season;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

53、getSecondAfter(Date date, int secondCnt) - 给定日期，设置偏移多少秒后日期

方法代码如下：

	/**
	 * 给定日期，设置偏移多少秒后日期
	 *
	 * @param date      给定的日期
	 * @param secondCnt 偏移秒数
	 * @return 具体偏移后日期
	 */
	public static Date getSecondAfter(Date date, int secondCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.SECOND, secondCnt);
		return cal.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

54、getSimpleDateFormatPattern(String dateStr) - 根据传入的日期解析出该用何种SimpleDateFormat并返回对应的SimpleDateFormat

方法代码如下：

	/**
	 * 根据传入的日期 解析出 该用何种SimpleDateFormat并返回对应的SimpleDateFormat
	 *
	 * @param dateStr 传入的日期字符串
	 * @return
	 */
	public static SimpleDateFormat getSimpleDateFormatPattern(String dateStr) {
		SimpleDateFormat format = null;
		if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
			format = new SimpleDateFormat("yyyy-MM-dd");
		} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
			format = new SimpleDateFormat("yyyyMMdd");
		} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
		} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
		} else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
			format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
		} else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
			format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
		} else if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}", dateStr)) {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		} else if (dateStr.length() > 20) {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		} else {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		}
		return format;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

55、getStartAndEndDate(int year, int weeknum) - 返回值说明:返回一个Calendar数组，长度为2 分别是开始日期和结束日期星期一作为一周的开始第一周是完整周不完整的几天算去年最后一周

方法代码如下：

	/**
	 * 
	 * 返回值说明:返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始 第一周是完整周 不完整的几天算去年最后一周
	 *
	 * @param year    年分 例如 2014
	 * @param weeknum 第几周 例如33
	 * @return
	 * 
	 */
	public static Calendar[] getStartAndEndDate(int year, int weeknum) {

		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, year);
		cal.set(Calendar.WEEK_OF_YEAR, weeknum);
		cal.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
		cal.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		Calendar end = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, end };
		return darr;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

56、getStartAndEndOfWeekByDate(Date date) - 获取指定日期的一周开始至结束日期返回一个Calendar数组，长度为7 星期一作为一周的开始

方法代码如下：

	/**
	 * 获取指定日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
	 * 
	 * @param date 指定日期
	 * @return
	 */
	public static Calendar[] getStartAndEndOfWeekByDate(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		// 向后推一天（从星期一到周末）
		cal.add(Calendar.DATE, -1);
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		Calendar tuesday = (Calendar) cal.clone();// 周二
		tuesday.add(Calendar.DATE, 2 - nw + 1);
		Calendar wednesday = (Calendar) cal.clone();// 周三
		wednesday.add(Calendar.DATE, 3 - nw + 1);
		Calendar thursday = (Calendar) cal.clone();// 周四
		thursday.add(Calendar.DATE, 4 - nw + 1);
		Calendar friday = (Calendar) cal.clone();// 周五
		friday.add(Calendar.DATE, 5 - nw + 1);
		Calendar saturday = (Calendar) cal.clone();// 周六
		saturday.add(Calendar.DATE, 6 - nw + 1);
		Calendar end = (Calendar) cal.clone();
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
		return darr;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

57、getStartToday() - 取得今天开始时间 00:00:00

方法代码如下：

	/**
	 * 取得今天开始时间 00:00:00
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStartToday() {

		Calendar todayStart = Calendar.getInstance();
		todayStart.set(Calendar.HOUR_OF_DAY, 0);
		todayStart.set(Calendar.MINUTE, 0);
		todayStart.set(Calendar.SECOND, 0);
		todayStart.set(Calendar.MILLISECOND, 0);
		return todayStart.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

58、getStatus30Days() - 取得前30天的开始时间包含今天比如 20210304 返回 20210203 00:00:00

方法代码如下：

	/**
	 * 取得前30天的开始时间 包含今天 比如 20210304 返回 20210203 00:00:00
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStatus30Days() {
		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.DAY_OF_YEAR, -29);
		Date time = tempEnd.getTime();

		return time;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

59、getStatus7Days() - 取得前7天开始时间包含今天比如 20210303 返回 20210225 00:00:00

方法代码如下：

	/**
	 * 取得前7天开始时间 包含今天 比如 20210303 返回 20210225 00:00:00
	 * 
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStatus7Days() {

		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.DAY_OF_YEAR, -6);
		Date time = tempEnd.getTime();

		return time;

	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

60、getStatusYestday() - 取得昨天的开始时间 00:00:00

方法代码如下：

	/**
	 * 取得昨天的开始时间 00:00:00
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStatusYestday() {

		Calendar tempStart = Calendar.getInstance();
		Date start = new Date();

		tempStart.setTime(start);
		tempStart.set(Calendar.HOUR_OF_DAY, 0);
		tempStart.set(Calendar.MINUTE, 0);
		tempStart.set(Calendar.SECOND, 0);
		tempStart.set(Calendar.MILLISECOND, 0);
		tempStart.add(Calendar.DAY_OF_YEAR, -1);
		Date time = tempStart.getTime();

		return time;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

61、getTimeByMinute(Date date, int minute) - 获取指定时间几分钟后的时间字符串

方法代码如下：

	/**
	 * 获取指定时间几分钟后的时间字符串
	 * 
	 * @param date   指定时间
	 * @param minute 几分钟后数据
	 * @return
	 */
	public static String getTimeByMinute(Date date, int minute) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.MINUTE, minute);
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());

	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

62、getTimeMilisecondDesc(long milliSeconds) - 根据传入的long数据给出这个数据有几天，几小时，几分和几秒

方法代码如下：

	/**
	 * 根据传入的long数据给出这个数据有几天，几小时，几分和几秒
	 * 
	 * 示例 输入 343039300 返回 3天23小时17分钟19秒
	 *
	 * @param milliSeconds long形数据
	 * @return
	 */
	public static String getTimeMilisecondDesc(long milliSeconds) {
		long days = milliSeconds / (1000 * 60 * 60 * 24);
		milliSeconds = milliSeconds - (days * 24 * 60 * 60 * 1000);
		long hours = milliSeconds / (1000 * 60 * 60);
		milliSeconds = milliSeconds - (hours * 60 * 60 * 1000);
		long minutes = milliSeconds / (1000 * 60);
		milliSeconds = milliSeconds - (minutes * 60 * 1000);
		long seconds = milliSeconds / (1000);

		StringBuffer sb = new StringBuffer();
		if (days != 0) {
			sb.append(days + "天");
		}
		if (hours != 0) {
			sb.append(hours + "小时");
		}
		if (minutes != 0) {
			sb.append(minutes + "分钟");
		}
		if (seconds != 0) {
			sb.append(seconds + "秒");
		}
		return sb.toString();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

63、getToday() - 获取今天的字符串，格式：“yyyy-MM-dd”

方法代码如下：

/**
	 * 获取今天
	 * 
	 * @return String
	 */
	public static String getToday() {
		return new SimpleDateFormat("yyyy-MM-dd").format(new Date());
	}
1
2
3
4
5
6
7
8

64、getWeek(Date date) - 输入指定日期，给出该日期为星期几的字符串说明

方法代码如下：

	/**
	 * 输入指定日期，给出该日期为星期几的字符串说明
	 * 
	 * @param date
	 * @return
	 */
	public static String getWeek(Date date) {
		String[] weeks = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
		if (week_index < 0) {
			week_index = 0;
		}
		return weeks[week_index];
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

65、getWeekEnd() - 获取本周的最后一天

方法代码如下：

	/**
	 * 获取本周的最后一天
	 * 
	 * @return String
	 **/
	public static String getWeekEnd() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_WEEK, cal.getActualMaximum(Calendar.DAY_OF_WEEK));
		cal.add(Calendar.DAY_OF_WEEK, 1);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 23:59:59";
	}
1
2
3
4
5
6
7
8
9
10
11
12

66、getWeekLimit(Date date) - 取得指定日期所在周的起始时间开始时间从00:00:00 结束时间是 23:59:59 此处认为星期一是一周第一天星期日是一周最后一天

方法代码如下：

	/**
	 * 取得指定日期所在周的起始时间 开始时间从00:00:00 结束时间是 23:59:59 此处认为星期一是一周第一天 星期日是一周最后一天 示例 传入
	 * 20210225 返回 Mon Feb 22 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
	 * 
	 * 
	 * @param date 传入的日期
	 *
	 * 
	 * @return
	 */
	public static Date[] getWeekLimit(Date date) {
		Date date1 = getFirstDayOfWeek(date);
		Date date2 = getLastDayOfWeek(date);
		return new Date[] { date1, date2 };
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

67、getWeekOfYear(Date date) - 获取指定日期当前周

方法代码如下：

	/**
	 * 获取指定日期当前周
	 *
	 * @param date
	 * @return
	 */
	public static int getWeekOfYear(Date date) {
		Calendar c = new GregorianCalendar();
		c.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
		c.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
		c.setTime(date);
		return c.get(Calendar.WEEK_OF_YEAR);
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

68、getWeekStart() - 获取本周的第一天

方法代码如下：

	/**
	 * 获取本周的第一天
	 * 
	 * @return String
	 **/
	public static String getWeekStart() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.WEEK_OF_MONTH, 0);
		cal.set(Calendar.DAY_OF_WEEK, 2);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 00:00:00";
	}
1
2
3
4
5
6
7
8
9
10
11
12

69、getYear(Date date) - 获取指定时间的年份数据

方法代码如下：

	/**
	 * 获取指定时间的年份数据
	 * 
	 * @param date
	 * @return
	 */
	public static int getYear(Date date) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		return now.get(Calendar.YEAR);
	}
1
2
3
4
5
6
7
8
9
10
11

70、getYearAfter(Date date, int yearCnt) - 取得后多少年的时间

方法代码如下：

	/**
	 * 取得后多少年的时间
	 *
	 * @param date
	 * @return
	 */
	public static Date getYearAfter(Date date, int yearCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.YEAR, yearCnt);
		return cal.getTime();
	}
1
2
3
4
5
6
7
8
9
10
11
12

71、getYearEnd() - 获取本年的最后一天

方法代码如下：

	/**
	 * 获取本年的最后一天
	 * 
	 * @return String
	 **/
	public static String getYearEnd() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.MONTH, calendar.getActualMaximum(Calendar.MONTH));
		calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
		Date currYearLast = calendar.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(currYearLast) + " 23:59:59";
	}
1
2
3
4
5
6
7
8
9
10
11
12

72、getYearLimit(Date date) - 取得指定日期的当年起始时间从00:00:00开始到23:59:59 为止

方法代码如下：

	/**
	 * 取得指定日期的当年起始时间 从00:00:00开始 到23:59:59 为止
	 * 
	 * 示例：输入：20210225 输出：Fri Jan 01 00:00:00 CST 2021 Fri Dec 31 23:59:59 CST 2021
	 *
	 * @param date 指定日期时间
	 * @return
	 */
	public static Date[] getYearLimit(Date date) {
		Calendar cal = clearDate(date, 6);
		Date date1 = cal.getTime();

		cal.add(Calendar.YEAR, 1);
		cal.add(Calendar.SECOND, -1);
		Date date2 = cal.getTime();

		return new Date[] { date1, date2 };
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

73、getYearLimitStr(Date date) - 取得指定日期当年的起始时间串格式是：yyyy-MM-dd HH:mm:ss

方法代码如下：

	/**
	 * 取得指定日期当年的起始时间串 格式是：yyyy-MM-dd HH:mm:ss
	 * 
	 * @param date
	 * @return
	 */
	public static String[] getYearLimitStr(Date date) {
		Date[] rtDateArray = getYearLimit(date);
		return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
	}
1
2
3
4
5
6
7
8
9
10

74、getYearStart() - 获取本年的第一天

方法代码如下：

	/**
	 * 获取本年的第一天
	 * 
	 * @return String
	 **/
	public static String getYearStart() {
		return new SimpleDateFormat("yyyy").format(new Date()) + "-01-01";
	}
1
2
3
4
5
6
7
8

75、getYestdayStr(Date date) - 取得指定日期前一天的时间字符串字符串格式为：yyyy-MM-dd HH:mm:ss

方法代码如下：

	/**
	 * 取得指定日期 前一天的时间字符串 字符串格式为：yyyy-MM-dd HH:mm:ss
	 *
	 * @param date
	 * @return
	 */
	public static String getYestdayStr(Date date) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.DATE, -1);
		return getDateTimeStr(cal.getTime());
	}
1
2
3
4
5
6
7
8
9
10
11
12

76、getYestdayStr(String dateStr) - 根据传入的日期字符串取得前一天的时间字符串例如：传入 20200102 返回 2020-01-01 00:00:00

方法代码如下：

	/**
	 * 根据传入的日期字符串取得前一天的时间字符串 例如：传入 20200102 返回 2020-01-01 00:00:00 传入2020-01-02
	 * 10:23:43 返回2020-01-01 10:23:43 字符串格式为：yyyy-MM-dd HH:mm:ss
	 *
	 * @param dateStr
	 * @return
	 */
	public static String getYestdayStr(String dateStr) {
		return getYestdayStr(parseDate(dateStr));
	}
1
2
3
4
5
6
7
8
9
10

77、getYestoday() - 获取昨天的字符串格式为"yyyy-MM-dd"

方法代码如下：

	/**
	 * 获取昨天
	 * 
	 * @return String
	 */
	public static String getYestoday() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DATE, -1);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time);
	}
1
2
3
4
5
6
7
8
9
10
11

78、getYMDDate(Date date, String format) - 获取指定时间根据格式化方式获取的各组成部分

方法代码如下：

	/**
	 * 获取指定时间根据格式化方式获取的各组成部分
	 * 
	 *
	 * @param date   指定时间
	 * @param format 获取的部分 yyyy 年份 MM 月份 dd 日
	 * @return
	 */
	public static int getYMDDate(Date date, String format) {
		SimpleDateFormat sdf = null;
		try {
			if (format != null && format.length() > 0) {
				if ("yyyy".equals(format)) {
					sdf = new SimpleDateFormat("yyyy");
					String formatY = sdf.format(date);
					return Integer.parseInt(formatY);
				} else if ("MM".equals(format)) {
					sdf = new SimpleDateFormat("MM");
					String formatY = sdf.format(date);
					return Integer.parseInt(formatY);
				} else if ("dd".equals(format)) {
					sdf = new SimpleDateFormat("dd");
					String formatY = sdf.format(date);
					return Integer.parseInt(formatY);
				}

			}
			return 0;
		} catch (Exception e) {
			return 0;
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

79、parseCalendar(String dateStr) - 根据传入的字符串将字符串转化为Calendar时间

方法代码如下：

	/**
	 * 
	 * 根据传入的字符串将字符串转化为Calendar时间
	 * 
	 * @param dateStr 传入的时间字符串
	 * @return
	 */
	public static Calendar parseCalendar(String dateStr) {
		Calendar c = Calendar.getInstance();
		try {
			c.setTime(parseDateByPattern(dateStr));
		} catch (Exception e) {
			return null;
		}
		return c;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

80、parseCalendar(String formatStr, String dateStr) - 根据传入的字符串和字符串格式化类型将字符串转化为Calendar时间

方法代码如下：

	/**
	 * 根据传入的字符串和字符串格式化类型将字符串转化为Calendar时间
	 * 
	 * @param formatStr 格式化形式
	 * @param dateStr   日期字符串
	 * @return
	 */
	public static Calendar parseCalendar(String formatStr, String dateStr) {
		Calendar c = Calendar.getInstance();
		try {
			c.setTime(parseDate(formatStr, dateStr));
		} catch (Exception e) {
			return null;
		}
		return c;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

81、parseDate(String dateStr) - 把指定字符串转化为Date

方法代码如下：

	/**
	 * 把指定字符串转化为Date
	 *
	 * @param dateStr 指定的字符串
	 * @return
	 */
	public static Date parseDate(String dateStr) {
		if (dateStr == null || "".equals(dateStr)) {
			return null;
		}

		SimpleDateFormat format = null;
		if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
			format = new SimpleDateFormat("yyyy-MM-dd");
		} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
			format = new SimpleDateFormat("yyyyMMdd");
		} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
		} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
		} else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
			format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
		} else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
			format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
		} else if (dateStr.length() > 20) {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
		} else {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		}

		try {
			return format.parse(dateStr);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

82、parseDate(String formatStr, String dateStr) - 根据传入的字符串和字符串格式化类型将字符串转化为Date时间

方法代码如下：

	/**
	 * 根据传入的字符串和字符串格式化类型将字符串转化为Date时间
	 *
	 * @param dateStr   日期字符串
	 * @param formatStr 格式化形式
	 * @return
	 */
	public static Date parseDate(String formatStr, String dateStr) throws ParseException {
		SimpleDateFormat format = new SimpleDateFormat(formatStr);
		return format.parse(dateStr);
	}
1
2
3
4
5
6
7
8
9
10
11

83、parseDateByPattern(String dateStr) - 根据传入的日期字符串自动转化为Date类型的时间不需要自己输入格式化方式字符串

方法代码如下：

	/**
	 * 根据传入的日期字符串自动转化为Date类型的时间 不需要自己输入格式化方式字符串
	 *
	 * @param dateStr @return @throws
	 * 
	 */
	public static Date parseDateByPattern(String dateStr) {
		SimpleDateFormat format = null;
		try {
			if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd");
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}/\\d{2}/\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy/MM/dd");
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyyMMdd");
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
				format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
				format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}/\\d{1,2}/\\d{1,2} \\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy/M/d HH:mm", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}\\.\\d{2}\\.\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy.MM.dd", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}年\\d{2}月", dateStr)) {
				format = new SimpleDateFormat("yyyy年MM月", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SS", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{1}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("HH:mm", Locale.CHINA);
				return format.parse(dateStr);
			}
		} catch (Exception e) {
			System.out.println("日期字符串：<<" + dateStr + ">>转换为Date失败......");
		}
		return null;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

84、parseOriTime(String str) - 将 Date原始格式"EEE MMM dd HH:mm:ss Z yyyy"转成指定格式 “yyyy-MM-dd HH:mm:ss”

方法代码如下：

	/**
	 * 将 Date原始格式"EEE MMM dd HH:mm:ss Z yyyy"转成指定格式 "yyyy-MM-dd HH:mm:ss"
	 * 
	 * @param str 待解析字符串 一般是执行Date的toString方法获得
	 * @return 返回的字符串 yyyy-MM-dd HH:mm:ss格式
	 */
	public static String parseOriTime(String str) {
		String sDate = "";
		SimpleDateFormat sdf1 = new SimpleDateFormat("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			Date date = sdf1.parse(str);
			sDate = sdf.format(date);
		} catch (Exception e) {
			System.out.println("日期转换失败:" + str);
		}
		return sDate;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

85、transFinalFormationStringDate(String date) - 根据指定规则输出指定日期字符串的中文表示

方法代码如下：

	/**
	 * 
	 * 根据指定规则输出指定日期字符串的中文表示 接收日期格式字符转化为中文+日期格式 规则： 刚刚（5分钟前） ①如果开课时间为当天的日期，显示“今天+时+分”
	 * ②如果开课时间为昨天的日期，显示“昨天+时+分” ③如果开课时间为前天的日期，显示“前天+时+分” ④如果开课时间为明天的日期，显示“明天+时+分”
	 * ⑤如果开课时间为后天的日期，显示“后天+时+分” ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分” ⑦其余日期均显示“月-日 时：分”
	 * ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
	 *
	 * @param date 指定日期字符串 格式为：yyyy-MM-dd HH:mm:ss
	 * @return 指定日期字符串的中文表示
	 */
	public static String transFinalFormationStringDate(String date) {
		long[] daysBetweenmm = getDaysBetweenmm(date, format(new Date()));
		if (daysBetweenmm[0] == 0 && daysBetweenmm[1] == 0 && daysBetweenmm[2] < 6) {
			return "刚刚";
		}
		return transFormationStringDate(date);
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

86、transFormationStringDate(String date) - 接收日期格式字符

方法代码如下：

	/**
	 * 
	 * @param date
	 * @return
	 */
	public static String transFormationStringDate(String date) {
		Date now = new Date();
		SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return transFormationStringDate(date, now, sss.format(now));

	}
1
2
3
4
5
6
7
8
9
10
11

87、transFormationStringDate(String date, Date newDate, String newDateStr) - 接收日期格式字符转化为中文+日期格式

方法代码如下：

	/**
	 * 接收日期格式字符转化为中文+日期格式 规则：①如果开课时间为当天的日期，显示“今天+时+分” ②如果开课时间为昨天的日期，显示“昨天+时+分”
	 * ③如果开课时间为前天的日期，显示“前天+时+分” ④如果开课时间为明天的日期，显示“明天+时+分” ⑤如果开课时间为后天的日期，显示“后天+时+分”
	 * ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分” ⑦其余日期均显示“月-日 时：分” ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
	 *
	 * @param date
	 * @return
	 */
	public static String transFormationStringDate(String date, Date newDate, String newDateStr) {
		SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			String yyyyStr = date.substring(0, 4);
			String mmStr = date.substring(5, 7);
			String ddStr = date.substring(8, 10);

			String hhStr = date.substring(11, 13);
			String MMStr = date.substring(14, 16);
			String ssStr = date.substring(17, 19);

			int yyyy = Integer.parseInt(yyyyStr);
			int mm = Integer.parseInt(mmStr);
			int dd = Integer.parseInt(ddStr);

			int hh = Integer.parseInt(hhStr);
			int MM = Integer.parseInt(MMStr);
			int ss = Integer.parseInt(ssStr);

			int yyyy1 = Integer.parseInt(newDateStr.substring(0, 4));
			int mm1 = Integer.parseInt(newDateStr.substring(5, 7));
			int dd1 = Integer.parseInt(newDateStr.substring(8, 10));

			if (yyyy != yyyy1) {// 如果开课时间不是当前年，显示“年-月-日 时：分”
				return yyyyStr + "-" + mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
			}
			if (mm == mm1 && dd == dd1) {// 如果开课时间为当天的日期，显示“今天+时+
				return "今天" + " " + hhStr + ":" + MMStr;
			}
			Date allDate = sss.parse(date);
			Long daysBetween = getDaysBetween(newDate, allDate);
			if (daysBetween == -1) {// 如果开课时间为昨天的日期，显示“昨天+时+分”
				return "昨天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween == -2) {// 如果开课时间为前天的日期，显示“前天+时+分”
				return "前天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween == 1) {// 如果开课时间为明天的日期，显示“明天+时+分”
				return "明天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween == 2) {// 如果开课时间为后天的日期，显示“后天+时+分”
				return "后天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween > 2 || daysBetween < -2) {// 如果开课时间超出后天
				Date firstDayOfWeek1 = getFirstDayOfWeek(newDate);// 当前日期所在周的第一天
				Date firstDayOfWeek2 = getFirstDayOfWeek(allDate);// 传入日期所在周的第一天
				if (firstDayOfWeek1.getTime() == firstDayOfWeek2.getTime()) {// 并且还在当前周内，显示“本周X+时+分”
					Long ad = getDaysBetween(firstDayOfWeek1, allDate);
					switch (ad.intValue()) {
					case 0:
						return "本周一" + " " + hhStr + ":" + MMStr;
					case 1:
						return "本周二" + " " + hhStr + ":" + MMStr;
					case 2:
						return "本周三" + " " + hhStr + ":" + MMStr;
					case 3:
						return "本周四" + " " + hhStr + ":" + MMStr;
					case 4:
						return "本周五" + " " + hhStr + ":" + MMStr;
					case 5:
						return "本周六" + " " + hhStr + ":" + MMStr;
					case 6:
						return "本周日" + " " + hhStr + ":" + MMStr;
					}
				}
			}
			// 其余日期均显示“月-日 时：分”
			return mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
			// format(allDate,"MM-dd HH:mm");
		} catch (Exception e) {
			return "日期格式字符转化错误";
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

三、Java中的日期转化格式DateUtil工具类 - 完整的 DateUtil.java 代码

日期工具类：DateUtil.java

package com.tzq.util;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Locale;
import java.util.regex.Pattern;

/**
 * 日期工具类
 */
public class DateUtil {

	/**
	 * 获取今天
	 * 
	 * @return String
	 */
	public static String getToday() {
		return new SimpleDateFormat("yyyy-MM-dd").format(new Date());
	}

	/**
	 * 获取昨天
	 * 
	 * @return String
	 */
	public static String getYestoday() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DATE, -1);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time);
	}

	/**
	 * 获取本月开始日期
	 * 
	 * @return String
	 **/
	public static String getMonthStart() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MONTH, 0);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 00:00:00";
	}

	/**
	 * 获取本月最后一天
	 * 
	 * @return String
	 **/
	public static String getMonthEnd() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 23:59:59";
	}

	/**
	 * 获取本周的第一天
	 * 
	 * @return String
	 **/
	public static String getWeekStart() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.WEEK_OF_MONTH, 0);
		cal.set(Calendar.DAY_OF_WEEK, 2);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 00:00:00";
	}

	/**
	 * 获取本周的最后一天
	 * 
	 * @return String
	 **/
	public static String getWeekEnd() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_WEEK, cal.getActualMaximum(Calendar.DAY_OF_WEEK));
		cal.add(Calendar.DAY_OF_WEEK, 1);
		Date time = cal.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(time) + " 23:59:59";
	}

	/**
	 * 获取本年的第一天
	 * 
	 * @return String
	 **/
	public static String getYearStart() {
		return new SimpleDateFormat("yyyy").format(new Date()) + "-01-01";
	}

	/**
	 * 获取本年的最后一天
	 * 
	 * @return String
	 **/
	public static String getYearEnd() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.MONTH, calendar.getActualMaximum(Calendar.MONTH));
		calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
		Date currYearLast = calendar.getTime();
		return new SimpleDateFormat("yyyy-MM-dd").format(currYearLast) + " 23:59:59";
	}

	/**
	 * 获取现在的日期时间
	 * 
	 * @return String
	 */
	public static String getNow() {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
	}

	public static String getNowAllString() {
		return new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E").format(new Date());
	}

	/**
	 * 将 Date原始格式"EEE MMM dd HH:mm:ss Z yyyy"转成指定格式 "yyyy-MM-dd HH:mm:ss"
	 * 
	 * @param str 待解析字符串 一般是执行Date的toString方法获得
	 * @return 返回的字符串 yyyy-MM-dd HH:mm:ss格式
	 */
	public static String parseOriTime(String str) {
		String sDate = "";
		SimpleDateFormat sdf1 = new SimpleDateFormat("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			Date date = sdf1.parse(str);
			sDate = sdf.format(date);
		} catch (Exception e) {
			System.out.println("日期转换失败:" + str);
		}
		return sDate;
	}

//	public static void main(String[] args) {
//		Date date = new Date();
//		System.out.println(parseOriTime(date.toString()));
//	}

	/**
	 * 将传入的Date格式化为"yyyy-MM-dd HH:mm:ss"形式，Date没有非空判断
	 *
	 * @param dateDate
	 * @return
	 */
	public static String dateToStrLong(Date date) {
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dateString = formatter.format(date);
		return dateString;
	}

	/**
	 * 将Date类型转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Date有非空判断
	 *
	 * @param date 日期类型
	 * @return 日期字符串
	 */
	public static String format(Date date) {
		if (date == null) {
			return "";
		}
		return format(date, "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 将Calendar类型的时间转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Calendar有非空判断
	 * 
	 * @param date
	 * @return
	 */
	public static String format(Calendar date) {
		if (date == null) {
			return "";
		}
		return format(date.getTime(), "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 将Date类型时间转换为指定格式的字符串，
	 *
	 * @param date    日期类型
	 * @param pattern 日期格式化的字符串格式 可以不输入，不输入 默认是"yyyy-MM-dd HH:mm:ss"
	 * @return 返回的日期字符串
	 */
	public static String format(Date date, String pattern) {
		if (date == null) {
			return "";
		}
		if (pattern == null || pattern.equals("") || pattern.equals("null")) {
			pattern = "yyyy-MM-dd HH:mm:ss";
		}
		return new SimpleDateFormat(pattern).format(date);
	}

	/**
	 * 将字符串类型时间转换为Date类型 字符串格式为"yyyy-MM-dd HH:mm:ss"
	 *
	 * @param date 字符串类型 格式为"yyyy-MM-dd HH:mm:ss"
	 * @return 日期类型
	 */
	public static Date format(String date) {
		return format(date, null);
	}

	/**
	 * 将指定格式的字符串时间类型转换为Date类型
	 * 
	 * @param date    字符串类型 时间字符串 不输入默认返回当前时间
	 * @param pattern 时间字符串格式 不输入默认是yyyy-MM-dd HH:mm:ss
	 * @return 日期类型
	 */
	public static Date format(String date, String pattern) {
		if (pattern == null || pattern.equals("") || pattern.equals("null")) {
			pattern = "yyyy-MM-dd HH:mm:ss";
		}
		if (date == null || date.equals("") || date.equals("null")) {
			return new Date();
		}
		Date d = null;
		try {
			d = new SimpleDateFormat(pattern).parse(date);
		} catch (ParseException pe) {
			System.out.println("日期解析失败  date:" + date + "  pattern:" + pattern);
		}
		return d;
	}

	/**
	 * 返回当前时间的格式化字符串 字符串格式为："yyyy-MM-dd HH:mm:ss"
	 * 
	 * @return
	 */
	public static String getCurrDate() {
		return format(new Date(), "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 根据传入的日期 解析出 该用何种SimpleDateFormat并返回对应的SimpleDateFormat
	 *
	 * @param dateStr 传入的日期字符串
	 * @return
	 */
	public static SimpleDateFormat getSimpleDateFormatPattern(String dateStr) {
		SimpleDateFormat format = null;
		if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
			format = new SimpleDateFormat("yyyy-MM-dd");
		} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
			format = new SimpleDateFormat("yyyyMMdd");
		} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
		} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
		} else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
			format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
		} else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
			format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
		} else if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}", dateStr)) {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		} else if (dateStr.length() > 20) {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		} else {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		}
		return format;
	}

	/**
	 * 根据传入的日期字符串自动转化为Date类型的时间 不需要自己输入格式化方式字符串
	 *
	 * @param dateStr @return @throws
	 * 
	 */
	public static Date parseDateByPattern(String dateStr) {
		SimpleDateFormat format = null;
		try {
			if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd");
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}/\\d{2}/\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy/MM/dd");
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyyMMdd");
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
				format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
				format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}/\\d{1,2}/\\d{1,2} \\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy/M/d HH:mm", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}\\.\\d{2}\\.\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy.MM.dd", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}年\\d{2}月", dateStr)) {
				format = new SimpleDateFormat("yyyy年MM月", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{2}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SS", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{1}", dateStr)) {
				format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S", Locale.CHINA);
				return format.parse(dateStr);
			} else if (Pattern.matches("\\d{2}:\\d{2}", dateStr)) {
				format = new SimpleDateFormat("HH:mm", Locale.CHINA);
				return format.parse(dateStr);
			}
		} catch (Exception e) {
			System.out.println("日期字符串：<<" + dateStr + ">>转换为Date失败......");
		}
		return null;
	}

//	public static void main(String[] args) {
//		System.out.println(parseDateByPattern("2020/01/01"));
//	}

	/**
	 * 根据传入的long数据给出这个数据有几天，几小时，几分和几秒
	 * 
	 * 示例 输入 343039300 返回 3天23小时17分钟19秒
	 *
	 * @param milliSeconds long形数据
	 * @return
	 */
	public static String getTimeMilisecondDesc(long milliSeconds) {
		long days = milliSeconds / (1000 * 60 * 60 * 24);
		milliSeconds = milliSeconds - (days * 24 * 60 * 60 * 1000);
		long hours = milliSeconds / (1000 * 60 * 60);
		milliSeconds = milliSeconds - (hours * 60 * 60 * 1000);
		long minutes = milliSeconds / (1000 * 60);
		milliSeconds = milliSeconds - (minutes * 60 * 1000);
		long seconds = milliSeconds / (1000);

		StringBuffer sb = new StringBuffer();
		if (days != 0) {
			sb.append(days + "天");
		}
		if (hours != 0) {
			sb.append(hours + "小时");
		}
		if (minutes != 0) {
			sb.append(minutes + "分钟");
		}
		if (seconds != 0) {
			sb.append(seconds + "秒");
		}
		return sb.toString();
	}

//	public static void main(String[] args) {
//		System.out.println(getTimeMilisecondDesc(343039300l));
//	}

	/**
	 * 取得指定日期所在周的第一天 此处认为星期一是一周的第一天 时间是00:00:00
	 *
	 * @param date
	 * @return
	 */
	public static Date getFirstDayOfWeek(Date date) {
		Calendar c = clearDate(date, 4);
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
		return c.getTime();
	}

//	public static void main(String[] args) {
//		System.out.println(getFirstDayOfWeek(new Date()));
//	}

	/**
	 * 取得指定日期所在周的最后一天 此处认为星期日是最后一天 时间到23:59:59 示例： 输入：20210225 返回：Sun Feb 28
	 * 23:59:59 CST 2021
	 * 
	 *
	 * @param date
	 * @return
	 */
	public static Date getLastDayOfWeek(Date date) {
		Calendar c = clearDate(date, 4);
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		c.set(Calendar.MILLISECOND, 000);
		return c.getTime();
	}

//	public static void main(String[] args) {
//		System.out.println(getLastDayOfWeek(new Date()));
//	}

	/**
	 * 取得指定日期所在周的起始时间 开始时间从00:00:00 结束时间是 23:59:59 此处认为星期一是一周第一天 星期日是一周最后一天 示例 传入
	 * 20210225 返回 Mon Feb 22 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
	 * 
	 * 
	 * @param date 传入的日期
	 *
	 * 
	 * @return
	 */
	public static Date[] getWeekLimit(Date date) {
		Date date1 = getFirstDayOfWeek(date);
		Date date2 = getLastDayOfWeek(date);
		return new Date[] { date1, date2 };
	}

//	public static void main(String[] args) {
//		System.out.println(getWeekLimit(new Date())[0]+"    "+getWeekLimit(new Date())[1]);
//	}

	/**
	 * 取得指定日期的当月起始时间 从00:00:00开始 到23:59:59 为止
	 * 
	 * 示例 输入 20210225 输出 Mon Feb 01 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
	 *
	 * @param date 指定日期时间
	 * @return
	 */
	public static Date[] getMonthLimit(Date date) {
		Calendar cal = clearDate(date, 5);
		Date date1 = cal.getTime();

		cal.add(Calendar.MONTH, 1);
		cal.add(Calendar.SECOND, -1);
		Date date2 = cal.getTime();

		return new Date[] { date1, date2 };
	}

//	public static void main(String[] args) {
//		System.out.println(getMonthLimit(new Date())[0]+"    "+getMonthLimit(new Date())[1]);
//	}

	/**
	 * 取得指定日期的当年起始时间 从00:00:00开始 到23:59:59 为止
	 * 
	 * 示例：输入：20210225 输出：Fri Jan 01 00:00:00 CST 2021 Fri Dec 31 23:59:59 CST 2021
	 *
	 * @param date 指定日期时间
	 * @return
	 */
	public static Date[] getYearLimit(Date date) {
		Calendar cal = clearDate(date, 6);
		Date date1 = cal.getTime();

		cal.add(Calendar.YEAR, 1);
		cal.add(Calendar.SECOND, -1);
		Date date2 = cal.getTime();

		return new Date[] { date1, date2 };
	}

//	public static void main(String[] args) {
//		System.out.println(getYearLimit(new Date())[0]+"    "+getYearLimit(new Date())[1]);
//	}

	/**
	 * 取得指定日期当月的起始时间字符串 格式是：yyyy-MM-dd HH:mm:ss
	 *
	 * @param date
	 * @return
	 */
	public static String[] getMonthLimitStr(Date date) {
		Date[] rtDateArray = getMonthLimit(date);
		return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
	}

//	public static void main(String[] args) {
//		System.out.println(getMonthLimitStr(new Date())[0]+"     "+getMonthLimitStr(new Date())[1]);
//	}

	/**
	 * 取得指定日期当年的起始时间串 格式是：yyyy-MM-dd HH:mm:ss
	 * 
	 * @param date
	 * @return
	 */
	public static String[] getYearLimitStr(Date date) {
		Date[] rtDateArray = getYearLimit(date);
		return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
	}

//	public static void main(String[] args) {
//		System.out.println(getYearLimitStr(new Date())[0]+"     "+getYearLimitStr(new Date())[1]);
//	}

	/**
	 * 给定的日期字符串，得出该日期字符串偏移多少天后的日期时间
	 *
	 * @param dateStr 日期字符串
	 * @param dayCnt  偏移天数
	 * @return 偏移后日期
	 */
	public static Date getDayAfter(String dateStr, int dayCnt) {
		return getDayAfter(parseDate(dateStr), dayCnt);
	}

//	public static void main(String[] args) {
//		System.out.println(getDayAfter("2020-01-01",3));
//	}

	/**
	 * 给定日期，得出该日期偏移多少天后的日期
	 *
	 * @param date   给定日期
	 * @param dayCnt 偏移天数
	 * @return
	 */
	public static Date getDayAfter(Date date, int dayCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.DATE, dayCnt);
		return cal.getTime();
	}

	/**
	 * 给定日期，设置偏移多少秒后日期
	 *
	 * @param date      给定的日期
	 * @param secondCnt 偏移秒数
	 * @return 具体偏移后日期
	 */
	public static Date getSecondAfter(Date date, int secondCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.SECOND, secondCnt);
		return cal.getTime();
	}

	/**
	 * 指定日期偏移指定小时后的日期
	 *
	 * @param date    指定日期时间
	 * @param hourCnt 指定小时数
	 * @return 偏移后时间
	 */
	public static Date getDayHourAfter(Date date, int hourCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.HOUR, hourCnt);
		return cal.getTime();
	}

	/**
	 * 取得后多少月的时间
	 *
	 * @param date
	 * @param monthCnt
	 * @return
	 */
	public static Date getMonthAfter(Date date, int monthCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.MONTH, monthCnt);
		return cal.getTime();
	}

	/**
	 * 取得后多少年的时间
	 *
	 * @param date
	 * @return
	 */
	public static Date getYearAfter(Date date, int yearCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.YEAR, yearCnt);
		return cal.getTime();
	}

	/**
	 * 取得指定日期多少天后所有日期的集合 不 包含指定日期的时间
	 * 
	 * 比如 输入 20210225 2 输出：[Fri Feb 26 16:04:06 CST 2021, Sat Feb 27 16:04:06 CST
	 * 2021]
	 *
	 * @param date   指定日期
	 * @param dayCnt 指定天数
	 * @return 日期集合
	 */
	public static List<Date> getDayListAfter(Date date, int dayCnt) {
		List<Date> list = new ArrayList<Date>();
		GregorianCalendar cal = new GregorianCalendar();
		for (int i = 1; i <= dayCnt; i++) {
			cal.setTime(date);
			cal.add(Calendar.DATE, i);
			list.add(cal.getTime());
		}
		return list;
	}

//	public static void main(String[] args) {
//		System.out.println(getDayListAfter(new Date(),2).toString());
//	}

	/**
	 * 根据传入的日期字符串，给出该日期指定天数后的日期 实际就是日期相加减
	 *
	 * @param dateStr 日期字符串
	 * @param dayCnt  指定天数
	 * @return
	 */
	public static Date getDayDiff(String dateStr, int dayCnt) {
		return getDayDiff(parseDate(dateStr), dayCnt);
	}

//	public static void main(String[] args) {
//		System.out.println(getDayDiff("20200111",2));
//	}

	/**
	 * 根据传入的指定日期，给出该日期指定天数后的日期
	 *
	 * @param date   指定日期
	 * @param dayCnt 指定天数
	 * @return
	 */
	public static Date getDayDiff(Date date, int dayCnt) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.DATE, dayCnt);
		return cal.getTime();
	}

//	public static void main(String[] args) {
//		System.out.println(getDayDiff(new Date(),2));
//	}

	/**
	 * 取得今天开始时间 00:00:00
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStartToday() {

		Calendar todayStart = Calendar.getInstance();
		todayStart.set(Calendar.HOUR_OF_DAY, 0);
		todayStart.set(Calendar.MINUTE, 0);
		todayStart.set(Calendar.SECOND, 0);
		todayStart.set(Calendar.MILLISECOND, 0);
		return todayStart.getTime();
	}

//	public static void main(String[] args) {
//		System.out.println(getStartToday());
//	}

	/**
	 * 取得今天23:59:59秒时间
	 * 
	 * @param date
	 * @return
	 */
	public static Date getEndToday() {
		Calendar todayEnd = Calendar.getInstance();
		todayEnd.set(Calendar.HOUR_OF_DAY, 23);
		todayEnd.set(Calendar.MINUTE, 59);
		todayEnd.set(Calendar.SECOND, 59);
		todayEnd.set(Calendar.MILLISECOND, 999);
		return todayEnd.getTime();
	}

//	public static void main(String[] args) {
//		System.out.println(getEndToday());
//	}

	/**
	 * 取得昨天的开始时间 00:00:00
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStatusYestday() {

		Calendar tempStart = Calendar.getInstance();
		Date start = new Date();

		tempStart.setTime(start);
		tempStart.set(Calendar.HOUR_OF_DAY, 0);
		tempStart.set(Calendar.MINUTE, 0);
		tempStart.set(Calendar.SECOND, 0);
		tempStart.set(Calendar.MILLISECOND, 0);
		tempStart.add(Calendar.DAY_OF_YEAR, -1);
		Date time = tempStart.getTime();

		return time;
	}

//	public static void main(String[] args) {
//		System.out.println(getStatusYestday());
//	}

	/**
	 * 取得昨天结束时间 23:59:59
	 * 
	 * @param date
	 * @return
	 */
	public static Date getEndYestday() {

		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.SECOND, -1);
		Date time = tempEnd.getTime();
		return time;
	}

//	public static void main(String[] args) {
//		System.out.println(getEndYestday());
//	}

	/**
	 * 取得前7天开始时间 包含今天 比如 20210303 返回 20210225 00:00:00
	 * 
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStatus7Days() {

		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.DAY_OF_YEAR, -6);
		Date time = tempEnd.getTime();

		return time;

	}

//	public static void main(String[] args) {
//		System.out.println(getStatus7Days());
//	}

	/**
	 * 取得前7天结束时间 包含今天 比如 20210303 返回 20210225 23:59:59
	 * 
	 * @param date
	 * @return
	 */
	public static Date getEnd7Days() {

		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.DAY_OF_YEAR, -5);
		tempEnd.add(Calendar.SECOND, -1);
		Date time = tempEnd.getTime();

		return time;

	}

//	public static void main(String[] args) {
//		System.out.println(getEnd7Days());
//	}

	/**
	 * 取得前30天的开始时间 包含今天 比如 20210304 返回 20210203 00:00:00
	 * 
	 * @param date
	 * @return
	 */
	public static Date getStatus30Days() {
		Calendar tempEnd = Calendar.getInstance();
		Date end = new Date();

		tempEnd.setTime(end);
		tempEnd.set(Calendar.HOUR_OF_DAY, 0);
		tempEnd.set(Calendar.MINUTE, 0);
		tempEnd.set(Calendar.SECOND, 0);
		tempEnd.set(Calendar.MILLISECOND, 0);
		tempEnd.add(Calendar.DAY_OF_YEAR, -29);
		Date time = tempEnd.getTime();

		return time;
	}

//	public static void main(String[] args) {
//		System.out.println(getStatus30Days());
//	}

	/**
	 * 取得指定日期 23:59:59的时间 解析失败返回当前时间
	 * 
	 * @param date 指定日期
	 * @return 指定日期 23:59:59的时间
	 */
	public static Date getMongoDate(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Calendar ca = Calendar.getInstance();
		ca.setTime(date);
		ca.set(Calendar.HOUR_OF_DAY, 23);
		ca.set(Calendar.MINUTE, 59);
		ca.set(Calendar.SECOND, 59);
		ca.set(Calendar.MILLISECOND, 999);
		try {
			return sdf.parse(sdf.format(ca.getTime()));
		} catch (ParseException e) {
			System.out.println("日期解析错误......");
		}
		return new Date();
	}

//	public static void main(String[] args) {
//		System.out.println(getMongoDate(new Date()));
//	}

	/**
	 * 根据传入的日期字符串取得前一天的时间字符串 例如：传入 20200102 返回 2020-01-01 00:00:00 传入2020-01-02
	 * 10:23:43 返回2020-01-01 10:23:43 字符串格式为：yyyy-MM-dd HH:mm:ss
	 *
	 * @param dateStr
	 * @return
	 */
	public static String getYestdayStr(String dateStr) {
		return getYestdayStr(parseDate(dateStr));
	}
//	
//	public static void main(String[] args) {
//		System.out.println(getYestdayStr("2020-01-02 10:23:43"));
//	}

	/**
	 * 取得指定日期 前一天的时间字符串 字符串格式为：yyyy-MM-dd HH:mm:ss
	 *
	 * @param date
	 * @return
	 */
	public static String getYestdayStr(Date date) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.add(Calendar.DATE, -1);
		return getDateTimeStr(cal.getTime());
	}

//	public static void main(String[] args) {
//		System.out.println(getYestdayStr(new Date()));
//	}

	/**
	 * 根据传入的日期和参数将日期对应字段后面所有日期字段清零 参数对应字段说明：1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
	 * 返回的是Calendar类型
	 * 
	 * 样例: 1 Thu Mar 04 10:38:25 CST 2021 2 Thu Mar 04 10:38:00 CST 2021 3 Thu Mar
	 * 04 10:00:00 CST 2021 4 Thu Mar 04 00:00:00 CST 2021 5 Mon Mar 01 00:00:00 CST
	 * 2021 6 Fri Jan 01 00:00:00 CST 2021
	 *
	 * @param date     传入的日期时间
	 * @param clearNum 1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
	 * @return
	 */
	public static Calendar clearDate(Date date, int clearNum) {
		Calendar cal = new GregorianCalendar();
		cal.setTime(date);
		// 毫秒
		if (clearNum > 0) {
			cal.set(Calendar.MILLISECOND, 0);
		}
		// 秒

		if (clearNum > 1) {
			cal.set(Calendar.SECOND, 0);
		}
		// 分钟
		if (clearNum > 2) {
			cal.set(Calendar.MINUTE, 0);
		}
		// 小时
		if (clearNum > 3) {
			cal.set(Calendar.HOUR_OF_DAY, 0);
		}
		// 天

		if (clearNum > 4) {
			cal.set(Calendar.DATE, 1);
		}
		// 月份
		if (clearNum > 5) {
			cal.set(Calendar.MONTH, 0);
		}
		return cal;
	}

//	public static void main(String[] args) {
//		System.out.println(clearDate(new Date(),6).getTime());
//	}

	/**
	 * 根据传入的字符串和字符串格式化类型将字符串转化为Date时间
	 *
	 * @param dateStr   日期字符串
	 * @param formatStr 格式化形式
	 * @return
	 */
	public static Date parseDate(String formatStr, String dateStr) throws ParseException {
		SimpleDateFormat format = new SimpleDateFormat(formatStr);
		return format.parse(dateStr);
	}

//	public static void main(String[] args) {
//		try {
//			System.out.println(parseDate("yyyy-MM-dd","2020-01-01"));
//		} catch (ParseException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//	}

	/**
	 * 根据传入的字符串和字符串格式化类型将字符串转化为Calendar时间
	 * 
	 * @param formatStr 格式化形式
	 * @param dateStr   日期字符串
	 * @return
	 */
	public static Calendar parseCalendar(String formatStr, String dateStr) {
		Calendar c = Calendar.getInstance();
		try {
			c.setTime(parseDate(formatStr, dateStr));
		} catch (Exception e) {
			return null;
		}
		return c;
	}

	/**
	 * 
	 * 根据传入的字符串将字符串转化为Calendar时间
	 * 
	 * @param dateStr 传入的时间字符串
	 * @return
	 */
	public static Calendar parseCalendar(String dateStr) {
		Calendar c = Calendar.getInstance();
		try {
			c.setTime(parseDateByPattern(dateStr));
		} catch (Exception e) {
			return null;
		}
		return c;
	}

	/**
	 * 把指定字符串转化为Date
	 *
	 * @param dateStr 指定的字符串
	 * @return
	 */
	public static Date parseDate(String dateStr) {
		if (dateStr == null || "".equals(dateStr)) {
			return null;
		}

		SimpleDateFormat format = null;
		if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
			format = new SimpleDateFormat("yyyy-MM-dd");
		} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
			format = new SimpleDateFormat("yyyyMMdd");
		} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
		} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
			format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
		} else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
			format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
		} else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
			format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
		} else if (dateStr.length() > 20) {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
		} else {
			format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		}

		try {
			return format.parse(dateStr);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

//	public static void main(String[] args) {
//		System.out.println(parseDate("2020-01-23"));
//	}

	/**
	 * 取得指定时间的时间串，格式为 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param date 指定时间
	 * @return 格式化后时间字符串
	 */
	public static String getDateTimeStr(Date date) {
		if (date == null) {
			return getCurDateTimeStr();
		}
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
	}

	/**
	 * 取得当前的时间，格式为 yyyy-MM-dd HH:mm:ss
	 *
	 * @return
	 */
	public static String getCurDateTimeStr() {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
	}

	/**
	 * 根据传入的年份，给出该年的最大周
	 * 
	 * @param year
	 * @return
	 */
	public static int getMaxWeekOfYear(int year) {
		Calendar c = new GregorianCalendar();
		c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
		return getWeekOfYear(c.getTime());
	}

//	public static void main(String[] args) {
//		System.out.println(getMaxWeekOfYear(2021));
//	}

	/**
	 * 获取指定日期当前周
	 *
	 * @param date
	 * @return
	 */
	public static int getWeekOfYear(Date date) {
		Calendar c = new GregorianCalendar();
		c.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
		c.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
		c.setTime(date);
		return c.get(Calendar.WEEK_OF_YEAR);
	}

	/**
	 * 
	 * 返回值说明:返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始 第一周是完整周 不完整的几天算去年最后一周
	 *
	 * @param year    年分 例如 2014
	 * @param weeknum 第几周 例如33
	 * @return
	 * 
	 */
	public static Calendar[] getStartAndEndDate(int year, int weeknum) {

		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, year);
		cal.set(Calendar.WEEK_OF_YEAR, weeknum);
		cal.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
		cal.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		Calendar end = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, end };
		return darr;
	}

//	public static void main(String[] args) {
//		System.out.println(getStartAndEndDate(2021,1)[0].getTime()+"    "+getStartAndEndDate(2021,1)[1].getTime());
//	}

	/**
	 * 获取当期日期的一周 开始和结束日期 返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始
	 * 
	 * @return
	 */
	public static Calendar[] getCurrStartEndDate() {
		Calendar cal = Calendar.getInstance();
		// 向后推一天（从星期一到周末）
		cal.add(Calendar.DATE, -1);
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		Calendar end = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, end };
		return darr;
	}

//	public static void main(String[] args) {
//		System.out.println(getCurrStartEndDate()[0].getTime() + "    " + getCurrStartEndDate()[1].getTime());
//	}

	/**
	 * 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
	 * 
	 * @return
	 */
	public static Calendar[] getCurrStartAndEndOfWeek() {
		Calendar cal = Calendar.getInstance();
		// 向后推一天（从星期一到周末）
		cal.add(Calendar.DATE, -1);
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		Calendar tuesday = (Calendar) cal.clone();// 周二
		tuesday.add(Calendar.DATE, 2 - nw + 1);
		Calendar wednesday = (Calendar) cal.clone();// 周三
		wednesday.add(Calendar.DATE, 3 - nw + 1);
		Calendar thursday = (Calendar) cal.clone();// 周四
		thursday.add(Calendar.DATE, 4 - nw + 1);
		Calendar friday = (Calendar) cal.clone();// 周五
		friday.add(Calendar.DATE, 5 - nw + 1);
		Calendar saturday = (Calendar) cal.clone();// 周六
		saturday.add(Calendar.DATE, 6 - nw + 1);
		Calendar end = (Calendar) cal.clone();
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
		return darr;
	}

//	public static void main(String[] args) {
//		Calendar[] tests = getCurrStartAndEndOfWeek();
//		for(Calendar calendar:tests) {
//			System.out.println(calendar.getTime());
//		}
//	}

	/**
	 * 获取指定日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
	 * 
	 * @param date 指定日期
	 * @return
	 */
	public static Calendar[] getStartAndEndOfWeekByDate(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		// 向后推一天（从星期一到周末）
		cal.add(Calendar.DATE, -1);
		int nw = cal.get(Calendar.DAY_OF_WEEK);
		Calendar start = (Calendar) cal.clone();
		start.add(Calendar.DATE, 1 - nw + 1);
		Calendar tuesday = (Calendar) cal.clone();// 周二
		tuesday.add(Calendar.DATE, 2 - nw + 1);
		Calendar wednesday = (Calendar) cal.clone();// 周三
		wednesday.add(Calendar.DATE, 3 - nw + 1);
		Calendar thursday = (Calendar) cal.clone();// 周四
		thursday.add(Calendar.DATE, 4 - nw + 1);
		Calendar friday = (Calendar) cal.clone();// 周五
		friday.add(Calendar.DATE, 5 - nw + 1);
		Calendar saturday = (Calendar) cal.clone();// 周六
		saturday.add(Calendar.DATE, 6 - nw + 1);
		Calendar end = (Calendar) cal.clone();
		end.add(Calendar.DATE, 7 - nw + 1);
		Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
		return darr;
	}

//	public static void main(String[] args) {
//		Calendar[] tests = getStartAndEndOfWeekByDate(parseDate("2021-01-01"));
//		for(Calendar calendar:tests) {
//			System.out.println(calendar.getTime());
//		}
//	}

	/**
	 * 算出俩个时间，所间隔的多少天
	 * 
	 * @param startDate
	 * @param endDate
	 * @return
	 */
	public static Long getDaysBetween(Date startDate, Date endDate) {
		Calendar fromCalendar = Calendar.getInstance();
		fromCalendar.setTime(startDate);
		fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
		fromCalendar.set(Calendar.MINUTE, 0);
		fromCalendar.set(Calendar.SECOND, 0);
		fromCalendar.set(Calendar.MILLISECOND, 0);

		Calendar toCalendar = Calendar.getInstance();
		toCalendar.setTime(endDate);
		toCalendar.set(Calendar.HOUR_OF_DAY, 0);
		toCalendar.set(Calendar.MINUTE, 0);
		toCalendar.set(Calendar.SECOND, 0);
		toCalendar.set(Calendar.MILLISECOND, 0);

		return (toCalendar.getTime().getTime() - fromCalendar.getTime().getTime()) / (1000 * 60 * 60 * 24);
	}

//	public static void main(String[] args) {
//		System.out.println(getDaysBetween(parseDate("2020-01-01"),parseDate("2020-01-08")));
//	}

	/**
	 * 两个时间相差多少天多少小时多少分多少秒
	 *
	 * @param startDate 时间参数 1 格式：1990-01-01 12:00:00
	 * @param endDate   时间参数 2 格式：2009-01-01 12:00:00
	 * @return long[] 返回值为：{天, 时, 分, 秒}
	 */
	public static long[] getDaysBetweenmm(String startDate, String endDate) {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date one;
		Date two;
		long day = 0;
		long hour = 0;
		long min = 0;
		long sec = 0;
		try {
			one = df.parse(startDate);
			two = df.parse(endDate);
			long time1 = one.getTime();
			long time2 = two.getTime();
			long diff;
			if (time1 < time2) {
				diff = time2 - time1;
			} else {
				diff = time1 - time2;
			}
			day = diff / (24 * 60 * 60 * 1000);
			hour = (diff / (60 * 60 * 1000) - day * 24);
			min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
			sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		long[] times = { day, hour, min, sec };
		return times;
	}

//	public static void main(String[] args) {
//		long [] s = getDaysBetweenmm("2020-01-01 20:01:02","2020-02-01 10:20:20");
//		for(long l:s) {
//			System.out.println(l);
//		}
//	}

	/**
	 * 根据指定的月字符串算出月初和月未的时间，精确到秒 实例：输入：2020-01 输出：Wed Jan 01 00:00:00 CST 2020 Fri
	 * Jan 31 23:59:59 CST 2020
	 * 
	 *
	 * @param monthStr 格式为:2020-01形式
	 * @return 月初和月末时间数组
	 */
	public static Date[] getDatetimeMonthLimit(String monthStr) {
		String start = monthStr + "-01 00:00:00";
		Date startTime = DateUtil.format(start);

		Calendar cal = Calendar.getInstance();
		cal.setTime(startTime);
		cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE) + 1);
		cal.add(Calendar.SECOND, -1);
		Date endTime = cal.getTime();
		return new Date[] { startTime, endTime };
	}

//	public static void main(String[] args) {
//		System.out.println(getDatetimeMonthLimit("2020-02")[0]+"    "+getDatetimeMonthLimit("2020-02")[1]);
//	}

	/**
	 * 根据指定的月字符串算出上月月初和月未的时间，精确到秒
	 *
	 * @param monthStr 格式为:2020-01形式
	 * @return 上月月初和月未的时间
	 */
	public static Date[] getDatetimePreMonthLimit(String monthStr) {
		String start = monthStr + "-01 00:00:00";
		Date startTime = DateUtil.format(start);

		Calendar cal = Calendar.getInstance();
		cal.setTime(startTime);
		cal.add(Calendar.MONTH, -1);
		startTime = cal.getTime();

		cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE));
		Date endTime = new Date(cal.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		return new Date[] { startTime, endTime };
	}

//	public static void main(String[] args) {
//		System.out.println(getDatetimePreMonthLimit("2020-02")[0]+"    "+getDatetimePreMonthLimit("2020-02")[1]);
//	}

	/**
	 * 根据指定的天字符串算出天开始和天结束的时间，精确到秒
	 * 
	 * @param day 指定的天字符串 格式为：2020-01-01
	 * @return 算出天开始和天结束的时间
	 */
	public static Date[] getDatetimeDayLimit(String day) {
		String startStr = day + " 00:00:00";
		Date start = DateUtil.parseDate(startStr);
		return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
	}

//	public static void main(String[] args) {
//		System.out.println(getDatetimeDayLimit("2020-02-01")[0] + "    " + getDatetimeDayLimit("2020-02-01")[1]);
//	}

	/**
	 * 根据指定的天字符串算出昨天开始和昨天结束的时间，精确到秒
	 * 
	 * @param day 指定的天字符串 格式为：2020-01-01
	 * @return 算出昨天开始和昨天结束的时间
	 */
	public static Date[] getDatetimePreDayLimit(String day) {
		String startStr = day + " 00:00:00";
		Date start = new Date(DateUtil.parseDate(startStr).getTime() - 24 * 60 * 60 * 1000l);
		return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
	}

	/**
	 * 
	 * 根据传入的日期，判断日期是第几季度 1 第一季度 2 第二季度 3 第三季度 4 第四季度
	 *
	 * @param date 传入的日期
	 * @return 季度数
	 */
	public static int getSeason(Date date) {

		int season = 0;

		Calendar c = Calendar.getInstance();
		c.setTime(date);
		int month = c.get(Calendar.MONTH);
		switch (month) {
		case Calendar.JANUARY:
		case Calendar.FEBRUARY:
		case Calendar.MARCH:
			season = 1;
			break;
		case Calendar.APRIL:
		case Calendar.MAY:
		case Calendar.JUNE:
			season = 2;
			break;
		case Calendar.JULY:
		case Calendar.AUGUST:
		case Calendar.SEPTEMBER:
			season = 3;
			break;
		case Calendar.OCTOBER:
		case Calendar.NOVEMBER:
		case Calendar.DECEMBER:
			season = 4;
			break;
		default:
			break;
		}
		return season;
	}

//	public static void main(String[] args) {
//		System.out.println(getSeason(parseDate("2020-03-01")));
//	}

	/**
	 * 根据指定的年份和季度 算出季度初和季度未的时间，精确到秒
	 *
	 * @param year    年份
	 * @param nSeason 第几季度
	 * @return 季度开始和结束时间
	 */
	public static Date[] getDatetimeSeasonLimit(int year, int nSeason) {
		Calendar c = Calendar.getInstance();
		Date[] season = new Date[2];
		c.set(year, Calendar.JANUARY, 1, 0, 0, 0);
		c.set(Calendar.MILLISECOND, 0);
		if (nSeason == 1) {// 第一季度
			c.set(Calendar.MONTH, Calendar.JANUARY);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.MARCH);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		} else if (nSeason == 2) {// 第二季度
			c.set(Calendar.MONTH, Calendar.APRIL);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.JUNE);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		} else if (nSeason == 3) {// 第三季度
			c.set(Calendar.MONTH, Calendar.JULY);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.SEPTEMBER);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		} else if (nSeason == 4) {// 第四季度
			c.set(Calendar.MONTH, Calendar.OCTOBER);
			season[0] = c.getTime();
			c.set(Calendar.MONTH, Calendar.DECEMBER);
			c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
			season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		}

		return season;
	}

//	public static void main(String[] args) {
//		System.out.println(getDatetimeSeasonLimit(2021,4)[0]+"  "+getDatetimeSeasonLimit(2021,4)[1]);
//	}

	/**
	 * 根据指定的年份和季度 算出上一季度 季度初和季度未的时间，精确到秒
	 *
	 * @param year    年份
	 * @param nSeason 第几季度
	 * @return
	 */
	public static Date[] getDatetimePreSeasonLimit(int year, int nSeason) {
		if (nSeason == 1) {
			nSeason = 4;
			year = year - 1;
		} else {
			nSeason = nSeason - 1;
		}
		return getDatetimeSeasonLimit(year, nSeason);
	}

	/**
	 * 根据指定的年份数据算出年初和年未的时间，精确到秒
	 *
	 * @param year 年份
	 * @return
	 */
	public static Date[] getDatetimeYearLimit(int year) {
		Calendar c = Calendar.getInstance();
		Date[] res = new Date[2];
		c.set(Calendar.YEAR, year);
		c.set(Calendar.MONTH, Calendar.JANUARY);
		res[0] = clearDate(c.getTime(), 5).getTime();
		c.setTime(res[0]);
		c.set(Calendar.MONTH, Calendar.DECEMBER);
		c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
		res[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
		return res;
	}

//	public static void main(String[] args) {
//		System.out.println(getDatetimeYearLimit(2020)[0]+"   "+getDatetimeYearLimit(2020)[1]);
//	}

	/**
	 * 根据指定的年份数据算出去年年初和年未的时间，精确到秒
	 *
	 * @param year 年份
	 * @return
	 */
	public static Date[] getDatetimePreYearLimit(int year) {
		return getDatetimeYearLimit(year - 1);
	}

//	public static void main(String[] args) {
//		System.out.println(getDatetimePreYearLimit(2020)[0] + "   " + getDatetimePreYearLimit(2020)[1]);
//	}

	/**
	 * 日期相加减
	 *
	 * @param date
	 * @param number 天数数量
	 * @return
	 */
	public static Date getNextDay(Date date, int number) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, number);// +1今天的时间加一天
		date = calendar.getTime();
		return date;
	}

	/**
	 * 计算俩个时间差多少天多少小时
	 *
	 * @param endDate 结束时间
	 * @param nowDate 开始时间
	 * @return 差几天的字符串
	 */
	public static String getDatePoorHour(Date nowDate, Date endDate) {

		long nd = 1000 * 24 * 60 * 60l;
		long nh = 1000 * 60 * 60l;
		long nm = 1000 * 60l;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = endDate.getTime() - nowDate.getTime();
		// 计算差多少天
		long day = diff / nd;
		// 计算差多少小时
		long hour = (diff % nd) / nh;
		// 计算差多少分钟
		long min = (diff % nd % nh) / nm;
		// 计算差多少秒//输出结果
		// long sec = diff % nd % nh % nm / ns;
		return day + "天" + hour + "小时";
	}

//	public static void main(String[] args) {
//		System.out.println(getDatePoorHour(parseDate("2020-01-01 10:01:00"),parseDate("2020-01-03 10:00:00")));
//	}

	/**
	 * 计算俩个时间差多少天多少小时多少分钟
	 *
	 * @param endDate 结束时间
	 * @param nowDate 开始时间
	 * @return
	 */
	public static String getDatePoorMinute(Date nowDate, Date endDate) {

		long nd = 1000 * 24 * 60 * 60l;
		long nh = 1000 * 60 * 60l;
		long nm = 1000 * 60l;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = endDate.getTime() - nowDate.getTime();
		// 计算差多少天
		long day = diff / nd;
		// 计算差多少小时
		long hour = (diff % nd) / nh;
		// 计算差多少分钟
		long min = (diff % nd % nh) / nm;
		// 计算差多少秒//输出结果
		// long sec = diff % nd % nh % nm / ns;
		String tempStr = "";
		if (day > 0) {
			tempStr = day + "天";
		}
		if (hour > 0) {
			tempStr += hour + "小时";
		}
		if (min > 0) {
			tempStr += min + "分钟";
		}
		return tempStr;
	}

//	public static void main(String[] args) {
//		System.out.println(getDatePoorMinute(parseDate("2020-01-01 10:01:00"),parseDate("2020-01-03 10:00:00")));
//	}

	/**
	 * 计算俩个时间相差多少分钟
	 *
	 * @param endDate 结束时间
	 * @param nowDate 开始时间
	 * @return
	 */
	public static long getDatePoorTotalMinute(Date nowDate, Date endDate) {
		long nm = 1000 * 60l;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = endDate.getTime() - nowDate.getTime();
		Long tempLong = diff / nm;
		return tempLong;
	}

	/**
	 * 获取当前季度的开始时间
	 *
	 * @return
	 */
	public static Date getCurrentQuarterStartTime() {
		Calendar c = Calendar.getInstance();
		int currentMonth = c.get(Calendar.MONTH) + 1;
		Date now = null;
		try {
			if (currentMonth >= 1 && currentMonth <= 3)
				c.set(Calendar.MONTH, 0);
			else if (currentMonth >= 4 && currentMonth <= 6)
				c.set(Calendar.MONTH, 3);
			else if (currentMonth >= 7 && currentMonth <= 9)
				c.set(Calendar.MONTH, 6);
			else if (currentMonth >= 10 && currentMonth <= 12)
				c.set(Calendar.MONTH, 9);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return clearDate(c.getTime(), 5).getTime();
	}

//	public static void main(String[] args) {
//		System.out.println(getCurrentQuarterStartTime());
//	}

	/**
	 * 获取当前季度的结束时间
	 *
	 * @return
	 */
	public static Date getCurrentQuarterEndTime() {
		Calendar c = Calendar.getInstance();
		int currentMonth = c.get(Calendar.MONTH) + 1;
		try {
			if (currentMonth >= 1 && currentMonth <= 3) {
				c.set(Calendar.MONTH, 2);
				c.set(Calendar.DATE, 31);
			} else if (currentMonth >= 4 && currentMonth <= 6) {
				c.set(Calendar.MONTH, 5);
				c.set(Calendar.DATE, 30);
			} else if (currentMonth >= 7 && currentMonth <= 9) {
				c.set(Calendar.MONTH, 8);
				c.set(Calendar.DATE, 30);
			} else if (currentMonth >= 10 && currentMonth <= 12) {
				c.set(Calendar.MONTH, 11);
				c.set(Calendar.DATE, 31);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		c.set(Calendar.MILLISECOND, 000);
		return c.getTime();
	}

//	public static void main(String[] args) {
//		System.out.println(getCurrentQuarterEndTime());
//	}
	/**
	 * 输入指定日期，给出该日期为星期几的字符串说明
	 * 
	 * @param date
	 * @return
	 */
	public static String getWeek(Date date) {
		String[] weeks = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
		if (week_index < 0) {
			week_index = 0;
		}
		return weeks[week_index];
	}

//	public static void main(String[] args) {
//		System.out.println(getWeek(parseDate("2020-02-29")));
//	}

	/**
	 * 获取两个日期相隔天数 去掉时分秒，直接比对日
	 *
	 * @param fDate 开始时间
	 * @param oDate 结束时间
	 * @return 返回相差几天
	 */
	public static int getIntervalOfDays(Date fDate, Date oDate) {
		if (null == fDate || null == oDate) {
			return -1;
		}
		fDate = DateUtil.clearDate(fDate, 4).getTime();
		oDate = DateUtil.clearDate(oDate, 4).getTime();
		long intervalMilli = oDate.getTime() - fDate.getTime();
		return (int) (intervalMilli / (24 * 60 * 60 * 1000));
	}

	/**
	 * 获取指定时间的月份数据
	 * 
	 * @param date 指定时间
	 * @return 月份数据
	 */
	public static int getMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.MONTH) + 1;
	}

	/**
	 * 获取指定时间的年份数据
	 * 
	 * @param date
	 * @return
	 */
	public static int getYear(Date date) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		return now.get(Calendar.YEAR);
	}

	/**
	 * 获取指定时间几分钟后的时间字符串
	 * 
	 * @param date   指定时间
	 * @param minute 几分钟后数据
	 * @return
	 */
	public static String getTimeByMinute(Date date, int minute) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.MINUTE, minute);
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());

	}

//	public static void main(String[] args) {
//		System.out.println(getTimeByMinute(new Date(),2));
//	}

	/**
	 * 
	 * 根据指定规则输出指定日期字符串的中文表示 接收日期格式字符转化为中文+日期格式 规则： 刚刚（5分钟前） ①如果开课时间为当天的日期，显示“今天+时+分”
	 * ②如果开课时间为昨天的日期，显示“昨天+时+分” ③如果开课时间为前天的日期，显示“前天+时+分” ④如果开课时间为明天的日期，显示“明天+时+分”
	 * ⑤如果开课时间为后天的日期，显示“后天+时+分” ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分” ⑦其余日期均显示“月-日 时：分”
	 * ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
	 *
	 * @param date 指定日期字符串 格式为：yyyy-MM-dd HH:mm:ss
	 * @return 指定日期字符串的中文表示
	 */
	public static String transFinalFormationStringDate(String date) {
		long[] daysBetweenmm = getDaysBetweenmm(date, format(new Date()));
		if (daysBetweenmm[0] == 0 && daysBetweenmm[1] == 0 && daysBetweenmm[2] < 6) {
			return "刚刚";
		}
		return transFormationStringDate(date);
	}

//	public static void main(String[] args) {
//		System.out.println(transFinalFormationStringDate("2021-02-09 16:18:00"));
//	}

	/**
	 * 
	 * @param date
	 * @return
	 */
	public static String transFormationStringDate(String date) {
		Date now = new Date();
		SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return transFormationStringDate(date, now, sss.format(now));

	}

	/**
	 * 接收日期格式字符转化为中文+日期格式 规则：①如果开课时间为当天的日期，显示“今天+时+分” ②如果开课时间为昨天的日期，显示“昨天+时+分”
	 * ③如果开课时间为前天的日期，显示“前天+时+分” ④如果开课时间为明天的日期，显示“明天+时+分” ⑤如果开课时间为后天的日期，显示“后天+时+分”
	 * ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分” ⑦其余日期均显示“月-日 时：分” ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
	 *
	 * @param date
	 * @return
	 */
	public static String transFormationStringDate(String date, Date newDate, String newDateStr) {
		SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			String yyyyStr = date.substring(0, 4);
			String mmStr = date.substring(5, 7);
			String ddStr = date.substring(8, 10);

			String hhStr = date.substring(11, 13);
			String MMStr = date.substring(14, 16);
			String ssStr = date.substring(17, 19);

			int yyyy = Integer.parseInt(yyyyStr);
			int mm = Integer.parseInt(mmStr);
			int dd = Integer.parseInt(ddStr);

			int hh = Integer.parseInt(hhStr);
			int MM = Integer.parseInt(MMStr);
			int ss = Integer.parseInt(ssStr);

			int yyyy1 = Integer.parseInt(newDateStr.substring(0, 4));
			int mm1 = Integer.parseInt(newDateStr.substring(5, 7));
			int dd1 = Integer.parseInt(newDateStr.substring(8, 10));

			if (yyyy != yyyy1) {// 如果开课时间不是当前年，显示“年-月-日 时：分”
				return yyyyStr + "-" + mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
			}
			if (mm == mm1 && dd == dd1) {// 如果开课时间为当天的日期，显示“今天+时+
				return "今天" + " " + hhStr + ":" + MMStr;
			}
			Date allDate = sss.parse(date);
			Long daysBetween = getDaysBetween(newDate, allDate);
			if (daysBetween == -1) {// 如果开课时间为昨天的日期，显示“昨天+时+分”
				return "昨天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween == -2) {// 如果开课时间为前天的日期，显示“前天+时+分”
				return "前天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween == 1) {// 如果开课时间为明天的日期，显示“明天+时+分”
				return "明天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween == 2) {// 如果开课时间为后天的日期，显示“后天+时+分”
				return "后天" + " " + hhStr + ":" + MMStr;
			}
			if (daysBetween > 2 || daysBetween < -2) {// 如果开课时间超出后天
				Date firstDayOfWeek1 = getFirstDayOfWeek(newDate);// 当前日期所在周的第一天
				Date firstDayOfWeek2 = getFirstDayOfWeek(allDate);// 传入日期所在周的第一天
				if (firstDayOfWeek1.getTime() == firstDayOfWeek2.getTime()) {// 并且还在当前周内，显示“本周X+时+分”
					Long ad = getDaysBetween(firstDayOfWeek1, allDate);
					switch (ad.intValue()) {
					case 0:
						return "本周一" + " " + hhStr + ":" + MMStr;
					case 1:
						return "本周二" + " " + hhStr + ":" + MMStr;
					case 2:
						return "本周三" + " " + hhStr + ":" + MMStr;
					case 3:
						return "本周四" + " " + hhStr + ":" + MMStr;
					case 4:
						return "本周五" + " " + hhStr + ":" + MMStr;
					case 5:
						return "本周六" + " " + hhStr + ":" + MMStr;
					case 6:
						return "本周日" + " " + hhStr + ":" + MMStr;
					}
				}
			}
			// 其余日期均显示“月-日 时：分”
			return mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
			// format(allDate,"MM-dd HH:mm");
		} catch (Exception e) {
			return "日期格式字符转化错误";
		}
	}

	/**
	 * 获取指定时间根据格式化方式获取的各组成部分
	 * 
	 *
	 * @param date   指定时间
	 * @param format 获取的部分 yyyy 年份 MM 月份 dd 日
	 * @return
	 */
	public static int getYMDDate(Date date, String format) {
		SimpleDateFormat sdf = null;
		try {
			if (format != null && format.length() > 0) {
				if ("yyyy".equals(format)) {
					sdf = new SimpleDateFormat("yyyy");
					String formatY = sdf.format(date);
					return Integer.parseInt(formatY);
				} else if ("MM".equals(format)) {
					sdf = new SimpleDateFormat("MM");
					String formatY = sdf.format(date);
					return Integer.parseInt(formatY);
				} else if ("dd".equals(format)) {
					sdf = new SimpleDateFormat("dd");
					String formatY = sdf.format(date);
					return Integer.parseInt(formatY);
				}

			}
			return 0;
		} catch (Exception e) {
			return 0;
		}
	}

//    public static void main(String[] args) {
//		System.out.println(getYMDDate(new Date(),"yyyy"));  //2021
//		System.out.println(getYMDDate(new Date(),"MM"));    //3
//		System.out.println(getYMDDate(new Date(),"dd"));    //4
//		
//	} 

	/**
	 * 
	 * 传入天、时、份、秒 获取当月指定天数后的指定时间
	 * 
	 * @param hour   小时数
	 * @param minute 分钟数
	 * @param second 秒钟数
	 * @param day    指定天数后
	 * @return 指定时间
	 */
	public static Date getNeedTime(int hour, int minute, int second, int day) {
		Calendar calendar = Calendar.getInstance();
		if (day != 0) {
			calendar.add(Calendar.DATE, day);
		}
		calendar.set(Calendar.HOUR_OF_DAY, hour);
		calendar.set(Calendar.MINUTE, minute);
		calendar.set(Calendar.SECOND, second);

		return calendar.getTime();
	}

	public static void main(String[] args) {
		System.out.println(getMonthStart());
		System.out.println(getMonthEnd());
		System.out.println(getNowAllString());
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/260525?site

Java中的日期转化格式DateUtil工具类-（87个方法）_java dateutil

Java中的日期转化格式DateUtil工具类-（87个方法）

一、Java中的日期转化格式DateUtil工具类 - 简介

二、Java中的日期转化格式DateUtil工具类 - 详细功能介绍

1、clearDate(Date date, int clearNum) - 根据传入的日期和参数将日期对应字段后面所有日期字段清零

2、dateToStrLong(Date date) - 将传入的Date格式化为"yyyy-MM-dd HH:mm:ss"形式，Date没有非空判断

3、format(Calendar date) - 将Calendar类型的时间转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Calendar有非空判断

4、format(Date date) - 将Date类型转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Date有非空判断

5、format(Date date, String pattern) - 将Date类型时间转换为指定格式的字符串

6、format(String date) - 将字符串类型时间转换为Date类型 字符串格式为"yyyy-MM-dd HH:mm:ss"

7、format(String date, String pattern) - 将指定格式的字符串时间类型转换为Date类型

8、getCurDateTimeStr() - 取得当前的时间，格式为 yyyy-MM-dd HH:mm:ss

9、getCurrDate() - 返回当前时间的格式化字符串 字符串格式为：“yyyy-MM-dd HH:mm:ss”

10、getCurrentQuarterEndTime() - 获取当前季度的结束时间

11、getCurrentQuarterStartTime() - 获取当前季度的开始时间

12、getCurrStartAndEndOfWeek() - 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始

13、getCurrStartEndDate() - 获取当期日期的一周 开始和结束日期 返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始

14、getDatePoorHour(Date nowDate, Date endDate) - 计算俩个时间差多少天多少小时

15、getDatePoorMinute(Date nowDate, Date endDate) - 计算俩个时间差多少天多少小时多少分钟

16、getDatePoorTotalMinute(Date nowDate, Date endDate) - 计算俩个时间相差多少分钟

17、getDatetimeDayLimit(String day) - 根据指定的天字符串算出天开始和天结束的时间，精确到秒

18、getDatetimeMonthLimit(String monthStr) - 根据指定的月字符串算出月初和月未的时间，精确到秒 实例：输入：2020-01 输出：Wed Jan 01 00:00:00 CST 2020 Fri

19、getDatetimePreDayLimit(String day) - 根据指定的天字符串算出昨天开始和昨天结束的时间，精确到秒

20、getDatetimePreMonthLimit(String monthStr) - 根据指定的月字符串算出上月月初和月未的时间，精确到秒

21、getDatetimePreSeasonLimit(int year, int nSeason) - 根据指定的年份和季度 算出上一季度 季度初和季度未的时间，精确到秒

22、getDatetimePreYearLimit(int year) - 根据指定的年份数据算出去年年初和年未的时间，精确到秒

23、getDatetimeSeasonLimit(int year, int nSeason) - 根据指定的年份和季度 算出季度初和季度未的时间，精确到秒

24、getDateTimeStr(Date date) - 取得指定时间的时间串，格式为 yyyy-MM-dd HH:mm:ss

25、getDatetimeYearLimit(int year) - 根据指定的年份数据算出年初和年未的时间，精确到秒

26、getDayAfter(Date date, int dayCnt) - 给定日期，得出该日期偏移多少天后的日期

27、getDayAfter(String dateStr, int dayCnt) - 给定的日期字符串，得出该日期字符串偏移多少天后的日期时间

28、getDayDiff(Date date, int dayCnt) - 根据传入的指定日期，给出该日期指定天数后的日期

29、getDayDiff(String dateStr, int dayCnt) - 根据传入的日期字符串，给出该日期指定天数后的日期 实际就是日期相加减

30、getDayHourAfter(Date date, int hourCnt) - 指定日期偏移指定小时后的日期

31、getDayListAfter(Date date, int dayCnt) - 取得指定日期多少天后所有日期的集合 不 包含指定日期的时间

32、getDaysBetween(Date startDate, Date endDate) - 算出俩个时间，所间隔的多少天

33、getDaysBetweenmm(String startDate, String endDate) - 两个时间相差多少天多少小时多少分多少秒

34、getEnd7Days() - 取得前7天结束时间 包含今天 比如 20210303 返回 20210225 23:59:59

35、getEndToday() - 取得今天23:59:59秒时间

36、getEndYestday() - 取得昨天结束时间 23:59:59

37、getFirstDayOfWeek(Date date) - 取得指定日期所在周的第一天 此处认为星期一是一周的第一天 时间是00:00:00

38、getIntervalOfDays(Date fDate, Date oDate) - 获取两个日期相隔天数 去掉时分秒，直接比对日

39、getLastDayOfWeek(Date date) - 取得指定日期所在周的最后一天 此处认为星期日是最后一天 时间到23:59:59 示例： 输入：20210225 返回：Sun Feb 28

40、getMaxWeekOfYear(int year) - 根据传入的年份，给出该年的最大周

41、getMongoDate(Date date) - 取得指定日期 23:59:59的时间 解析失败返回当前时间

42、getMonth(Date date) - 获取指定时间的月份数据

43、getMonthAfter(Date date, int monthCnt) - 取得后多少月的时间

44、getMonthEnd() - 获取本月最后一天

45、getMonthLimit(Date date) - 取得指定日期的当月起始时间 从00:00:00开始 到23:59:59 为止

46、getMonthLimitStr(Date date) - 取得指定日期当月的起始时间字符串 格式是：yyyy-MM-dd HH:mm:ss

47、getMonthStart() - 获取本月开始日期

48、getNeedTime(int hour, int minute, int second, int day) - 传入天、时、份、秒 获取当月指定天数后的指定时间

49、getNextDay(Date date, int number) - 日期相加减

50、getNow() - 获取现在的日期时间

51、getNowAllString() - 获取现在的日期时间(详细到毫秒)

52、getSeason(Date date) - 根据传入的日期，判断日期是第几季度 1 第一季度 2 第二季度 3 第三季度 4 第四季度

53、getSecondAfter(Date date, int secondCnt) - 给定日期，设置偏移多少秒后日期

54、getSimpleDateFormatPattern(String dateStr) - 根据传入的日期 解析出 该用何种SimpleDateFormat并返回对应的SimpleDateFormat

55、getStartAndEndDate(int year, int weeknum) - 返回值说明:返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始 第一周是完整周 不完整的几天算去年最后一周

56、getStartAndEndOfWeekByDate(Date date) - 获取指定日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始

57、getStartToday() - 取得今天开始时间 00:00:00

58、getStatus30Days() - 取得前30天的开始时间 包含今天 比如 20210304 返回 20210203 00:00:00

59、getStatus7Days() - 取得前7天开始时间 包含今天 比如 20210303 返回 20210225 00:00:00

60、getStatusYestday() - 取得昨天的开始时间 00:00:00

61、getTimeByMinute(Date date, int minute) - 获取指定时间几分钟后的时间字符串

62、getTimeMilisecondDesc(long milliSeconds) - 根据传入的long数据给出这个数据有几天，几小时，几分和几秒

63、getToday() - 获取今天的字符串，格式：“yyyy-MM-dd”

64、getWeek(Date date) - 输入指定日期，给出该日期为星期几的字符串说明

65、getWeekEnd() - 获取本周的最后一天

66、getWeekLimit(Date date) - 取得指定日期所在周的起始时间 开始时间从00:00:00 结束时间是 23:59:59 此处认为星期一是一周第一天 星期日是一周最后一天

67、getWeekOfYear(Date date) - 获取指定日期当前周

68、getWeekStart() - 获取本周的第一天

69、getYear(Date date) - 获取指定时间的年份数据

70、getYearAfter(Date date, int yearCnt) - 取得后多少年的时间

71、getYearEnd() - 获取本年的最后一天

72、getYearLimit(Date date) - 取得指定日期的当年起始时间 从00:00:00开始 到23:59:59 为止

73、getYearLimitStr(Date date) - 取得指定日期当年的起始时间串 格式是：yyyy-MM-dd HH:mm:ss

74、getYearStart() - 获取本年的第一天

75、getYestdayStr(Date date) - 取得指定日期 前一天的时间字符串 字符串格式为：yyyy-MM-dd HH:mm:ss

76、getYestdayStr(String dateStr) - 根据传入的日期字符串取得前一天的时间字符串 例如：传入 20200102 返回 2020-01-01 00:00:00

6、format(String date) - 将字符串类型时间转换为Date类型字符串格式为"yyyy-MM-dd HH:mm:ss"

9、getCurrDate() - 返回当前时间的格式化字符串字符串格式为：“yyyy-MM-dd HH:mm:ss”

12、getCurrStartAndEndOfWeek() - 获取当期日期的一周开始至结束日期返回一个Calendar数组，长度为7 星期一作为一周的开始

13、getCurrStartEndDate() - 获取当期日期的一周开始和结束日期返回一个Calendar数组，长度为2 分别是开始日期和结束日期星期一作为一周的开始

18、getDatetimeMonthLimit(String monthStr) - 根据指定的月字符串算出月初和月未的时间，精确到秒实例：输入：2020-01 输出：Wed Jan 01 00:00:00 CST 2020 Fri

21、getDatetimePreSeasonLimit(int year, int nSeason) - 根据指定的年份和季度算出上一季度季度初和季度未的时间，精确到秒

23、getDatetimeSeasonLimit(int year, int nSeason) - 根据指定的年份和季度算出季度初和季度未的时间，精确到秒

29、getDayDiff(String dateStr, int dayCnt) - 根据传入的日期字符串，给出该日期指定天数后的日期实际就是日期相加减

31、getDayListAfter(Date date, int dayCnt) - 取得指定日期多少天后所有日期的集合不包含指定日期的时间

34、getEnd7Days() - 取得前7天结束时间包含今天比如 20210303 返回 20210225 23:59:59

37、getFirstDayOfWeek(Date date) - 取得指定日期所在周的第一天此处认为星期一是一周的第一天时间是00:00:00

38、getIntervalOfDays(Date fDate, Date oDate) - 获取两个日期相隔天数去掉时分秒，直接比对日

39、getLastDayOfWeek(Date date) - 取得指定日期所在周的最后一天此处认为星期日是最后一天时间到23:59:59 示例：输入：20210225 返回：Sun Feb 28

41、getMongoDate(Date date) - 取得指定日期 23:59:59的时间解析失败返回当前时间

45、getMonthLimit(Date date) - 取得指定日期的当月起始时间从00:00:00开始到23:59:59 为止

46、getMonthLimitStr(Date date) - 取得指定日期当月的起始时间字符串格式是：yyyy-MM-dd HH:mm:ss

48、getNeedTime(int hour, int minute, int second, int day) - 传入天、时、份、秒获取当月指定天数后的指定时间

54、getSimpleDateFormatPattern(String dateStr) - 根据传入的日期解析出该用何种SimpleDateFormat并返回对应的SimpleDateFormat

55、getStartAndEndDate(int year, int weeknum) - 返回值说明:返回一个Calendar数组，长度为2 分别是开始日期和结束日期星期一作为一周的开始第一周是完整周不完整的几天算去年最后一周

56、getStartAndEndOfWeekByDate(Date date) - 获取指定日期的一周开始至结束日期返回一个Calendar数组，长度为7 星期一作为一周的开始

58、getStatus30Days() - 取得前30天的开始时间包含今天比如 20210304 返回 20210203 00:00:00

59、getStatus7Days() - 取得前7天开始时间包含今天比如 20210303 返回 20210225 00:00:00

66、getWeekLimit(Date date) - 取得指定日期所在周的起始时间开始时间从00:00:00 结束时间是 23:59:59 此处认为星期一是一周第一天星期日是一周最后一天

72、getYearLimit(Date date) - 取得指定日期的当年起始时间从00:00:00开始到23:59:59 为止

73、getYearLimitStr(Date date) - 取得指定日期当年的起始时间串格式是：yyyy-MM-dd HH:mm:ss

75、getYestdayStr(Date date) - 取得指定日期前一天的时间字符串字符串格式为：yyyy-MM-dd HH:mm:ss

76、getYestdayStr(String dateStr) - 根据传入的日期字符串取得前一天的时间字符串例如：传入 20200102 返回 2020-01-01 00:00:00

83、parseDateByPattern(String dateStr) - 根据传入的日期字符串自动转化为Date类型的时间不需要自己输入格式化方式字符串