工具类-时间处理类

最新推荐文章于 2024-01-23 07:00:00 发布
秃然变可爱的小猫咪
最新推荐文章于 2024-01-23 07:00:00 发布
阅读量182
点赞数
分类专栏： java-工具类
本文链接：https://blog.csdn.net/u014692224/article/details/104774508
版权
java-工具类专栏收录该内容
8 篇文章 0 订阅
订阅专栏
时间处理类

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FecVZnlh-1583822931374)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1583822892308.png)]$
package com.mytest.TimeUtils;

import java.sql.Timestamp;
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.HashMap;
import java.util.List;
import java.util.Map;

import org.joda.time.Days;
import org.joda.time.Hours;
import org.joda.time.LocalDate;
import org.joda.time.Minutes;
import org.joda.time.Months;
import org.joda.time.Seconds;
import org.joda.time.Weeks;
import org.joda.time.Years;

public class TimeUtil {
	/**
	 * 获取当前时间,格式如Tue Sep 13 17:31:44 CST 2016
	 *
	 * @return <code>Date</code>获取当前时间
	 */
	public static Date getDate() {
		Calendar calendar = Calendar.getInstance();
		return calendar.getTime();
	}
	
	
	/**
	 * 根据指定的格式将字符串转换成Date对象，如果没有指定格式则采用默认语言环境的格式
	 * @param text			字符串
	 * @param pattern		日期格式
	 * @return Date			Date对象
	 * @throws Exception
	 */
	public static Date getDate(String text, String pattern) throws Exception {
		Date date = null;
		
		if (null!=text&&""!=text) {
			SimpleDateFormat format = null;
			if (isBlank(pattern)) {
				format = new SimpleDateFormat();
			} else {
				format = new SimpleDateFormat(pattern);
			}
			date = format.parse(text);
		}
		
		return date;
	}
	
	public static boolean isBlank(String text){
		if (null!=text&&""!=text) {
			return true;
		}else{
			return false;
		}
	}
	
	
	/**
	 * 按指定的格式将日期型数据格式化输出，如果没有指定格式则采用默认语言环境的格式
	 * @param Date			日期对象
	 * @param pattern		日期格式
	 * @return String		格式化后的字符串
	 * @throws Exception
	 */
	public static String format(Date date, String pattern) throws Exception {
		String text = null; 
		
		if (date != null) {
			SimpleDateFormat format = null;
			if (isBlank(pattern)) {
				format = new SimpleDateFormat();
			} else {
				format = new SimpleDateFormat(pattern);
			}
			text = format.format(date);
		}

		return text;
	}
	
	
	/**
	 * 按指定的格式将Timestamp型数据格式化输出，如果没有指定格式则采用默认语言环境的格式
	 * @param timestamp		Timestamp对象
	 * @param pattern		日期格式
	 * @return String		格式化后的字符串
	 * @throws Exception
	 */
	public static String format(Timestamp timestamp, String pattern) throws Exception {
		return format((Date) timestamp, pattern);
	}
	
	/**
	 * 按指定域调整时间，时间域同Calendar类中定义的YEAR、MONTH、DATE、DAY_OF_MONTH、HOUR、MINUTE、SECOND、MILLISECOND等
	 * @param date			Date日期对象
	 * @param field			日期格式
	 * @param value			调整的幅度
	 * @return Date			返回调整后的时间
	 * @throws Exception
	 */
	public static Date add(Date date, int field, int value) throws Exception {
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.add(field, value);
		return calendar.getTime();
	}

	/**
	 * 按指定域调整时间，时间域同Calendar类中定义的YEAR、MONTH、DATE、DAY_OF_MONTH、HOUR、MINUTE、SECOND、MILLISECOND等
	 * @param timestamp		Timestamp日期对象
	 * @param field			日期格式
	 * @param value			调整的幅度
	 * @return Timestamp	返回调整后的时间
	 * @throws Exception
	 */
	public static Timestamp add(Timestamp timestamp, int field, int value) throws Exception {
		Date date = add((Date)timestamp, field, value);
		return new Timestamp(date.getTime());
	}

	/**
	 * 时间格式转换，即字符串表示的时间从一种格式转换成另一种格式
	 * @param text			字符串时间
	 * @param pattern1		当前时间格式
	 * @param pattern2		转换时间格式
	 * @return String 		返回转换后的字符串时间
	 * @throws Exception
	 */
	public static String dateFormatConvert(String text, String pattern1, String pattern2) throws Exception {
		if (isBlank(text)) {
			return null;
		} else {
			Date date = getDate(text, pattern1);
			return format(date, pattern2);
		}
	}
	 
    

    /**
     * 计数两个日期之间的相差的日期部分，日期部分可以为年（Calendar.YEAR）、月（Calendar.MONTH）、日（Calendar.DAY_OF_MONTH）、时（Calendar.HOUR）、分（Calendar.MINUTE）、秒（Calendar.SECOND）
     * @param startDate		开始日期
     * @param endDate		结束日期
     * @param fieldType		日期部分类型
     * @return long			日期部分差额
     */
    public static long countDateField(Date startDate, Date endDate, int fieldType) throws Exception {
        long count = 0;
        
        if (startDate == null || endDate == null) {
        	throw new Exception("日期参数为空！");
        }
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        c1.setTime(startDate);
        c2.setTime(endDate);
        switch (fieldType) {
        case Calendar.YEAR:
        	count = Math.abs(c1.get(Calendar.YEAR) - c2.get(Calendar.YEAR));
        	break;
        case Calendar.MONTH:
        	count = Math.abs((c1.get(Calendar.YEAR)*12 + c1.get(Calendar.MONTH)) - (c2.get(Calendar.YEAR)*12 + c2.get(Calendar.MONTH)));
        	break;
        case Calendar.DAY_OF_MONTH:
        	count = Math.abs(startDate.getTime()/86400000 - endDate.getTime()/86400000);
        	break;
        case Calendar.HOUR:
        	count = Math.abs(startDate.getTime()/3600000 - endDate.getTime()/3600000);
        	break;
        case Calendar.MINUTE:
        	count = Math.abs(startDate.getTime()/60000 - endDate.getTime()/60000);
        	break;
        case Calendar.SECOND:
        	count = Math.abs(startDate.getTime()/1000 - endDate.getTime()/1000);
        	break;
        default:
        	throw new Exception("不支持的日期部分类型！");
        }
        return count;
    }

    /**
     * 计数两个日期之间的相差的日期部分，日期部分可以为年（Calendar.YEAR）、月（Calendar.MONTH）、日（Calendar.DAY_OF_MONTH）、时（Calendar.HOUR）、分（Calendar.MINUTE）、秒（Calendar.SECOND）
     * @param startDate		开始日期
     * @param endDate		结束日期
     * @param fieldType		日期部分类型
     * @return long			日期部分差额
     */
    public static long countDateField(Timestamp startDate, Timestamp endDate, int fieldType) throws Exception {
    	return countDateField((Date)startDate, (Date)endDate, fieldType);
    }

	/**
	 * 列表两个日期之间的涵盖的日期部分，日期部分可以为年（Calendar.YEAR）、月（Calendar.MONTH）、日（Calendar.DAY_OF_MONTH）、时（Calendar.HOUR）、分（Calendar.MINUTE）
	 * @param startDate		开始日期
	 * @param endDate		结束日期
	 * @param fieldType		日期部分类型
	 * @return int
	 */
	public static String[] listDateField(Date startDate, Date endDate, int fieldType) throws Exception {
		List list = null;
		
		if (startDate == null || endDate == null) {
			throw new Exception("日期参数为空！");
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(startDate);
		String pattern = null;
		switch (fieldType) {
		case Calendar.YEAR:
			pattern = "yyyy";
			break;
		case Calendar.MONTH:
			pattern = "yyyyMM";
			break;
		case Calendar.DAY_OF_MONTH:
			pattern = "yyyyMMdd";
			break;
		case Calendar.HOUR:
			pattern = "yyyyMMddHH";
			break;
		case Calendar.MINUTE:
			pattern = "yyyyMMddHHmm";
			break;
		default:
			throw new Exception("不支持的日期部分类型！");
		}
		int amount = 0;
		if (startDate.before(endDate)) {
			amount = 1;
		}
		else {
			amount = -1;
		}
		String e = format(endDate, pattern);
		list = new ArrayList();
		while (true) {
			String s = format(calendar.getTime(), pattern);
			list.add(s);
			if (s.equals(e)) {
				break;
			}
			calendar.add(fieldType, amount);
        }
		
        return (String[])list.toArray(new String[0]);
    }
	
	/**
	 * 列表两个日期之间的涵盖的日期部分，日期部分可以为年（Calendar.YEAR）、月（Calendar.MONTH）、日（Calendar.DAY_OF_MONTH）、时（Calendar.HOUR）、分（Calendar.MINUTE）
	 * @param startDate		开始日期
	 * @param endDate		结束日期
	 * @param fieldType		日期部分类型
	 * @return int
	 */
	public static String[] listDateField(Timestamp startDate, Timestamp endDate, int fieldType) throws Exception {
		return listDateField((Date)startDate, (Date)endDate, fieldType);
	}

	/**
	 * 根据制定的类型对日期部分进行截取，截取类型可以为年（Calendar.YEAR）、月（Calendar.MONTH）、日（Calendar.DAY_OF_MONTH）、时（Calendar.HOUR）、分（Calendar.MINUTE）、秒（Calendar.SECOND），如:日期 "2015-08-16 12:28:32"按年截取为
	 * "1970-01-01 00:00:00"；按月截取为"2015-01-01 00:00:00"；按日截取为"2015-08-01 00:00:00"；按时截取为"2015-08-16 00:00:00"；按分钟 截取为"2015-08-01 12:00:00"；按秒截取为"2015-08-01 12:28:00"
	 * @param startDate		开始日期
	 * @param endDate		结束日期
	 * @param fieldType		日期部分类型
	 * @return int
	 */
	public static Date truncate(Date date, int fieldType) throws Exception {
		if (date == null) {
			throw new Exception("日期参数为空！");
		}
		String pattern = null;
		switch (fieldType) {
		case Calendar.YEAR:
			pattern = "1970";
			break;
		case Calendar.MONTH:
			pattern = "yyyy";
			break;
		case Calendar.DAY_OF_MONTH:
			pattern = "yyyyMM";
			break;
		case Calendar.HOUR:
			pattern = "yyyyMMdd";
			break;
		case Calendar.MINUTE:
			pattern = "yyyyMMddHH";
			break;
		case Calendar.SECOND:
			pattern = "yyyyMMddHHmm";
			break;
		default:
			throw new Exception("不支持的日期部分类型！");
		}
		return getDate(format(date, pattern), pattern);
    }

	/**
	 * 根据制定的类型对日期部分进行截取，截取类型可以为年（Calendar.YEAR）、月（Calendar.MONTH）、日（Calendar.DAY_OF_MONTH）、时（Calendar.HOUR）、分（Calendar.MINUTE）、秒（Calendar.SECOND），如:日期 "2015-08-16 12:28:32"按年截取为
	 * "1970-01-01 00:00:00"；按月截取为"2015-01-01 00:00:00"；按日截取为"2015-08-01 00:00:00"；按时截取为"2015-08-16 00:00:00"；按分钟 截取为"2015-08-01 12:00:00"；按秒截取为"2015-08-01 12:28:00"
	 * @param startDate		开始日期
	 * @param endDate		结束日期
	 * @param fieldType		日期部分类型
	 * @return int
	 */
	public static Timestamp truncate(Timestamp timestamp, int fieldType) throws Exception {
		Date time = truncate((Date)timestamp, fieldType);
		return new Timestamp(time.getTime());
	}
	
	/**
	 * 时间转换,将时间转换为参数pattern指定的格式
	 *
	 * @param date
	 *            时间
	 * @param pattern
	 *            时间格式，如：yyyy-MM-dd HH:mm:ss
	 * @return 转换后的时间字符串
	 */
	public static String formatDate(Date date, String pattern) {
		if (date == null) {
			return "";
		}
		SimpleDateFormat myFormat = new SimpleDateFormat(pattern);
		return myFormat.format(date);
	}

	/**
	 * 时间转换,将时间转换为参数pattern指定的格式
	 *
	 * @param time
	 *            时间
	 * @param pattern
	 *            时间格式，如：yyyy-MM-dd HH:mm:ss
	 * @return 转换后的时间字符串
	 */
	public static String formatDate(Timestamp time, String pattern) {
		if (time == null) {
			return "";
		}
		SimpleDateFormat myFormat = new SimpleDateFormat(pattern);
		return myFormat.format(time);
	}

	/**
	 * 以"yyyy-MM-dd HH:mm:ss.0"格式获取系统当前时间（秒）
	 *
	 * @return <code>Timestamp</code>当前系统时间
	 */
	public static Timestamp getTime() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Calendar calendar = Calendar.getInstance();
		String mystrdate = myFormat.format(calendar.getTime());
		return Timestamp.valueOf(mystrdate);
	}

	/**
	 * 获取当天最早的时间(时间yyyy-MM-dd 00:00:00)
	 *
	 * @return <code>Timestamp</code>当天最早的时间(时间yyyy-MM-dd 00:00:00)
	 */
	public static Timestamp getDateFirst() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
		Calendar calendar = Calendar.getInstance();
		String mystrdate = myFormat.format(calendar.getTime());
		return Timestamp.valueOf(mystrdate);
	}

	/**
	 * 获取当天最晚时间(时间23:59:59)
	 *
	 * @return <code>Timestamp</code>当天最晚时间 (时间yyyy-MM-dd 23:59:59)
	 */
	public static Timestamp getDateLast() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
		Calendar calendar = Calendar.getInstance();
		String mystrdate = myFormat.format(calendar.getTime());
		return Timestamp.valueOf(mystrdate);
	}



	/**
	 * 取得当前时间的年月日("yyyyMMdd")
	 *
	 * @return 当前时间的年月日("yyyyMMdd")字符串
	 */
	public static String getCurrDate() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyyMMdd");
		Calendar calendar = Calendar.getInstance();
		String mystrdate = myFormat.format(calendar.getTime());
		return mystrdate;
	}

	/**
	 * 格式必须为yyyy-[m]m-[d]d hh:mm:ss[.f...]时间字符串转换成Timestamp
	 *
	 * @param timeString
	 * @return <code>Timestamp</code>时间戳
	 */
	public static Timestamp getTime(String timeString) {
		return Timestamp.valueOf(timeString);
	}

	/**
	 * 自定义格式的时间字符串转换成格式为（yyyy-MM-dd HH:mm:ss）的时间戳
	 *
	 * @param timeString
	 *            时间字符串
	 * @param fmt
	 *            与时间字符串相匹配的格式
	 * @return <code>Timestamp</code>时间戳
	 * @throws ParseException
	 */
	public static Timestamp getTime(String timeString, String fmt) throws ParseException {
		SimpleDateFormat myFormat = new SimpleDateFormat(fmt);
		Date date = myFormat.parse(timeString);
		myFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return getTime(myFormat.format(date));
	}

	/**
	 * 输入指定格式(yyyy-MM-dd HH:mm:ss或者yyyy-MM-dd)时间字符串,返回时间戳
	 * <p>
	 * 如果输入格式为yyyy-MM-dd的时间字符串,则返回格式yyyy-MM-dd 00:00:00的时间戳
	 *
	 * @param timeString
	 * @return <code>Timestamp</code>时间戳
	 * @throws ParseException
	 */
	public static Timestamp getDateFirst(String timeString) throws ParseException {
		if (null == timeString || "".equals(timeString)) {
			return null;
		}
		if (timeString.length() > 10) {
			return getTime(timeString, "yyyy-MM-dd HH:mm:ss");
		} else {
			return getTime(timeString, "yyyy-MM-dd");
		}
	}

	/**
	 * 输入指定格式(yyyy-MM-dd HH:mm:ss或者yyyy-MM-dd)时间字符串,返回时间戳
	 * <p>
	 * 如果输入格式为yyyy-MM-dd的时间字符串,则返回格式yyyy-MM-dd 23:59:59的时间戳
	 *
	 * @param timeString
	 *            格式为(yyyy-MM-dd HH:mm:ss或者yyyy-MM-dd)时间字符串
	 * @return Timestamp
	 * @throws ParseException
	 */
	public static Timestamp getDateLast(String timeString) throws ParseException {
		if (null == timeString || "".equals(timeString)) {
			return null;
		}
		if (timeString.length() > 10) {
			return getTime(timeString, "yyyy-MM-dd HH:mm:ss");
		} else {
			return getTime(timeString + " 23:59:59", "yyyy-MM-dd HH:mm:ss");
		}
	}

	/**
	 * 周日为一周的起始日
	 * <p>
	 * 获取本周周一时间，返回 格式yyyy-MM-dd 00:00:00
	 *
	 * @return Timestamp
	 */
	public static Timestamp getMonday() {
		Calendar calendar = Calendar.getInstance();
		int dayofweek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		calendar.add(Calendar.DATE, -dayofweek + 1);
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
		String mystrdate = myFormat.format(calendar.getTime());
		return Timestamp.valueOf(mystrdate);
	}

	/**
	 * 周日为一周的起始日
	 * <p>
	 * 获取本周 周日 时间，返回格式yyyy-MM-dd 23:59:59
	 *
	 * @author cmt
	 * @return Timestamp
	 */
	public static Timestamp getSunday() {
		Calendar calendar = Calendar.getInstance();
		int dayofweek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		calendar.add(Calendar.DATE, -dayofweek);
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
		String mystrdate = myFormat.format(calendar.getTime());
		return Timestamp.valueOf(mystrdate);
	}



	/**
	 * 两个日期相减 格式 yyyyMMdd
	 *
	 * @param oldDate
	 * @param newDate
	 * @return 相差的天数
	 */
	public static long getsubDate(String oldDate, String newDate) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Date d1 = null;
		Date d2 = null;
		try {
			d1 = sdf.parse(oldDate);
			d2 = sdf.parse(newDate);
		} catch (ParseException e) {
			throw new RuntimeException("日期处理出错");
		}

		return (d1.getTime() - d2.getTime()) / (3600L * 1000 * 24);
	}

	/**
	 * 两个日期相减 格式 yyyyMMdd
	 *
	 * @param oldDate
	 * @param newDate
	 * @return 相差的天数
	 */
	public static long getsubDate(Date oldDate, Date newDate) {
		return (oldDate.getTime() - newDate.getTime()) / (3600L * 1000 * 24);
	}

	/**
	 * 获取系统当前时间（分）
	 *
	 * @author cmt
	 * @return
	 */
	public static String getMinute() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyyMMddHHmm");
		return myFormat.format(new Date());
	}

	/**
	 * 转换成时间 字符串格式必须为 yyyy-MM-dd HH:mm:ss 或 yyyy-MM-dd
	 *
	 * @author cmt
	 * @return Date
	 * @throws ParseException
	 */
	public static Date parseToDate(String val) throws ParseException {
		Date date = null;
		if (null != val && val.trim().length() != 0 && !"null".equals(val.trim().toLowerCase())) {
			val = val.trim();
			if (val.length() > 10) {
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				date = sdf.parse(val);
			}
			if (val.length() <= 10) {
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				date = sdf.parse(val);
			}
		}
		return date;
	}

	/**
	 * 将时间字符串转换成指定格式的Date
	 *
	 * @param dateStr
	 *
	 * @param format
	 *
	 * @return Date
	 * @throws ParseException
	 */
	public static Date parseToDate(String dateStr, String format) throws ParseException {
		Date date = null;
		if (null != dateStr && dateStr.trim().length() != 0 && !"null".equals(dateStr.trim().toLowerCase())) {
			dateStr = dateStr.trim();
			SimpleDateFormat sdf = new SimpleDateFormat(format);
			date = sdf.parse(dateStr);
		}
		return date;
	}

	/**
	 * 获取上月的第一天yyyy-MM-dd 00:00:00和最后一天yyyy-MM-dd 23:59:59
	 *
	 * @author cmt
	 * @return
	 */
	public static Map getPreMonth() {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");

		Calendar cal = Calendar.getInstance();
		GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(new Date());

		calendar.add(Calendar.MONTH, -1);
		Date theDate = calendar.getTime();
		gcLast.setTime(theDate);
		gcLast.set(Calendar.DAY_OF_MONTH, 1);
		String day_first_prevM = df.format(gcLast.getTime());
		StringBuilder str = new StringBuilder().append(day_first_prevM).append(" 00:00:00");
		day_first_prevM = str.toString(); // 上月第一天

		calendar.add(cal.MONTH, 1);
		calendar.set(cal.DATE, 1);
		calendar.add(cal.DATE, -1);
		String day_end_prevM = df.format(calendar.getTime());
		StringBuilder endStr = new StringBuilder().append(day_end_prevM).append(" 23:59:59");
		day_end_prevM = endStr.toString(); // 上月最后一天

		Map map = new HashMap();
		map.put("prevMonthFD", day_first_prevM);
		map.put("prevMonthPD", day_end_prevM);
		return map;
	}

	/**
	 * 获取上周 周一时间，返回 格式yyyy-MM-dd 00:00:00
	 *
	 * @author cmt
	 * @return
	 */
	public static Timestamp getPreMonday() {
		Calendar calendar = Calendar.getInstance();

		calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
		calendar.add(calendar.WEEK_OF_MONTH, -1);

		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
		String mystrdate = myFormat.format(calendar.getTime());
		return Timestamp.valueOf(mystrdate);
	}

	/**
	 * 获取上周 周日时间，返回 格式yyyy-MM-dd 23:59:59
	 *
	 * @author cmt
	 * @return
	 */
	public static Timestamp getPreSunday() {
		Calendar calendar = Calendar.getInstance();

		calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
		calendar.add(calendar.WEEK_OF_MONTH, -1);

		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
		String mystrdate = myFormat.format(calendar.getTime());
		return Timestamp.valueOf(mystrdate);
	}

	/**
	 * 获得格式为yyyyMMddHHmmssSSS时间字符串
	 *
	 * @return String
	 */
	public static String getDateyyyyMMddHHmmssSSSStr() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		Calendar calendar = Calendar.getInstance();
		return myFormat.format(calendar.getTime());
	}

	/**
	 * 获得格式为yyyyMMddHHmmss时间字符串
	 *
	 * @return String
	 */
	public static String getDateyyyyMMddHHmmss() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyyMMddHHmmss");
		Calendar calendar = Calendar.getInstance();
		return myFormat.format(calendar.getTime());
	}

	/**
	 * 获得格式为yyyyMMdd时间字符串
	 *
	 * @return String
	 */
	public static String getDateyyyyMMdd() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyyMMdd");
		Calendar calendar = Calendar.getInstance();
		return myFormat.format(calendar.getTime());
	}

	/**
	 * 获取t天前日期，格式yyyyMM
	 *
	 * @return
	 */
	public static String getDateyyyyMMdd(int t) {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyyMMdd");
		Calendar calendar = Calendar.getInstance();
		int day = calendar.get(Calendar.DAY_OF_YEAR);
		calendar.set(Calendar.DAY_OF_YEAR, day - t);
		return myFormat.format(calendar.getTime());
	}

	/**
	 * 获取当前月份，格式yyyyMM
	 *
	 * @return
	 */
	public static String getMonth() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyyMM");
		return myFormat.format(getDate());
	}

	/**
	 * 取当前时间 格式为 yyyy-MM-dd HH:mm:ss
	 *
	 * @return
	 */
	public static String getDateNow() {
		SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Calendar calendar = Calendar.getInstance();
		return myFormat.format(calendar.getTime());
	}

	/**
	 * 指定格式进行时间校验
	 *
	 * @param pattern 格式
	 * @param date 具体时间
	 * @return boolean true表示具体的时间与时间格式相符,false则相反
	 */
	public static boolean validateDate(String pattern, String date) {
		if (isBlank(date)) {
			return false;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		try {
			Date time = sdf.parse(date);
			String newValue = sdf.format(time);
			return date.equals(newValue);
		} catch (ParseException e) {
			return false;
		}
	}

	/**
	 * 校验给定的时间字符串与格式yyyyMMddHHmmss是否相符
	 *
	 * @param date
	 *
	 * @return boolean
	 */
	public static boolean validateyMdHms(String date) {
		return validateDate("yyyyMMddHHmmss", date);
	}

	/**
	 * 校验给定的时间字符串与格式yyyy-MM-dd HH:mm:ss是否相符
	 *
	 * @param date
	 * @return boolean
	 */
	public static boolean validateyMdHmsWithSymbol(String date) {
		return validateDate("yyyy-MM-dd HH:mm:ss", date);
	}

	/**
	 * 校验给定的时间字符串与格式yyyy-MM-dd是否相符
	 *
	 * @param date
	 * @return boolean
	 */
	public static boolean validateyMdWithSymbol(String date) {
		return validateDate("yyyy-MM-dd", date);
	}

	/**
	 *校验给定的时间字符串与格式yyyyMMdd是否相符
	 *
	 * @param date
	 * @return boolean
	 */
	public static boolean validateyMd(String date) {
		return validateDate("yyyyMMdd", date);
	}
	
	 /**
     * 获取任意时间的下一个月
     * 描述:<描述函数实现的功能>.
     * @param repeatDate
     * @return
     */
    public static String getPreMonth(String repeatDate) {
        String lastMonth = "";
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat dft = new SimpleDateFormat("yyyyMM");
        int year = Integer.parseInt(repeatDate.substring(0, 4));
        String monthsString = repeatDate.substring(4, 6);
        int month;
        if ("0".equals(monthsString.substring(0, 1))) {
            month = Integer.parseInt(monthsString.substring(1, 2));
        } else {
            month = Integer.parseInt(monthsString.substring(0, 2));
        }
        cal.set(year,month,Calendar.DATE);
        lastMonth = dft.format(cal.getTime());
        return lastMonth;
    }

    /**
     * 获取任意时间的上一个月
     * 描述:<描述函数实现的功能>.
     * @param repeatDate
     * @return
     */
    public static String getLastMonth(String repeatDate) {
        String lastMonth = "";
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat dft = new SimpleDateFormat("yyyyMM");
        int year = Integer.parseInt(repeatDate.substring(0, 4));
        String monthsString = repeatDate.substring(4, 6);
        int month;
        if ("0".equals(monthsString.substring(0, 1))) {
            month = Integer.parseInt(monthsString.substring(1, 2));
        } else {
            month = Integer.parseInt(monthsString.substring(0, 2));
        }
        cal.set(year,month-2,Calendar.DATE);
        lastMonth = dft.format(cal.getTime());
        return lastMonth;
    }
    
    public static Timestamp getCurrentTime() {
		return new Timestamp(System.currentTimeMillis());
}


   /**
     * 得到当前日期时间,格式为yyyy-MM-dd HH:mm:ss.
     * FrameWork使用
     * @return String
     */
    public static String getCurrDateTime() {
        java.sql.Timestamp date = new java.sql.Timestamp(System.
                currentTimeMillis());
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return formatter.format(date);
    }


   /**  
     * 得到当前日期时间,格式为yyyyMMddHHmmss.
     * FrameWork使用
     * @return String
     */
    public static String getCurrDateTime_yyyymmddhhmmss() {
        java.sql.Timestamp date = new java.sql.Timestamp(System.
                currentTimeMillis());
        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
        return formatter.format(date);
    }
    
    /**
     * 根据传入的日期字符串转换成相应的日期对象，
     * 如果字符串为空或不符合日期格式，则返回当前时间。
     * FrameWork使用
     * @param strDate String 日期字符串
     * @return java.sql.Timestamp 日期对象
     * */
    public static java.sql.Timestamp getDateByString(String strDate) {
        if (strDate.trim().equals("")) {
            return new java.sql.Timestamp(System.currentTimeMillis());
        }
        try {
            strDate = getFormattedDate(strDate, "yyyy-MM-dd HH:mm:ss") +
                      ".000000000";
            return java.sql.Timestamp.valueOf(strDate);
        } catch (Exception ex) {
            return new java.sql.Timestamp(System.currentTimeMillis());
        }
    }


    
    /**
     * 对输入的日期字符串进行格式化,
     * 如果输入的是0000/00/00 00:00:00则返回空串.
     * FrameWork使用
     * @param strDate String 需要进行格式化的日期字符串
     * @param strFormatTo String 要转换的日期格式
     * @return String 经过格式化后的字符串
     */
    public static String getFormattedDate(String strDate, String strFormatTo) {
        if ((strDate == null) || strDate.trim().equals("")) {
            return "";
        }
        strDate = strDate.replace('/', '-');
        strFormatTo = strFormatTo.replace('/', '-');
        if (strDate.equals("0000-00-00 00:00:00") ||
            strDate.equals("1800-01-01 00:00:00")) {
            return "";
        }
        String formatStr = strFormatTo; //"yyyyMMdd";
        if ((strDate == null) || strDate.trim().equals("")) {
            return "";
        }
        switch (strDate.trim().length()) {
        case 6:
            if (strDate.substring(0, 1).equals("0")) {
                formatStr = "yyMMdd";
            } else {
                formatStr = "yyyyMM";
            }
            break;
        case 8:
            formatStr = "yyyyMMdd";
            break;
        case 10:
            if (strDate.indexOf("-") == -1) {
                formatStr = "yyyy/MM/dd";
            } else {
                formatStr = "yyyy-MM-dd";
            }
            break;
        case 11:
            if (strDate.getBytes().length == 14) {
                formatStr = "yyyy年MM月dd日";
            } else {
                return "";
            }
        case 14:
            formatStr = "yyyyMMddHHmmss";
            break;
        case 19:
            if (strDate.indexOf("-") == -1) {
                formatStr = "yyyy/MM/dd HH:mm:ss";
            } else {
                formatStr = "yyyy-MM-dd HH:mm:ss";
            }
            break;
        case 21:
            if (strDate.indexOf("-") == -1) {
                formatStr = "yyyy/MM/dd HH:mm:ss.S";
            } else {
                formatStr = "yyyy-MM-dd HH:mm:ss.S";
            }
            break;
        default:
            return strDate.trim();
        }
        try {
            SimpleDateFormat formatter = new SimpleDateFormat(formatStr);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(formatter.parse(strDate));
            formatter = new SimpleDateFormat(strFormatTo);
            return formatter.format(calendar.getTime());
        } catch (Exception e) {
            //Common.printLog("转换日期字符串格式时出错;" + e.getMessage());
            return "";
        }
    }

    /**
     * 将带有时间类型的日期转换成不带时间的日期
     *
     * @param date
     * @return
     */
    public static Timestamp formatDateTimeToDate(Date date) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.HOUR_OF_DAY, 0);
        rightNow.set(Calendar.MILLISECOND, 0);
        rightNow.set(Calendar.SECOND, 0);
        rightNow.set(Calendar.MINUTE, 0);
        return new Timestamp(rightNow.getTimeInMillis());
    }

    /**
     * 得到本月最后一天 
     * @param timest1
     * @return
     */
    public static Timestamp getLastDayOfMonth(Timestamp timest1) {
    	Calendar cal = Calendar.getInstance();
        cal.setTime(timest1);
        cal.add(Calendar.MONTH,1);
        cal.set(Calendar.DAY_OF_MONTH,0);
        return new Timestamp(cal.getTimeInMillis());
    }


    /**
     * 获取某年的今日字符串
     * @param year -1：去年 1：明年
     * @return
     */
    public static String getYear(int year) {
    	Calendar cal = Calendar.getInstance();
        cal.add(Calendar.YEAR,year);
        java.sql.Timestamp date = new java.sql.Timestamp(cal.getTimeInMillis());
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return formatter.format(date);
    }



    /**
     * 得到昨天日期，格式yyyy-MM-dd。
     * @return String 格式化的日期字符串
     */
    public static String getYesterday() {
        Date cDate = new Date();
        cDate.setTime(cDate.getTime() - 24 * 3600 * 1000);
        SimpleDateFormat cSimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        return cSimpleDateFormat.format(cDate);
    }

    /**
     * 得到明天日期，格式yyyy-MM-dd。
     * @return String 格式化的日期字符串
     */
    public static String getTomorrow() {
        Date cDate = new Date();
        cDate.setTime(cDate.getTime() + 24 * 3600 * 1000);
        SimpleDateFormat cSimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        return cSimpleDateFormat.format(cDate);
    }


    /**
     * 得到指定的日期，如一年三个月零九天后(以yyyy/MM/dd格式显示)参数为("yyyy/MM/dd",1,3,9)
     * @param strFormat
     * @param iYear
     * @param iMonth
     * @param iDate
     * @return
     */
    public static String getSpecTime(String strFormat, int iYear, int iMonth,
                                     int iDate, int iHour, int iMinute,
                                     int iSecond) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.set(Calendar.YEAR, rightNow.get(Calendar.YEAR) + iYear);
        rightNow.set(Calendar.MONTH, rightNow.get(Calendar.MONTH) + iMonth);
        rightNow.set(Calendar.DATE, rightNow.get(Calendar.DATE) + iDate);
        rightNow.set(Calendar.HOUR, rightNow.get(Calendar.HOUR) + iHour);
        rightNow.set(Calendar.MINUTE, rightNow.get(Calendar.MINUTE) + iMinute);
        rightNow.set(Calendar.SECOND, rightNow.get(Calendar.SECOND) + iSecond);
        SimpleDateFormat df = new SimpleDateFormat(strFormat);
        return df.format(rightNow.getTime());
    }

   /**add by liufeng 20061122
       * 得到当前时间（前或后）iDays天的日期
       * @param strFormat String　日期格式比如　yyyy-MM-dd
       * @param iDays int
       * @return String
       */
      public static String getCurenDayAddDay(String strFormat,int iDays) {
          Calendar c = new GregorianCalendar();
          c.add(Calendar.DAY_OF_MONTH,iDays);
          Date cDate = new Date();
          cDate.setTime(c.getTimeInMillis());
          SimpleDateFormat cSimpleDateFormat = new SimpleDateFormat(strFormat);
          return cSimpleDateFormat.format(cDate);
    }


    /**
     * 获取当前时间前（后）几个月的那一天日期
     * @param iMonth
     * @param strFormat
     * @return
     */
    public static String getDateBeforeMonths(int iMonth,String strFormat){
        Calendar cal = new GregorianCalendar();
        cal.add(Calendar.MONTH,iMonth);
    	Date cDate = new Date();
    	cDate.setTime(cal.getTimeInMillis());
        SimpleDateFormat cSimpleDateFormat = new SimpleDateFormat(strFormat);
        String strNewDate = cSimpleDateFormat.format(cDate);
        return strNewDate;
    }

 /**
     * 获得指定日期的前一天
     * @param specifiedDay  指定日期
      * @param format 指定日期格式
     * @return
     * @throws Exception
     */
    public static String getSpecifiedDayBefore(String specifiedDay,String format){
        //SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        Date date=null;
        try {
            date = new SimpleDateFormat(format).parse(specifiedDay);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        c.setTime(date);
        int day=c.get(Calendar.DATE);
        c.set(Calendar.DATE,day-1);
        String dayBefore=new SimpleDateFormat(format).format(c.getTime());
        return dayBefore;
    }

    /**
     * 获得指定日期的后一天
     * @param specifiedDay  指定日期
      * @param format 指定日期格式
     * @return
     * @throws Exception
     */
    public static String getSpecifiedDayAfter(String specifiedDay,String format){
        //SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        Date date=null;
        try {
            date = new SimpleDateFormat(format).parse(specifiedDay);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        c.setTime(date);
        int day=c.get(Calendar.DATE);
        c.set(Calendar.DATE,day+1);
        String dayAfter=new SimpleDateFormat(format).format(c.getTime());
        return dayAfter;
    }

    /**
     * 获得时间的字符串
     *
     * @param ts      Timestamp
     * @param pattern String
     * @return String
     * @throws Exception
     */
    public static String getYYYYMMDDHHMMSS(Timestamp ts, String pattern) throws Exception {
        if (ts == null) {
            return null;
        }
        DateFormat dateformat = new SimpleDateFormat(pattern);
        String str = dateformat.format(ts);
        return str;
    }


  

/**
     * 根据指定的日期获取下个月的第一天的时间
     *
     * @param date
     * @return
     * @author shaosm
     */
    public static Timestamp getDateOfNextMonthFirstDay(Date date) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.DAY_OF_MONTH, 1);
        rightNow.set(Calendar.HOUR_OF_DAY, 0);
        rightNow.set(Calendar.MILLISECOND, 0);
        rightNow.set(Calendar.SECOND, 0);
        rightNow.set(Calendar.MINUTE, 0);
        rightNow.set(Calendar.MONTH, rightNow.get(Calendar.MONTH) + 1);
        return new Timestamp(rightNow.getTimeInMillis());
    }

    /**
     * 根据指定的日期获取上个月的第一天的时间
     *
     * @param date
     * @return
     */
    public static Timestamp getDateOfPreMonthFirstDay(Date date) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.DAY_OF_MONTH, 1);
        rightNow.set(Calendar.HOUR_OF_DAY, 0);
        rightNow.set(Calendar.MILLISECOND, 0);
        rightNow.set(Calendar.SECOND, 0);
        rightNow.set(Calendar.MINUTE, 0);
        rightNow.set(Calendar.MONTH, rightNow.get(Calendar.MONTH) - 1);
        return new Timestamp(rightNow.getTimeInMillis());
    }

  /**
     * 根据指定日期获取该月的最后一天的最后时间点
     *
     * @param date
     * @return
     */
    public static Timestamp getDateOfCurrentMonthEndDay(Date date) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.DAY_OF_MONTH, rightNow.getActualMaximum(Calendar.DAY_OF_MONTH));
        rightNow.set(Calendar.HOUR_OF_DAY, 23);
        rightNow.set(Calendar.MILLISECOND, 59);
        rightNow.set(Calendar.SECOND, 59);
        rightNow.set(Calendar.MINUTE, 59);
        rightNow.set(Calendar.MONTH, rightNow.get(Calendar.MONTH));
        return new Timestamp(rightNow.getTimeInMillis());
    }

    public static Timestamp getLastHour(Date date){
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.setLenient(true);
        c.set(Calendar.HOUR_OF_DAY, c.get(Calendar.HOUR_OF_DAY) + 1);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        c.set(Calendar.MILLISECOND, 59);
        return new Timestamp(c.getTimeInMillis());
    }

    public static Timestamp getLastDay(Date date){
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.HOUR_OF_DAY, 23);
        rightNow.set(Calendar.MILLISECOND, 59);
        rightNow.set(Calendar.SECOND, 59);
        rightNow.set(Calendar.MINUTE, 59);
        return new Timestamp(rightNow.getTimeInMillis());
    }

 /**
     * 根据指定日期获取前一天的最后的时间点
     *
     * @param date
     * @return
     */
    public static Timestamp getPreLastDate(Date date) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.DAY_OF_MONTH, rightNow.get(Calendar.DAY_OF_MONTH) - 1);
        rightNow.set(Calendar.HOUR_OF_DAY, 23);
        rightNow.set(Calendar.MILLISECOND, 59);
        rightNow.set(Calendar.SECOND, 59);
        rightNow.set(Calendar.MINUTE, 59);
        rightNow.set(Calendar.MONTH, rightNow.get(Calendar.MONTH));
        return new Timestamp(rightNow.getTimeInMillis());
    }

    /**
     * 根据指定日期获取下一天的开始的时间点
     *
     * @param date
     * @return
     */
    public static Timestamp getNextDay(Date date) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.DAY_OF_MONTH, rightNow.get(Calendar.DAY_OF_MONTH) + 1);
        rightNow.set(Calendar.HOUR_OF_DAY, 0);
        rightNow.set(Calendar.MILLISECOND, 0);
        rightNow.set(Calendar.SECOND, 0);
        rightNow.set(Calendar.MINUTE, 0);
        rightNow.set(Calendar.MONTH, rightNow.get(Calendar.MONTH));
        return new Timestamp(rightNow.getTimeInMillis());
    }
    
    /**
     * 根据指定日期获取某天的开始的时间点
     *
     * @param date
     * @return
     */
    public static Timestamp getDay(Date date,int i) {
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.set(Calendar.DAY_OF_MONTH, rightNow.get(Calendar.DAY_OF_MONTH) + i);
        rightNow.set(Calendar.HOUR_OF_DAY, 0);
        rightNow.set(Calendar.MILLISECOND, 0);
        rightNow.set(Calendar.SECOND, 0);
        rightNow.set(Calendar.MINUTE, 0);
        rightNow.set(Calendar.MONTH, rightNow.get(Calendar.MONTH));
        return new Timestamp(rightNow.getTimeInMillis());
    }

    /**
     * 将时间格式化为YYYY-MM-DD
     *
     * @param date
     * @return
     */
    public static String getYYYYMMDD(Date date) {
        if (date == null)
            return null;
        DateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
        return dateformat.format(date);
    }

    /**
     * 将时间格式化为YYYY-MM-DD
     *
     * @param date
     * @return
     */
    public static String getNoLineYYYYMMDD(Date date) {
        if (date == null)
            return null;
        DateFormat dateformat = new SimpleDateFormat("yyyyMMdd");
        return dateformat.format(date);
    }
    
    /**
     * 返回两个日期之间隔了多少天
     * @param date1
     * @param date2
     */
    public static int DateDiff(Date date1, Date date2) {
        int i = (int) ((date1.getTime() - date2.getTime()) / 3600 / 24 / 1000);
        return i;
    }
    
    /**
     * 月份相加 
     * @param timest1
     * @param month
     * @return
     */
    public static Timestamp DateAddMonth(Timestamp timest1, int month) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(timest1);
        cal.add(Calendar.MONTH,month);
        return new Timestamp(cal.getTimeInMillis());
    }
    
    /**
     * 日期计算
     * @param timest1
     * @param day
     * @return
     */
    public static Timestamp DateAddDay(Timestamp timest1, int day) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(timest1);
        cal.add(Calendar.DAY_OF_MONTH,day);
        return new Timestamp(cal.getTimeInMillis());
    }


    /**
     * 对输入的日期进行格式化, 如果输入的日期是null则返回空串.
     * FrameWork使用
     * @param dtDate java.sql.Timestamp 需要进行格式化的日期字符串
     * @param strFormatTo String 要转换的日期格式
     * @return String 经过格式化后的字符串
     */
    public static String getFormattedDate(java.sql.Timestamp dtDate,
                                          String strFormatTo) {
        if (dtDate == null) {
            return "";
        }
        if (dtDate.equals(new java.sql.Timestamp(0))) {
            return "";
        }
        strFormatTo = strFormatTo.replace('/', '-');
        try {
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy");
            if (Integer.parseInt(formatter.format(dtDate)) < 1900) {
                return "";
            } else {
                formatter = new SimpleDateFormat(strFormatTo);
                return formatter.format(dtDate);
            }
        } catch (Exception e) {
            return "";
        }
    }

    /**
     * 当前日期增加或减去minute分钟后日期 add by zhourh 2009-08-20
     *
     * @param dateTime
     * @param minute
     * @return
     */
    public static Timestamp getDateAddMinute(Timestamp dateTime, int minute) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(dateTime);
        cal.add(Calendar.MINUTE, minute);
        return new Timestamp(cal.getTimeInMillis());
    }
    

  /**
     * 两个日期之间的年数
     *
     * @param start Date
     * @param end   Date
     * @return int
     */
    public static int yearsBetween(Date start, Date end) {
        return Years.yearsBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getYears();
    }

    /**
     * 两个日期之间的月数
     *
     * @param start Date
     * @param end   Date
     * @return int
     */
    public static int monthsBetween(Date start, Date end) {
        return Months.monthsBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getMonths();
    }

    /**
     * 两个日期之间的周数
     *
     * @param start Date
     * @param end   Date
     * @return int
     */
    public static int weeksBetween(Date start, Date end) {
        return Weeks.weeksBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getWeeks();
    }

    /**
     * 两个日期之间的天数
     *
     * @param start Date
     * @param end   Date
     * @return int
     */
    public static int daysBetween(Date start, Date end) {
        return Days.daysBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getDays();
    }

    /**
     * 两个日期之间的小时数
     *
     * @param start Date
     * @param end   Date
     * @return int
     */
    public static int hoursBetween(Date start, Date end) {
        return Hours.hoursBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getHours();
    }

    /**
     * 两个日期之间的分钟数
     *
     * @param start Date
     * @param end   Date
     * @return int
     */
    public static int minutesBetween(Date start, Date end) {
        return Minutes.minutesBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getMinutes();
    }

    /**
     * 两个日期之间的秒数
     *
     * @param start Date
     * @param end   Date
     * @return int
     */
    public static int secondsBetween(Date start, Date end) {
        return Seconds.secondsBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getSeconds();
    }


}