日期工具类DateUtil

贡献一个比较齐全的日期处理类。

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.convert.converter.Converter;





  public class DateUtil implements Converter<String, Date> {
     /**
	* DateFormat,格式:yyyy-MM-dd
	 */
   	private static DateFormat dateFormat;

	/**
	 * DateFormat,格式:yyyy-MM-dd HH:mm:ss
	 */
	private static DateFormat dateTimeFormat;

	/**
	 * DateFormat,格式:yyyyMMddHHmmss
	 */
	private static DateFormat dateTimeStrFormat;

	/**
	 * DateFormat,格式:yyyy年MM月dd日HH时mm分ss秒
	 *
	 */
	private static DateFormat zhcnDateTimeStrFormat;
	
	private static String twoDecimalFormat = "##0.0";

	/**
	 * 显示日期的格式,yyyy
	 */
	public static final String DATE_YEAE_FORMAT = "yyyy";

	/**
	 * 显示日期的格式,yyyy-MM
	 */
	public static final String DATE_MONTH_FORMAT = "yyyy-MM";

	/**
	 * 显示日期的格式,yyyy-MM-dd
	 */
	public static final String DATE_FORMAT = "yyyy-MM-dd";

	/**
	 * 显示日期的格式,yyyy-MM-dd HH
	 */
	public static final String DATE_HOUR_FORMAT = "yyyy-MM-dd HH";

	/**
	 * 显示日期的格式,yyyy-MM-dd HH:mm
	 */
	public static final String DATE_MIN_FORMAT = "yyyy-MM-dd HH:mm";

	/**
	 * 显示日期的格式,yyyy-MM-dd HH:mm:ss
	 */
	public static final String TIMEF_FORMAT = "yyyy-MM-dd HH:mm:ss";

	/**
	 * 显示日期的格式,yyyy-MM-dd HH:mm:ss.SSS
	 */
	public static final String FULL_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";

	/**
	 * 显示日期的格式,yyyy年 *
	 */
	public static final String ZHCN_YEAR_FORMAT = "yyyy年";

	/**
	 * 显示日期的格式,yyyy年MM月
	 *
	 */
	public static final String ZHCN_MONTH_FORMAT = "yyyy年MM月";

	/**
	 * 显示日期的格式,yyyy年MM月dd日 *
	 */
	public static final String ZHCN_DAY_FORMAT = "yyyy年MM月dd日";

	/**
	 * 显示日期的格式,yyyy年MM月dd日HH时 *
	 */
	public static final String ZHCN_HOUR_FORMAT = "yyyy年MM月dd日HH时";

	/**
	 * 显示日期的格式,yyyy年MM月dd日HH时mm分 *
	 */
	public static final String ZHCN_MIN_FORMAT = "yyyy年MM月dd日HH时mm分";

	/**
	 * 显示日期的格式,yyyy年MM月dd日HH时mm分ss秒 *
	 */
	public static final String ZHCN_TIME_FORMAT = "yyyy年MM月dd日HH时mm分ss秒";

	/**
	 * 显示日期的格式,yyyyMMddHHmmss
	 */
	public static final String TIME_STR_FORMAT = "yyyyMMddHHmmss";
	/**
	 * 显示日期的格式,yyyyMMddHHmmssSSS
	 */
	public static final String TIMESSS_STR_FORMAT = "yyyyMMddHHmmssSSS";
	/**
	 * 显示日期的格式,yyyyMMdd
	 */
	public static final String DATE_STR_FORMAT = "yyyyMMdd";

	/**
	 * 显示日期的格式,yyMMdd
	 */
	public static final String DATE_SIMPLE_SHORT_FORMAT = "yyMMdd";
	
	/**
	 * 表示年
	 */
	public static final int DATE_YEAR = 0;
	
	/**
	 * 表示季节
	 */
	public static final int DATE_SEASON = 1;
	
	/**
	 * 表示月份
	 */
	public static final int DATE_MONTH = 2;

	static {
		dateFormat = new SimpleDateFormat(DATE_FORMAT);
		dateTimeFormat = new SimpleDateFormat(TIMEF_FORMAT);
		dateTimeStrFormat = new SimpleDateFormat(TIME_STR_FORMAT);
		zhcnDateTimeStrFormat = new SimpleDateFormat(ZHCN_TIME_FORMAT);
	}

	// 日期常量
	enum DateConstants {
		TODAY(0), NEARLYWEEK(1), MONTH(2), NEARLYMONTH(3), LASTWEEK(4);
		private int value;

		DateConstants(int value) {
			this.value = value;
		}
	}

	/**
	 *
	 * convertStringToDateFormat:字符串转换为时间格式，仅支持日期，分钟和秒
	 * @param source 时间字符串
	 * @return Date 返回时间类型
	 */
	@Override
	public Date convert(String source) {
		if (StringUtils.isEmpty(source)) {
			return null;
		}

		List<String> formarts = new ArrayList<>();
		formarts.add(DATE_FORMAT);
		formarts.add(DATE_MIN_FORMAT);
		formarts.add(TIMEF_FORMAT);

		if (StringUtils.isEmpty(source)) {
			return null;
		}

		String date = source.trim();
		if (date.matches("^\\d{4}-\\d{1,2}-\\d{1,2}$")) {
			return parseDate(date, formarts.get(0));
		} else if (date.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}$")) {
			return parseDate(date, formarts.get(1));
		} else if (date.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}:\\d{1,2}$")) {
			return parseDate(date, formarts.get(2));
		} else {
			return null;
		}
	}

	/**
	 * 获取当前时间在＋－n分钟后的字符串时间
	 *
	 * @param nMinute 分钟数值
	 * @return String
	 */
	public static String getTimebyMinAfter(int nMinute) {
		Calendar now = Calendar.getInstance(TimeZone.getDefault());
		now.add(Calendar.MINUTE, nMinute);
		return dateTimeFormat.format(now.getTime());
	}

	/**
	 * 获取当前时间在＋－n秒后的字符串时间
	 *
	 * @param n int
	 * @return String
	 */
	public static String getTimebySecAfter(int n) {
		Calendar now = Calendar.getInstance(TimeZone.getDefault());
		now.add(Calendar.SECOND, n);
		return dateTimeFormat.format(now.getTime());
	}

	/**
	 * 获取定义的DateFormat格式
	 *
	 * @param formatStr 时间格式
	 * @return
	 */
	private static DateFormat getDateFormat(String formatStr) {
		if (formatStr.equalsIgnoreCase(DATE_FORMAT)) {
			return dateFormat;
		} else if (formatStr.equalsIgnoreCase(TIMEF_FORMAT)) {
			return dateTimeFormat;
		} else {
			return new SimpleDateFormat(formatStr);
		}
	}

	/**
	 * 将Date转换成字符串“yyyy-mm-dd hh:mm:ss”的字符串
	 *
	 * @param date 日期
	 * @return String 字符串
	 */
	public static String dateToDateString(Date date) {
		return dateToDateString(date, TIMEF_FORMAT);
	}

	/**
	 * 将Date转换成formatStr格式的字符串
	 *
	 * @param date 时间值
	 * @param formatStr 时间格式
	 * @return 返回时间值
	 */
	public static String dateToDateString(Date date, String formatStr) {
		DateFormat df = getDateFormat(formatStr);
		return df.format(date);
	}

	/**
	 * 将字符串的Date转换成指定formatStr格式的字符串
	 *
	 * @param date
	 * @param formatStr
	 * @return
	 */
	public static String dateToDateString(String date, String formatStr) {
		DateFormat df = getDateFormat(formatStr);
		return df.format(date);
	}

	/**
	 * 将Date转换成yyyy-MM-dd的字符串
	 *
	 * @param date 时间值
	 * @return 返回时间值yyyy-MM-dd的字符串
	 */
	public static String getDateString(Date date) {
		DateFormat df = getDateFormat(DATE_FORMAT);
		return df.format(date);
	}

	/**
	 * 将小时数换算成返回以毫秒为单位的时间
	 *
	 * @param hours
	 * @return 返回小时数换算成返回以毫秒为单位的时间
	 */
	public static long getMicroSec(BigDecimal hours) {
		BigDecimal bd;
		bd = hours.multiply(new BigDecimal(3600 * 1000));
		return bd.longValue();
	}

	/**
	 * 获取今天的日期，格式自定
	 *
	 * @param pattern - 设定显示格式
	 * @return String - 返回今天的日期
	 */
	public static String getToday(String pattern) {
		Calendar now = Calendar.getInstance(TimeZone.getDefault());
		DateFormat sdf = getDateFormat(pattern);
		sdf.setTimeZone(TimeZone.getDefault());
		return sdf.format(now.getTime());
	}

	// 得到系统当前的分钟数,如当前时间是上午12:00,系统当前的分钟数就是12*60
	public static int getCurrentMinutes() {
		Calendar now = Calendar.getInstance(TimeZone.getDefault());
		return now.get(Calendar.HOUR_OF_DAY) * 60 + now.get(Calendar.MINUTE);
	}

	/**
	 *
	 * getCurrentMin:获取当前分钟数
	 *
	 * @return int
	 */
	public static int getCurrentMin() {
		Calendar calendar = Calendar.getInstance();
		return calendar.get(Calendar.MINUTE);
	}

	/**
	 * 获取当前日期时间yyyy年MM月dd日HH时mm分ss秒的形式
	 *
	 * @return 当前日期时间yyyy年MM月dd日HH时mm分ss秒的形式
	 */
	public static String getCurZhCNDateTime() {
		return dateToDateString(new Date(), ZHCN_TIME_FORMAT);
	}

	/**
	 * 获取当前时间
	 *
	 * @return
	 */
	public static Date getCurrentDate() {
		return new Date(System.currentTimeMillis());
	}

	/**
	 *
	 * getCurrentDate:按指定格式获取当前时间
	 *
	 * @param format 时间格式
	 * @return String
	 */
	public static String getCurrentDate(String format) {
		String strFormat = TIME_STR_FORMAT;
		if (!StringUtil.isEmptyOrNull(format)) {
			strFormat = format;
		}

		// 设置日期格式
		SimpleDateFormat df = new SimpleDateFormat(strFormat);
		return df.format(new Date());
	}

	/**
	 * @return 得到本月月份 如09
	 */
	public static String getMonth() {
		Calendar now = Calendar.getInstance();
		int month = now.get(Calendar.MONTH) + 1;
		String monStr = String.valueOf(month);

		// 对于10月份以下的月份,加"0"在前面

		if (month < 10){
			monStr = "0" + monStr;
		}
		
		return monStr;
	}

	/**
	 * @return 得到本月第几天
	 */
	public static String getDay() {
		Calendar now = Calendar.getInstance();
		int day = now.get(Calendar.DAY_OF_MONTH);
		String dayStr = String.valueOf(day);

		// 对于10月份以下的月份,加"0"在前面
		if (day < 10){
			dayStr = "0" + dayStr;
		}
		
		return dayStr;
	}

	/**
	 * @return 获取指定日期月份 如09
	 */
	public static String getMonth(Date date) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		int month = now.get(Calendar.MONTH) + 1;
		String monStr = String.valueOf(month);
		// 对于10月份以下的月份,加"0"在前面
		if (month < 10){
			monStr = "0" + monStr;
		}
		
		return monStr;
	}

	/**
	 * @return 获取指定日期天数
	 */
	public static String getDay(Date date) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		int day = now.get(Calendar.DAY_OF_MONTH);
		String dayStr = String.valueOf(day);
		// 对于10月份以下的月份,加"0"在前面
		if (day < 10){
			dayStr = "0" + dayStr;
		}
		
		return dayStr;
	}

	/**
	 * 根据失效时间判断是否依然有效
	 *
	 * @param expireTime 失效时间的字符串形式,格式要求:yyMMddHHmmss
	 * @return true:失效 false:没有失效
	 * @throws ParseException
	 */
	public static boolean isTimeExpired(String expireTime) {
		boolean ret = false;
		try{
			// SimpleDateFormat不是线程安全的,所以每次调用new一个新的对象
			Date date = new SimpleDateFormat(TIME_STR_FORMAT).parse(expireTime);
			Calendar expire = Calendar.getInstance();
			expire.setTime(date);
			Calendar now = Calendar.getInstance();
			// 将毫秒字段设为0,保持精度一致性

			now.set(Calendar.MILLISECOND, 0);
			if (now.after(expire)) {
				ret = true;
			}
		}catch(Exception e){
			LOGGER.error(String.format("DateUtil.isTimeExpired:%s", e));
		}
		
		return ret;
	}

	/**
	 * 根据开始时间和可用时间计算出失效时间
	 * @param startTime 开始时间
	 * @param availableTime 有效时长（单位：秒）
	 * @return 失效时间
	 */
	public static String getExpireTimeByCalculate(Date startTime, int availableTime) {
		Calendar expire = Calendar.getInstance();

		// 设置为开始时间
		expire.setTime(startTime);

		// 开始时间向后有效时长秒得到失效时间
		expire.add(Calendar.SECOND, availableTime);

		// 返回失效时间字符串
		return new SimpleDateFormat(TIME_STR_FORMAT).format(expire.getTime());
	}

	/**
	 * 将Date转换为yyyyMMddHHmmss的形式
	 * @param date
	 * @return 日期的字符串形式,格式：yyyyMMddHHmmss
	 */
	public static String convertDateToString(Date date) {
		return new SimpleDateFormat(TIME_STR_FORMAT).format(date);
	}

	/**
	 * 将Date转换为yyMMddHHmmss的形式
	 * @param date
	 * @return 日期的字符串形式,格式：yyMMddHHmmss
	 */
	public static String convertDateToString(Date date, String format) {
		return new SimpleDateFormat(format).format(date);
	}

	/**
	 * 将yyMMddHHmmss形式的字符串转换成Date的形式
	 * @param date yyMMddHHmmss形式的日期字符串
	 * @return Date对象
	 */
	public static Date convertStringToDate(String date) {
		try{
			return new SimpleDateFormat(TIME_STR_FORMAT).parse(date);
		}catch(Exception e){
			LOGGER.error(String.format("DateUtil.convertStringToDate:%s", e));
		}
		
		return new Date();
	}

	/**
	 * 字符串转化为日期
	 *
	 * @param date 日期字符串
	 * @param formatString 格式化字符串
	 * @return
	 */
	public static Date convertStringToDate(String date, String formatString) {
		try{
			return new SimpleDateFormat(formatString).parse(date);
		}catch(Exception e){
			LOGGER.error(String.format("DateUtil.convertStringToDate:%s", e));
		}
		
		return new Date();
	}

	/**
	 * 日期转化为格式化日期
	 *
	 * @param date 日期
	 * @param formatString 格式化字符串
	 * @return
	 */
	public static Date convertDateToDate(Date date, String formatString) {
		try{
			return new SimpleDateFormat(formatString).parse(convertDateToString(date, formatString));
		}catch(Exception e){
			LOGGER.error(String.format("DateUtil.convertDateToDate:%s", e));
		}
		
		return new Date();
	}

	/**
	 * 字符串转化为格式化字符串格式
	 *
	 * @param date 日期
	 * @param formatString 格式化字符串
	 * @return
	 * 修改日期：2017年10月21日08:35:24 用途：使用字符传的日期格式，会有一个隐性的转换异常，转换会报错
	 */
	public static String convertStringToString(String date, String formatString) {
		try {
			DateFormat df = new SimpleDateFormat(formatString);
			Date dateValue;
			dateValue = DateUtil.convertStringToDate(date, DateUtil.TIMEF_FORMAT);
			return df.format(dateValue);
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.convertStringToString:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 将yy-MM-dd形式的字符串转换成Date的形式
	 *
	 *
	 *
	 * @param date
	 *            yy-MM-dd形式的日期字符串
	 * @return Date对象
	 * @throws ParseException
	 */
	public static Date convertSimpleStringToDate(String date) throws ParseException {
		return new SimpleDateFormat(DATE_FORMAT).parse(date);
	}

	/**
	 * @param date
	 *            yyyyMMddHHmmss格式的日期字符转换为yyyy年MM月dd日HH时mm分ss秒格式的字符串
	 *
	 * @return yyyy年MM月dd日HH时mm分ss秒格式的日期字符串
	 *
	 * @throws ParseException
	 */
	public static String convertStringToZhCN(String date) throws ParseException {
		return zhcnDateTimeStrFormat.format(dateTimeStrFormat.parse(date));
	}

	/**
	 * 时间字符串转换成日期时间的形式
	 *
	 * @param date
	 *            yy-MM-dd HH:mm:ss形式的日期字符串
	 * @return Date对象
	 * @throws ParseException
	 */
	public static Date convertSimpleStringToDateTime(String date) throws ParseException {
		return new SimpleDateFormat(TIMEF_FORMAT).parse(date);
	}

	/**
	 * 获取当天日期
	 */
	public static Date getTodayDate() {
		// 获取昨日的日期
		Calendar cal = Calendar.getInstance();
		return cal.getTime();
	}

	/**
	 * 获取昨日日期 返回格式：yyyy-MM-dd
	 */
	public static String getYesterdayDateStr() {
		// 获取昨日的日期
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_MONTH, -1);
		Date yesterday = cal.getTime();
		return new SimpleDateFormat(DATE_FORMAT).format(yesterday);
	}

	/**
	 * 获取昨日日期 返回格式：yyyy-MM-dd
	 */
	public static Date getYesterdayDate() {
		// 获取昨日的日期
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_MONTH, -1);
		return cal.getTime();
	}

	/**
	 * 获取明天日期 返回格式：yyyy-MM-dd
	 */
	public static String getTomorrowDateStr() {
		// 获取昨日的日期
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_MONTH, 1);
		Date tomorrow = cal.getTime();
		return new SimpleDateFormat(DATE_FORMAT).format(tomorrow);
	}

	/**
	 * 获取明天日期 返回格式：yyyy-MM-dd
	 */
	public static Date getTomorrowDate() {
		// 获取昨日的日期

		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_MONTH, 1);
		return cal.getTime();
	}

	/**
	 * 根据Calendar对象、字符串日期类型获得字符串日期
	 *
	 * @param date
	 *            Calendar对象
	 * @param strDatetype
	 *            字符串日期类型（1：XXXX年XX月XX日，2：XX月XX日，3，XXXX年，4：XXXX-XX-XX，5：XX-XX，6：XXXX）
	 *
	 * @return
	 */
	public static String getStrDate(Calendar calendar, int strDateType) {
		String year = String.valueOf(calendar.get(Calendar.YEAR));
		String month = (calendar.get(Calendar.MONTH) + 1) < 10 ? "0" + (calendar.get(Calendar.MONTH) + 1)
				: String.valueOf

				(calendar.get(Calendar.MONTH) + 1);
		String day = calendar.get(Calendar.DAY_OF_MONTH) < 10 ? "0" + calendar.get(Calendar.DAY_OF_MONTH)
				: String.valueOf

				(calendar.get(Calendar.DAY_OF_MONTH));
		String strDate;

		switch (strDateType) {
		case 1:
			strDate = String.format("%s年%s月%s日", year, month, day);
			break;
		case 2:
			strDate = String.format("%s月%s日", month, day);
			break;
		case 3:
			strDate = String.format("%s年", year);
			break;
		case 5:
			strDate = String.format("%s-%s", month, day);
			break;
		case 6:
			strDate = year;
			break;
		case 4:
		default:
			strDate = String.format("%s-%s-%s", year, month, day);
			break;
		}

		return strDate;
	}

	/**
	 * 根据原来的时间（Date）获得相对偏移 N 月的时间（Date）
	 *
	 * @param protoDate
	 *            原来的时间（java.util.Date）
	 *
	 * @param dateOffset（向前移正数，向后移负数）
	 *
	 * @return 时间（java.util.Date）
	 *
	 */
	public static Date getOffsetMonthDate(Date protoDate, int monthOffset) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(protoDate);
		cal.add(Calendar.MONTH, -monthOffset);
		return cal.getTime();
	}

	/**
	 * 根据原来的时间（Date）获得相对偏移 N 天的时间（Date）
	 *
	 * @param protoDate
	 *            原来的时间（java.util.Date）
	 *
	 * @param dateOffset（向前移正数，向后移负数）
	 *
	 * @return 时间（java.util.Date）
	 *
	 */
	public static Date getOffsetDayDate(Date protoDate, int dateOffset) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(protoDate);
		cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) - dateOffset);
		return cal.getTime();
	}

	/**
	 * 根据原来的时间（Date）获得相对偏移 N 小时的时间（Date）
	 *
	 * @param protoDate
	 *            原来的时间（java.util.Date）
	 *
	 * @param offsetHour
	 *            （向前移正数，向后移负数）
	 *
	 * @return 时间（java.util.Date）
	 *
	 */
	public static Date getOffsetHourDate(Date protoDate, int offsetHour) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(protoDate);
		cal.set(Calendar.HOUR_OF_DAY, cal.get(Calendar.HOUR_OF_DAY) - offsetHour);
		return cal.getTime();
	}

	/**
	 * 获取指定月份和日子的日期(未做日期效验)
	 *
	 * @param currentDate
	 *            当前日期
	 * @param assignYear
	 *            指定年份,-1代表年不做修改
	 * @param assignMonth
	 *            指定月份,从0开始,超过月最大值自动往后加一个月年,-1代表月不做修改
	 * @param assignDay
	 *            指定日,从1开始,超过日最大值往后加一个月,-1代表日不做修改
	 * @return 修改后的日期
	 */
	public static Date getAssignDate(Date currentDate, int assignYear, int assignMonth, int assignDay) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(currentDate);
		if (assignYear > -1) {
			cal.set(Calendar.YEAR, assignYear);
		}
		if (assignMonth > -1) {
			cal.set(Calendar.MONTH, assignMonth);
		}
		if (assignDay > -1) {
			cal.set(Calendar.DAY_OF_MONTH, assignDay);
		}
		return cal.getTime();
	}

	/**
	 * 获得两个日前之间相差的小时数
	 *
	 * @param startDate
	 *            开始日期
	 * @param endDate
	 *            结束日期
	 * @return 小时数
	 */
	public static int getHourCountBetweenDate(Date startDate, Date endDate) {
		Calendar startCalendar = Calendar.getInstance();
		startCalendar.setTime(startDate);
		startCalendar.set(Calendar.MINUTE, 0);
		startCalendar.set(Calendar.SECOND, 0);

		Calendar endCalendar = Calendar.getInstance();
		endCalendar.setTime(endDate);
		endCalendar.set(Calendar.MINUTE, 0);
		endCalendar.set(Calendar.SECOND, 0);

		int i = 0;
		while (endCalendar.compareTo(startCalendar) >= 0) {
			startCalendar.set(Calendar.HOUR_OF_DAY, startCalendar.get(Calendar.HOUR_OF_DAY) + 1);
			i++;
		}
		return i;
	}

	/**
	 * 获得两个日前之间相差的天数,有时分秒的影响
	 *
	 * @param startDate
	 *            开始日期
	 *
	 * @param endDate
	 *            结束日期
	 * @return 天数
	 */
	public static int getDayCountBetweenDate(Date startDate, Date endDate) {
		Calendar startCalendar = Calendar.getInstance();
		startCalendar.setTime(startDate);
		Calendar endCalendar = Calendar.getInstance();
		endCalendar.setTime(endDate);
		int i = 0;
		while (endCalendar.compareTo(startCalendar) >= 0) {
			startCalendar.set(Calendar.DAY_OF_MONTH, startCalendar.get(Calendar.DAY_OF_MONTH) + 1);
			i++;
		}
		return i;
	}

	/**
	 * 获得两个日前之间相差的月份
	 *
	 * @param startDate
	 *            开始日期
	 *
	 * @param endDate
	 *            结束日期
	 * @return 月数
	 */
	public static int getMonthCountBetweenDate(Date startDate, Date endDate) {
		Calendar startCalendar = Calendar.getInstance();
		startCalendar.setTime(startDate);
		Calendar endCalendar = Calendar.getInstance();
		endCalendar.setTime(endDate);
		int i = 0;
		while (endCalendar.compareTo(startCalendar) >= 0) {
			startCalendar.set(Calendar.MONTH, startCalendar.get(Calendar.MONTH) + 1);
			i++;
		}
		return i;
	}

	/**
	 * 获得两个日前之间相差的年
	 *
	 * @param startDate
	 *            开始日期
	 *
	 * @param endDate
	 *            结束日期
	 * @return 年
	 */
	public static int getYearlyCountBetweenDate(Date startDate, Date endDate) {
		Calendar startCalendar = Calendar.getInstance();
		startCalendar.setTime(startDate);
		Calendar endCalendar = Calendar.getInstance();
		endCalendar.setTime(endDate);
		int i = 0;
		while (endCalendar.compareTo(startCalendar) >= 0) {
			startCalendar.set(Calendar.YEAR, startCalendar.get(Calendar.YEAR + 1));
			i++;
		}
		return i;
	}

	/**
	 * 根据原来的时间（Date）获得相对偏移 N 天的时间（Date）
	 * @param protoDate 原来的时间（java.util.Date）
	 * @param dateOffset（向前移正数，向后移负数）
	 * @param type 指定不同的格式（1：年月日，2：年月日时，3：年月日时分）
	 * @return 时间（java.util.Date），没有时分秒
	 */
	public static Date getOffsetSimpleDate(Date protoDate, int dateOffset, int type) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(protoDate);
		cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) - dateOffset);
		if (type == 1) {
			cal.set(Calendar.HOUR_OF_DAY, 0);
			cal.set(Calendar.MINUTE, 0);
		}
		if (type == 2) {
			cal.set(Calendar.MINUTE, 0);
		}
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		return cal.getTime();
	}

	/**
	 * 时间转为化为字符串
	 * 格式为：yyyyMMddHHmmssSSS
	 * @return
	 */
	public static String getDateToString() {
		SimpleDateFormat dateFormat = new SimpleDateFormat(TIMESSS_STR_FORMAT);
		Date date = new Date();
		return dateFormat.format(date);
	}

	/**
	 * 时间转为化为字符串
	 * 格式为：yyyy-MM-dd HH:mm:ss
	 * @return
	 */
	public static String getTodayTimeString() {
		SimpleDateFormat dateFormat = new SimpleDateFormat(TIMEF_FORMAT);
		Date date = new Date();
		return dateFormat.format(date);
	}

	/**
	 * 增加秒
	 * @param dateTime 时间值
	 * @param nSecond 增加秒数
	 * @return 返回时间值
	 */
	public static Date addSecond(Date dateTime, int nSecond) {
		Calendar cd = Calendar.getInstance();
		cd.setTime(dateTime);
		cd.add(Calendar.SECOND, nSecond);// 增加秒
		return cd.getTime();
	}

	/**
	 * 增加秒
	 * @param dateTime 时间值
	 * @param nSecond 增加秒数
	 * @param formatstring 时间格式
	 * @return 返回时间值
	 */
	public static String addSecond(Date m, int n, String formatstring) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
			Calendar cd = Calendar.getInstance();
			cd.setTime(m);
			cd.add(Calendar.SECOND, n);// 增加秒
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.addSecond formatstring:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 增加秒
	 * @param dateTime 时间值
	 * @param nSecond 增加秒数
	 * @return 返回时间值
	 */
	public static String addSecond(String dateTime, int nSecond) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.TIMEF_FORMAT);
			Calendar cd = Calendar.getInstance();
			cd.setTime(sdf.parse(dateTime));
			cd.add(Calendar.SECOND, nSecond);// 增加秒
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.addSecond:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 增加分钟
	 * @param dateTime 时间值
	 * @param nMinute 分钟数
	 * @return 返回时间值
	 */
	public static Date addMinute(Date dateTime, int nMinute) {
		Calendar cd = Calendar.getInstance();
		cd.setTime(dateTime);
		cd.add(Calendar.MINUTE, nMinute);// 增加分钟
		return cd.getTime();
	}

	/**
	 * 增加分钟
	 * @param dateTime 时间值
	 * @param nMinute 分钟数
	 * @param formatstring 时间格式
	 * @return 返回时间值
	 */
	public static String addMinute(Date dateTime, int nMinute, String formatstring) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
			Calendar cd = Calendar.getInstance();
			cd.setTime(dateTime);
			cd.add(Calendar.MINUTE, nMinute);// 增加分钟
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.addMinute:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 增加小时
	 * @param dateTime 时间值
	 * @param nHour 小时数
	 * @return 返回时间值
	 */
	public static Date addHour(Date dateTime, int nHour) {
		Calendar cd = Calendar.getInstance();
		cd.setTime(dateTime);
		cd.add(Calendar.HOUR_OF_DAY, nHour);// 增加小时
		return cd.getTime();
	}

	/**
	 * 增加小时
	 * @param dateTime 时间值
	 * @param nHour 小时数
	 * @param formatstring 时间格式
	 * @return 返回时间值
	 */
	public static String addHour(Date dateTime, int nHour, String formatstring) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
			Calendar cd = Calendar.getInstance();
			cd.setTime(dateTime);
			cd.add(Calendar.HOUR_OF_DAY, nHour);// 增加小时
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.addHour:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 增加一天
	 * @param dateTime 时间值
	 * @param nDay 天数
	 * @return 返回时间值
	 */
	public static String addDay(String dateTime, int nDay) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.DATE_FORMAT);
			Calendar cd = Calendar.getInstance();
			cd.setTime(sdf.parse(dateTime));
			cd.add(Calendar.DATE, nDay);// 增加一天
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.addDay:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 增加一天
	 * @param dateTime 时间值
	 * @param nDay 天数
	 * @return 返回时间值
	 */
	public static Date addDay(Date dateTime, int nDay) {
		Calendar cd = Calendar.getInstance();
		cd.setTime(dateTime);
		cd.add(Calendar.DATE, nDay);// 增加一天
		return cd.getTime();
	}

	/**
	 * 增加一个月
	 * @param dateTime 时间值
	 * @param nMonth 增加月份值
	 * @return String 返回增加月份后的时间
	 */
	public static Date addMonth(Date dateTime, int nMonth) {
		Calendar cd = Calendar.getInstance();
		cd.setTime(dateTime);
		cd.add(Calendar.MONTH, nMonth);// 增加一个月
		return cd.getTime();
	}

	/**
	 * 增加一个月
	 * @param dateTime 时间值
	 * @param nMonth 增加月份值
	 * @param formatstring 时间格式
	 * @return String 返回增加月份后的时间
	 */
	public static String addMonth(Date dateTime, int nMonth, String formatstring) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
			Calendar cd = Calendar.getInstance();
			cd.setTime(dateTime);
			cd.add(Calendar.MONTH, nMonth);// 增加一个月
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.addMonth formatstring:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 增加N个月
	 * @param dateTime 时间值
	 * @param nMonth 增加月份值
	 * @param formatstring 时间格式
	 * @return String 返回增加月份后的时间
	 */
	public static String addMonth(String dateTime, int nMonth, String format) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(format);
			Calendar cd = Calendar.getInstance();
			cd.setTime(sdf.parse(dateTime));
			cd.add(Calendar.MONTH, nMonth);// 增加一个月
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 增加月份
	 * @param dateTime 时间值
	 * @param nMonth 增加月份值
	 * @return String 返回增加月份后的时间
	 */
	public static String addMonth(String dateTime, int nMonth) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.DATE_FORMAT);
			Calendar cd = Calendar.getInstance();
			cd.setTime(sdf.parse(dateTime));
			cd.add(Calendar.MONTH, nMonth);// 增加一个月
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.addMonth:%s", e));
		}

		return StringUtil.empty();
	}

	/**
	 * 方法描述:增加年
	 * @param dateTime 时间值
	 * @param nYear 增加年数值
	 * @param formatstring 时间格式
	 * @return 返回时间字符串
	 */
	public static String addYear(Date dateTime, int nYear, String formatstring) {
		Calendar cd = Calendar.getInstance();
		cd.setTime(dateTime);
		cd.add(Calendar.YEAR, nYear);
		DateFormat sdf = new SimpleDateFormat(formatstring);
		return sdf.format(cd.getTime());
	}

	/**
	 * 获取需要执行的统计的日期数组
	 * @return 格式['2011-01-01',2011-01-02']
	 */
	public static String[] getExecDay(Date lastDate) {
		String[] day = null;
		// 获取昨天日期
		Date yesdate = null;
		try {
			yesdate = DateUtil.convertDateToDate(DateUtil.getYesterdayDate(), DateUtil.DATE_FORMAT);
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.getExecDay:%s", e));
		}
		// 获取上次最后执行日期与昨天相隔天数
		int dayCount = DateUtil.getDayCountBetweenDate(lastDate, yesdate);
		if (dayCount <= 0) {
			return day;
		}
		if (dayCount == 1) {
			return new String[] { DateUtil.getYesterdayDateStr() };
		} else {
			day = new String[dayCount];
			for (int i = 0; i < dayCount; i++) {
				String date = new SimpleDateFormat(DateUtil.DATE_HOUR_FORMAT).format(DateUtil.addDay(lastDate, i));
				day[i] = date;
			}
		}

		return day;
	}

	/**
	 * 获取需要执行的统计的年-月数组
	 * @return 格式['2011-01',2011-01']
	 */
	public static String[] getExecYearMonth(Date lastYearMonth) {
		String[] yearMonth = null;
		// 获取上个月日期
		Date lastMonth = DateUtil.getOffsetMonthDate(new Date(), 1);
		try {
			lastMonth = DateUtil.convertDateToDate(lastMonth, DateUtil.DATE_MONTH_FORMAT);
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.getExecYearMonth:%s", e));
		}
		// 获取上次最后执行日期与昨天相隔天数
		int monthCount = DateUtil.getMonthCountBetweenDate(lastYearMonth, lastMonth);
		if (monthCount <= 0) {
			return yearMonth;
		}
		if (monthCount == 1) {
			return new String[] { DateUtil.convertDateToString(lastMonth, DateUtil.DATE_MONTH_FORMAT) };
		} else {
			yearMonth = new String[monthCount];
			for (int i = 0; i < monthCount; i++) {
				String date = DateUtil.addMonth(lastYearMonth, i, DateUtil.DATE_MONTH_FORMAT);
				yearMonth[i] = date;
			}
		}

		return yearMonth;
	}

	/**
	 * 获取当月第一天
	 * @return 返回当月第一天
	 */
	public static Date getFirstDayOfMonth() {
		Calendar ca = Calendar.getInstance();
		ca.set(Calendar.DAY_OF_MONTH, 1);
		Date firstDate = ca.getTime();
		ca.add(Calendar.MONTH, 1);
		ca.add(Calendar.DAY_OF_MONTH, -1);
		return firstDate;
	}

	/**
	 * 获当月的最后一天
	 * @return 返回当月的最后一天
	 */
	public static Date getLastDayOfMonth() {
		Calendar ca = Calendar.getInstance();
		ca.set(Calendar.DAY_OF_MONTH, 1);
		ca.add(Calendar.MONTH, 1);
		ca.add(Calendar.DAY_OF_MONTH, -1);
		return ca.getTime();
	}

	/**
	 *
	 * getBeginTime:获取指定月份的开始时间
	 * @param year 年份
	 * @param month 月份
	 * @return String 返回指定月份的开始时间
	 */
	public static String getBeginTime(int year, int month) {
		YearMonth yearMonth = YearMonth.of(year, month);
		LocalDate localDate = yearMonth.atDay(1);
		LocalDateTime startOfDay = localDate.atStartOfDay();
		ZonedDateTime zonedDateTime = startOfDay.atZone(ZoneId.of("Asia/Shanghai"));

		return convertDateToString(Date.from(zonedDateTime.toInstant()), DateUtil.DATE_FORMAT) + " 00:00:00";
	}

	/**
	 *
	 * getEndTime:获取指定月份的结束时间
	 * @param year 年份
	 * @param month 月份
	 * @return String 返回指定月份的结束时间
	 */
	public static String getEndTime(int year, int month) {
		YearMonth yearMonth = YearMonth.of(year, month);
		LocalDate endOfMonth = yearMonth.atEndOfMonth();
		LocalDateTime localDateTime = endOfMonth.atTime(23, 59, 59, 999);
		ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.of("Asia/Shanghai"));

		return convertDateToString(Date.from(zonedDateTime.toInstant()), DateUtil.DATE_FORMAT) + " 23:59:59";
	}

	/**
	 * 获取日期所在月份的天数
	 * @return 返回日期所在月份的天数
	 */
	public static int getDaysOfMonth(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 获取一天的最后时间，常用于时间段查询的结束时间的处理
	 * @param dateTime 时间值
	 * @return 得到的时间为在d的23:59:59
	 */
	public static Date getLastTimeOfDay(Date dateTime) {
		Date date = dateTime;
		if (null == date) {
			date = DateUtil.getCurrentDate();
		}

		Calendar ca = Calendar.getInstance();
		ca.setTime(date);
		ca.add(Calendar.DAY_OF_MONTH, 1);
		ca.add(Calendar.MILLISECOND, -1);
		date = ca.getTime();

		return date;
	}

	/**
	 * getWeekDay(); 获查询日期区间 今天(0), 近一周(1), 本月(2),近一月(3),上一周(4) ;
	 * @return Date[0] 开始时间 Date[1] 结束时间
	 */
	public static Date[] getDateSection(int dateType) {
		Date[] dateSection = new Date[2];
		if (DateConstants.TODAY.value == dateType) {
			dateSection[0] = getTodayDate();
			dateSection[1] = dateSection[0];
		} else if (DateConstants.NEARLYWEEK.value == dateType) {
			dateSection[0] = getOffsetDayDate(getTodayDate(), 6);
			dateSection[1] = getTodayDate();
		} else if (DateConstants.NEARLYMONTH.value == dateType) {
			dateSection[0] = getOffsetMonthDate(getTodayDate(), 1);
			dateSection[1] = getTodayDate();
		} else if (DateConstants.MONTH.value == dateType) {
			dateSection[0] = getFirstDayOfMonth();
			dateSection[1] = getLastDayOfMonth();
		} else if (DateConstants.LASTWEEK.value == dateType) {
			dateSection[0] = getOffsetDayDate(getTodayDate(), getWeekDay() + 6);
			dateSection[1] = getOffsetDayDate(getTodayDate(), getWeekDay());
		} else {
			dateSection = null;
		}

		return dateSection;
	}

	public static boolean isNumberic(String str) {
		if (StringUtil.isEmpty(str)) {
			return false;
		}

		int sz = str.length();
		for (int i = 0; i < sz; i++) {
			if (!Character.isDigit(str.charAt(i))) {
				return false;
			}
		}

		return true;
	}

	/**
	 * 将日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
	 * @param date 时间类型时间值
	 * @param format 时间格式
	 * @return 返回日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
	 */
	public static String convertDateToOracleToDateExp(Date date, String format) {
		return "TO_DATE('" + new SimpleDateFormat(format).format(date) + "','YYYY-MM-DD HH24:MI:SS')";
	}

	/**
	 * 将日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
	 * @param date 时间类型时间
	 * @return 返回oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
	 */
	public static String convertDateToOracleToDateExp(Date date) {
		return convertDateToOracleToDateExp(date, TIMEF_FORMAT);
	}

	/**
	 * 将日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
	 *
	 * @param date 时间字符串时间
	 * @return 返回oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
	 */
	public static String convertDateToOracleToDateExp(String dateStr) {
		return "TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')";
	}

	/**
	 * 方法描述:将日期String，按照日期格式转成日期
	 * @param strDate 时间字符串
	 * @param formate 时间格式
	 * @return 返回时间类型的时间值
	 */
	public static Date parseDate(String strDate, String formate) {
		DateFormat df = new SimpleDateFormat(formate);
		Date date = null;
		try {
			date = df.parse(strDate);
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.parseDate:%s", e));
			date = null;
		}

		return date;
	}

	/**
	 * 方法描述:获取日期的年份
	 * @param date 时间
	 * @return 返回日期的年份
	 */
	public static int getYearByDate(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.YEAR);
	}

	/**
	 * 方法描述:添加小时
	 * @param addHour 增加小时数
	 * @return 返回增加小时数后的时间
	 */
	public static Date addHour(int addHour) {
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.HOUR_OF_DAY, addHour);
		return calendar.getTime();
	}

	/**
	 * 获取当年的第一天
	 * @return 返回当年的第一天
	 */
	public static Date getCurrYearFirst() {
		Calendar currCal = Calendar.getInstance();
		int currentYear = currCal.get(Calendar.YEAR);
		return getYearFirst(currentYear);
	}

	/**
	 * 获取当年的最后一天
	 * @return 返回当年的最后一天
	 */
	public static Date getCurrYearLast() {
		Calendar currCal = Calendar.getInstance();
		int currentYear = currCal.get(Calendar.YEAR);
		return getYearLast(currentYear);
	}

	/**
	 * 获取某年第一天日期
	 * @param year 年份
	 * @return Date 返回某年第一天日期
	 */
	public static Date getYearFirst(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		return calendar.getTime();
	}

	/**
	 * 获取某年最后一天日期
	 * @param year 年份
	 * @return Date 返回某年最后一天日期
	 */
	public static Date getYearLast(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		calendar.roll(Calendar.DAY_OF_YEAR, -1);
		return calendar.getTime();
	}

	/**
	 * 获得某个月最大天数
	 * @param dateTime 时间
	 * @return int 某个月最大天数
	 */
	public static int getMaxDayByYearMonth(String dateTime) {
		int days = 0;
		SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
		Date date;
		try {
			date = sdf.parse(dateTime);
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			days = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
		} catch (ParseException e) {
			LOGGER.error(String.format("DateUtil.getMaxDayByYearMonth:%s", e));
		}

		return days;
	}

	/**
	 * 两个时间之间相差距离多少天
	 * @param startTime 起始时间
	 * @param endTime 结束时间
	 * @return long 返回两个时间相差天数
	 */
	public static long getDistanceDays(String startTime, String endTime) {
		DateFormat df = new SimpleDateFormat(DATE_FORMAT);
		Date one;
		Date two;
		long days = 0;
		try {
			one = df.parse(startTime);
			two = df.parse(endTime);
			long time1 = one.getTime();
			long time2 = two.getTime();
			long diff;
			if (time1 < time2) {
				diff = time2 - time1;
			} else {
				diff = time1 - time2;
			}
			days = diff / (1000 * 60 * 60 * 24);
		} catch (Exception e) {
			LOGGER.error(String.format("DateUtil.getDistanceDays:%s", e));
		}

		return days;
	}

	/**
	 * 判断时间是否在时间段内
	 * @param date 当前时间 yyyy-MM-dd HH:mm:ss
	 * @param strDateBegin 开始时间 00:00:00
	 * @param strDateEnd 结束时间 00:05:00
	 * @return boolean 返回时间是否在时间段内
	 */
	public static boolean isInDate(Date date, String strDateBegin, String strDateEnd) {
		SimpleDateFormat sdf = new SimpleDateFormat(TIMEF_FORMAT);
		String strDate = sdf.format(date);
		// 截取当前时间时分秒
		int strDateH = Integer.parseInt(strDate.substring(11, 13));
		int strDateM = Integer.parseInt(strDate.substring(14, 16));
		int strDateS = Integer.parseInt(strDate.substring(17, 19));
		// 截取开始时间时分秒
		int strDateBeginH = Integer.parseInt(strDateBegin.substring(0, 2));
		int strDateBeginM = Integer.parseInt(strDateBegin.substring(3, 5));
		int strDateBeginS = Integer.parseInt(strDateBegin.substring(6, 8));
		// 截取结束时间时分秒
		int strDateEndH = Integer.parseInt(strDateEnd.substring(0, 2));
		int strDateEndM = Integer.parseInt(strDateEnd.substring(3, 5));
		int strDateEndS = Integer.parseInt(strDateEnd.substring(6, 8));
		if ((strDateH >= strDateBeginH && strDateH <= strDateEndH)) {
			// 当前时间小时数在开始时间和结束时间小时数之间
			if (strDateH > strDateBeginH && strDateH < strDateEndH) {
				return true;
				// 当前时间小时数等于开始时间小时数，分钟数在开始和结束之间
			} else if (strDateH == strDateBeginH && strDateM >= strDateBeginM && strDateM <= strDateEndM) {
				return true;
				// 当前时间小时数等于开始时间小时数，分钟数等于开始时间分钟数，秒数在开始和结束之间
			} else if (strDateH == strDateBeginH && strDateM == strDateBeginM && strDateS >= strDateBeginS
					&& strDateS <= strDateEndS) {
				return true;
			}
			// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数小等于结束时间分钟数
			else if (strDateH == strDateEndH && strDateM <= strDateEndM) {
				return true;
				// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数等于结束时间分钟数，秒数小等于结束时间秒数
			} else if (strDateH == strDateEndH && strDateS <= strDateEndS) {
				return true;
			} else {
				return false;
			}
		} else {
			return false;
		}
	}

	/**
	 *
	 * getWeekDay:获取当前时间星期几
	 * @return int
	 */
	public static int getWeekDay() {
		Calendar now = Calendar.getInstance();
		// 一周第一天是否为星期天
		boolean isFirstSunday = now.getFirstDayOfWeek() == Calendar.SUNDAY;
		// 获取周几
		int weekDay = now.get(Calendar.DAY_OF_WEEK);
		// 若一周第一天为星期天，则-1
		if (isFirstSunday) {
			weekDay = weekDay - 1;
			if (weekDay == 0) {
				weekDay = 7;
			}
		}

		return weekDay;
	}

	/**
	 * getWeekDay:计算传入时间星期几
	 * @param date 传入时间
	 * @return 返回传入时间星期几
	 */
	public static int getWeekDay(Date date) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		// 一周第一天是否为星期天
		boolean isFirstSunday = now.getFirstDayOfWeek() == Calendar.SUNDAY;
		// 获取周几
		int weekDay = now.get(Calendar.DAY_OF_WEEK);
		// 若一周第一天为星期天，则-1
		if (isFirstSunday) {
			weekDay = weekDay - 1;
			if (weekDay == 0) {
				weekDay = 7;
			}
		}

		return weekDay;
	}

	/**
	 *
	 * getDistanceHours: 计算两个时间段之间相差的小时数
	 * @param startTime 开始时间
	 * @param endTime 结束时间
	 * @return 返回两个时间段之间相差的小时数
	 */
	public static double getDistanceHours(String startTime, String endTime) {
		DateFormat df = new SimpleDateFormat(TIMEF_FORMAT);
		DecimalFormat dec = new DecimalFormat(twoDecimalFormat);
		Date one;
		Date two;
		String hours = "";
		try {
			one = df.parse(startTime);
			two = df.parse(endTime);
			long time1 = one.getTime();
			long time2 = two.getTime();
			double diff;
			diff = Math.abs(time1 - time2);
			hours = dec.format(diff / (1000 * 60 * 60));
		} catch (ParseException e) {
			LOGGER.error(String.format("DateUtil.getDistanceHours:%s", e));
		}

		return Double.valueOf(hours);
	}

	/**
	 *
	 * getDistanceSecond: 计算两个时间段之间相差的秒数
	 * @param startTime 开始时间
	 * @param endTime 结束时间
	 * @return 返回两个时间段之间相差的秒数
	 */
	public static int getDistanceSecond(String startTime, String endTime) {
		DateFormat df = new SimpleDateFormat(TIMEF_FORMAT);
		DecimalFormat dec = new DecimalFormat(twoDecimalFormat);
		Date one;
		Date two;
		String seconds = "";
		try {
			one = df.parse(startTime);
			two = df.parse(endTime);
			long time1 = one.getTime();
			long time2 = two.getTime();
			double diff = (double)(time1 - time2);
			seconds = dec.format(diff / (1000));
		} catch (ParseException e) {
			LOGGER.error(String.format("DateUtil.getDistanceSecond:%s", e));
		}

		return Double.valueOf(seconds).intValue();
	}

	/**
	 *
	 * getDistanceSecond: 计算距离当前时间相差的秒数
	 * @param startTime 起始时间
	 * @return 返回距离当前时间相差的秒数
	 */
	public static int getDistanceSecond(String startTime) {
	    DateFormat df = new SimpleDateFormat(TIMEF_FORMAT);
	    DecimalFormat dec = new DecimalFormat("##0.0");
	    Date one;
	    Date two = new Date();
	    String hours = "";
	    try {
	      one = df.parse(startTime);
	      long time1 = one.getTime();
	      long time2 = two.getTime();
	      long diff = time1 - time2;
	      hours = dec.format(diff / (1000));
	    } catch (ParseException e) {
	      LOGGER.error(String.format("DateUtil.getDistanceSecond:%s", e));
	    }

	    return Double.valueOf(hours).intValue();
	  }

	/**
	 *
	 * getDistanceMin:计算日期相差分钟数
	 * @param startTime 开始时间
	 * @param endTime 结束时间
	 * @return 返回两个时间相差分钟数
	 */
	public static long getDistanceMin(Date startTime, Date endTime) {
		return (startTime.getTime() - endTime.getTime())/ (1000 * 60);
	}
	
	/**
	 * 根据传入的时间和state判断是年、季或者月报
	 * @param dateTime 时间
	 * @param state 类型 0：年，1：季， 2 月
	 * @return
	 */
	public static String getTime(String dateTime, int state) {
        Date date = parseDate(dateTime, TIMEF_FORMAT);        
        String time = StringUtil.empty();
        switch(state) {
        	case DATE_YEAR:{
                time = convertDateToOracleToDateExp(date, ZHCN_YEAR_FORMAT);                
            }
        	break;
        	case DATE_SEASON:{
        		String season = StringUtil.empty();
                int month = Integer.parseInt(getMonth(date));
                if (month < 3){
                	season = "一";
                }else if (month < 6){
                	season = "二";
                }else if (month < 10){
                	season = "三";
                }else{
                	season = "四";
                }
                time = convertDateToOracleToDateExp(date, ZHCN_YEAR_FORMAT) + String.format("第%s季度", season);              
            }
        	break;
        	case DATE_MONTH:{
                time = convertDateToOracleToDateExp(date, ZHCN_MONTH_FORMAT);                 
            }
        	break;
        }
        
        return time;
    }
}