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

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
  • 77、getYestoday() – 获取昨天的字符串格式为”yyyy-MM-dd”
  • 78、getYMDDate(Date date, String format) – 获取指定时间根据格式化方式获取的各组成部分
  • 79、parseCalendar(String dateStr) – 根据传入的字符串将字符串转化为Calendar时间
  • 80、parseCalendar(String formatStr, String dateStr) – 根据传入的字符串和字符串格式化类型将字符串转化为Calendar时间
  • 81、parseDate(String dateStr) – 把指定字符串转化为Date
  • 82、parseDate(String formatStr, String dateStr) – 根据传入的字符串和字符串格式化类型将字符串转化为Date时间
  • 83、parseDateByPattern(String dateStr) – 根据传入的日期字符串自动转化为Date类型的时间 不需要自己输入格式化方式字符串
  • 84、parseOriTime(String str) – 将 Date原始格式”EEE MMM dd HH:mm:ss Z yyyy”转成指定格式 “yyyy-MM-dd HH:mm:ss”
  • 85、transFinalFormationStringDate(String date) – 根据指定规则输出指定日期字符串的中文表示
  • 86、transFormationStringDate(String date) – 接收日期格式字符
  • 87、transFormationStringDate(String date, Date newDate, String newDateStr) – 接收日期格式字符转化为中文+日期格式
• 三、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;
	}

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;
	}

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");
	}

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");
	}

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);
	}

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);
	}

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;
	}

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());
	}

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");
	}

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();
	}

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();
	}

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;
	}

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;
	}

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 + "小时";
	}

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;
	}

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;
	}

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) };
	}

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 };
	}

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) };
	}

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 };
	}

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);
	}

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

方法代码如下：

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

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;
	}

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);
	}

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;
	}

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();
	}

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

方法代码如下：

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

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();
	}

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

方法代码如下：

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

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();
	}

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;
	}

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);
	}

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;
	}

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;

	}

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();
	}

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;
	}

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();
	}

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));
	}

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();
	}

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());
	}

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();
	}

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;
	}

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();
	}

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";
	}

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 };
	}

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]) };
	}

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";
	}

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();
	}

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;
	}

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

方法代码如下：

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

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

方法代码如下：

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

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;
	}

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();
	}

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;
	}

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;
	}

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;
	}

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();
	}

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;
	}

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;

	}

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;
	}

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());

	}

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();
	}

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

方法代码如下：

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

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];
	}

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";
	}

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 };
	}

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);
	}

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";
	}

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);
	}

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();
	}

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";
	}

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 };
	}

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]) };
	}

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

方法代码如下：

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

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());
	}

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));
	}

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);
	}

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;
		}
	}

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;
	}

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;
	}

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;
	}

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);
	}

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;
	}

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;
	}

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);
	}

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));

	}

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 "日期格式字符转化错误";
		}
	}

三、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());
	}

}