Java中的操作日期的工具类

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

/**
 * Date Utility Class This is used to convert Strings to Dates and Timestamps
 * 格式约定
 * 字母  日期或时间元素 表示  示例  
 * G  Era 标志符  Text  AD  
 * y  年  Year  1996; 96 
 * M  年中的月份  Month  July; Jul; 07 
 * w  年中的周数  Number  27 
 * W  月份中的周数  Number  2 
 * D  年中的天数  Number  189 
 * d  月份中的天数  Number  10 
 * F  月份中的星期  Number  2 
 * a  Am/pm 标记  Text  PM  
 * H  一天中的小时数（0-23）  Number  0 
 * k  一天中的小时数（1-24）  Number  24 
 * K  am/pm 中的小时数（0-11）  Number  0 
 * h  am/pm 中的小时数（1-12）  Number  12 
 * m  小时中的分钟数  Number  30 
 * s  分钟中的秒数  Number  55 
 * S  毫秒数  Number  978 
 * z  时区  General time zone  Pacific Standard Time; PST; GMT-08:00 
 * Z  时区  RFC 822 time zone  -0800 

 * StandardDate : [String][yyyy-MM-dd] 2015-01-05
 * StandardTime : [String][HH:mm:ss]   20:39:26
 * Standard     : [String][yyyy-MM-dd HH:mm:ss] 2015-01-05 20:39:26
 * <p>
 * <a href="DateUtil.java.html"><i>View Source</i></a>
 * </p>
 * 
 * @author <a href="mailto:xia_chaojun@newautovideo.com">chaojun xia</a> Minutes
 *         should be mm not MM (MM is month).
 * @version $Revision: 1.0.0.1 $ $Date: 2006/08/30 13:59:59 $
 */
public class DateUtil {

    private static String defaultDatePattern = null;

    private static String timePattern = "HH:mm";

    /**
     * Return default datePattern (MM/dd/yyyy)
     * 
     * @return a string representing the date pattern on the UI
     */
    public static synchronized String getDatePattern() {
        Locale locale = LocaleContextHolder.getLocale();
        try {
            /* extract default date pattern from application context */
            defaultDatePattern = ResourceBundle.getBundle("ApplicationResources", locale).getString("date.format");
        } catch (MissingResourceException mse) {
            defaultDatePattern = "MM/dd/yyyy";
        }

        return defaultDatePattern;
    }

    /**
     * Return default datetimePattern (MM/dd/yyyy HH:mm:ss.S)
     * 
     * @return a string representing the datetime pattern on the UI
     */
    public static String getDateTimePattern() {
        return DateUtil.getDatePattern() + " HH:mm:ss.S";
    }

    /**
     * This method attempts to convert an Oracle-formatted date in the form
     * dd-MMM-yyyy to mm/dd/yyyy.
     * 
     * @param aDate
     *            date from database as a string
     * @return formatted string for the ui
     */
    public static final String getDate(Date aDate) {
        SimpleDateFormat df = null;
        String returnValue = "";
        if (aDate != null) {
            df = new SimpleDateFormat(getDatePattern());
            returnValue = df.format(aDate);
        }
        return returnValue;
    }

    /**
     * This method generates a string representation of a date/time in the
     * format you specify on input
     * 
     * @param aMask
     *            the date pattern the string is in
     * @param strDate
     *            a string representation of a date
     * @return a converted Date object
     * @see java.text.SimpleDateFormat
     * @throws ParseException
     */
    public static final Date convertStringToDate(String aMask, String strDate) throws ParseException {
        SimpleDateFormat df = null;
        Date date = null;
        df = new SimpleDateFormat(aMask);
        try {
            date = df.parse(strDate);
        } catch (ParseException pe) {
            throw new ParseException(pe.getMessage(), pe.getErrorOffset());
        }
        return (date);
    }
    
    public static Date convertXMLGregorianCalendar(XMLGregorianCalendar xmlcal) {
        GregorianCalendar grecal = xmlcal.toGregorianCalendar();
        return grecal.getTime();
    }

    public static XMLGregorianCalendar getXMLGregorianCalendar() {

        try {
            DatatypeFactory dtf = DatatypeFactory.newInstance();
            GregorianCalendar gcal = (GregorianCalendar) GregorianCalendar.getInstance();
            return dtf.newXMLGregorianCalendar(gcal);
        } catch (DatatypeConfigurationException e) {
            return null;
        }
    }

    public static XMLGregorianCalendar getXMLGregorianCalendarDate(Date date) throws DatatypeConfigurationException {
        GregorianCalendar c = new GregorianCalendar();
        c.setTime(date);
        XMLGregorianCalendar xmlGdate = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
        return xmlGdate;
    }

    public static long getTimeAlong(Date before, Date after) {
        return after.getTime() - before.getTime();
    }

    /**
     * This method returns the current date time in the format: MM/dd/yyyy HH:MM
     * a
     * 
     * @param theTime
     *            the current time
     * @return the current date/time
     */
    public static String getTimeNow(Date theTime) {
        return getDateTime(timePattern, theTime);
    }

    /**
     * This method returns the current date in the format: MM/dd/yyyy
     * 
     * @return the current date
     * @throws ParseException
     */
    public static Calendar getToday() throws ParseException {
        Date today = new Date();
        SimpleDateFormat df = new SimpleDateFormat(getDatePattern());

        String todayAsString = df.format(today);
        Calendar cal = new GregorianCalendar();
        cal.setTime(convertStringToDate(todayAsString));

        return cal;
    }

    /**
     * 最通用的时间方式
     * 
     * 
     * @param type
     *            :样式,如:"yyyy-MM-dd HH:mm:ss.SSS"
     * 
     */
    public static String getDateTime(String type) {
        Date aDate = DateUtil.currentSQLDate();

        SimpleDateFormat df = null;
        String returnValue = "";
        if (aDate != null) {
            df = new SimpleDateFormat(type);
            returnValue = df.format(aDate);
        }
        return (returnValue);

    }
    
    /**
     * This method generates a string representation of a date's date/time in
     * the format you specify on input
     * 
     * @param aMask
     *            the date pattern the string is in
     * @param aDate
     *            a date object
     * @return a formatted string representation of the date
     * 
     * @see java.text.SimpleDateFormat
     */
    public static final String getDateTime(String aMask, Date aDate) {
        SimpleDateFormat df = null;
        String returnValue = "";
        if (aDate != null) {
            df = new SimpleDateFormat(aMask);
            returnValue = df.format(aDate);
        }
        return (returnValue);
    }
    
    /**
     * This method generates a string representation of a date based on the
     * System Property 'dateFormat' in the format you specify on input
     * 
     * @param aDate
     *            A date to convert
     * @return a string representation of the date
     */
    public static final String convertDateToString(Date aDate) {
        return getDateTime(getDatePattern(), aDate);
    }

    /**
     * This method converts a String to a date using the datePattern
     * 
     * @param strDate
     *            the date to convert (in format MM/dd/yyyy)
     * @return a date object
     * 
     * @throws ParseException
     */
    public static Date convertStringToDate(String strDate) throws ParseException {
        Date aDate = null;
        try {
            aDate = convertStringToDate(getDatePattern(), strDate);
        } catch (ParseException pe) {
            pe.printStackTrace();
            throw new ParseException(pe.getMessage(), pe.getErrorOffset());
        }
        return aDate;
    }

    public static java.sql.Timestamp currentSQLTimestamp() {
        return new java.sql.Timestamp(System.currentTimeMillis());
    }

    public static synchronized java.sql.Date currentSQLDate() {
        return new java.sql.Date(System.currentTimeMillis());
    }

    public static java.sql.Date getSQLDate(java.util.Date date) {
        return new java.sql.Date(date.getTime());
    }

    public static java.sql.Timestamp getSQLTimestamp(java.util.Date date) {
        return new java.sql.Timestamp(date.getTime());
    }

    public static java.util.Date toDate(String strValue) {
        SimpleDateFormat fmt = null;
        if (strValue.indexOf('.') > 0) {
            fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.CHINA);// 2005-01-01
        } else if (strValue.indexOf(':') > 0) {
            fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);// 2005-01-01
                                                                            // 10:10:10.100
        } else if (strValue.indexOf('-') > 0) {
            fmt = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);// 2005-01-01
        }
        try {
            return fmt.parse(strValue);
        } catch (Exception ex) {
            return new Date();// 返回1970-01-01 00:00:00
        }
    }

    public static java.sql.Timestamp toSQLTimestamp(String strValue) {
        return (new java.sql.Timestamp(toDate(strValue).getTime()));
    }

    public static String getSQLDateTimeStr(java.util.Date date) {
        java.sql.Date sql_date = new java.sql.Date(date.getTime());
        java.sql.Time sql_time = new java.sql.Time(date.getTime());
        return sql_date + " " + sql_time;
    }

    public static boolean comparableBefore(String strValue01, String strValue02) {
        return toSQLTimestamp(strValue01).before(toSQLTimestamp(strValue02));
    }

    public static boolean comparableAfter(String strValue01, String strValue02) {
        return toSQLTimestamp(strValue01).after(toSQLTimestamp(strValue02));
    }

    // 根据字符串返回该字符串对应的时间类型"00-00-00 00:00:00"
    public static String getbegintime(String begintime) {
        return getBegintime(begintime);
    }
    public static String getBegintime(String begintime) {
        if (begintime != null && begintime.length() == 8) {
            String yearString = begintime.substring(0, 4);
            String monthString = begintime.substring(4, 6);
            String dateString = begintime.substring(6);
            begintime = yearString + "-" + monthString + "-" + dateString + " " + "00:00:00";
        }
        return begintime;
    }

    // 根据字符串返回该字符串对应的时间类型"00-00-00 24:00:00"
    public static String getEndtime(String endtime) {
        if (endtime != null && endtime.length() == 8) {
            String yearString = endtime.substring(0, 4);
            String monthString = endtime.substring(4, 6);
            String dateString = endtime.substring(6);
            endtime = yearString + "-" + monthString + "-" + dateString + " " + "24:00:00";
        }
        return endtime;
    }

    // 根据字符串返回该字符串对应的日期类型"00-00-00"
    public static String getdate(String stringtime) {
        if (stringtime != null && stringtime.length() == 8) {
            String yearString = stringtime.substring(0, 4);
            String monthString = stringtime.substring(4, 6);
            String dateString = stringtime.substring(6);
            stringtime = yearString + "-" + monthString + "-" + dateString;
        }
        return stringtime;
    }

    // 将2010-10-10类型转换成20101010格式
    public static String getString(String stringtime) {
        if (stringtime != null && stringtime.length() == 10) {
            String yearString = stringtime.substring(0, 4);
            String monthString = stringtime.substring(5, 7);
            String dateString = stringtime.substring(8);
            stringtime = yearString + monthString + dateString;
        }
        return stringtime;
    }

    // 将日期转化为HH24MMSS格式的字符串
    public static String convertTohh24mmssFormat(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        String hour = String.valueOf(calendar.get(Calendar.HOUR_OF_DAY));
        if (Integer.parseInt(hour) < 10) {
            hour = "0" + hour;
        }
        String minute = String.valueOf(calendar.get(Calendar.MINUTE));
        if (Integer.parseInt(minute) < 10) {
            minute = "0" + minute;
        }
        String second = String.valueOf(calendar.get(Calendar.SECOND));
        if (Integer.parseInt(second) < 10) {
            second = "0" + second;
        }
        String result = hour + minute + second;
        return result;
    }

    // 获得两个日期的时间差，返回结果为_小时_分钟_秒
    public static String gettimedefferent(long milliseconds) {
        long hours = 0;
        long minutes = 0;
        long seconds = milliseconds / 1000;
        hours = seconds / 3600;
        seconds = seconds - hours * 3600;
        minutes = seconds / 60;
        seconds = seconds - minutes * 60;
        System.out.println(hours + "小时" + minutes + "分钟" + seconds + "秒");
        return hours + "小时" + minutes + "分钟" + seconds + "秒";
    }

    /**
     * 获得几秒前的时间
     * @param date1 时间 yyyy-MM-dd HH:mm:ss
     * @param seconds 秒 1
     * @throws ParseException 
     */
    public static String getTimeBefore(String date1, int seconds) throws ParseException{
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = df.parse(date1);// 解析成日期格式
        date.setTime(date.getTime() - seconds * 1000);// 减去N秒的时间

        return df.format(date);// 再将该时间转换成字符串格式
    }
    
    
    /**
     * 得到几天后的时间 *
     * 
     * @param d
     * @param day
     * @return
     */
    public static Date getDateAfter(Date d, int day) {
        Calendar now = Calendar.getInstance();
        now.setTime(d);
        now.set(Calendar.DATE, now.get(Calendar.DATE) + day);
        return now.getTime();
    }

    /**
     * 标准日期时间比较大小
     * @param String
     *            date1 "2014-3-14 18:47:08"
     * @param String
     *            date2 "2014-3-14 18:47:09"
     * @return 毫秒数 1000(ms)
     */
    public static long diffDateTime(String date1, String date2) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long diff = 0;
        try {
            Date d1 = df.parse(date1);
            Date d2 = df.parse(date2);
            diff = d1.getTime() - d2.getTime();
        } catch (Exception e) {
        }
        return diff;
    }

    public static String formatLongToTimeStr(Long l) {
        int hour = 0;
        int minute = 0;
        int second = 0;
        second = l.intValue() / 1000;

        if (second > 60) {
            minute = second / 60;
            second = second % 60;
        }
        if (minute > 60) {
            hour = minute / 60;
            minute = minute % 60;
        }
        return (getTwoLength(hour) + getTwoLength(minute) + getTwoLength(second));
    }

    public static String getTwoLength(final int data) {
        if (data < 10) {
            return "0" + data;
        } else {
            return "" + data;
        }
    }

    /**
     * 将时长转换为分钟
     */
    public static String change2Minute(String duration) {
        if (duration.indexOf(":") >= 0) {
            String[] durationArr = duration.split(":");
            long hour = Long.parseLong(durationArr[0]);
            long minute = Long.parseLong(durationArr[1]);
            long second = Long.parseLong(durationArr[2]);
            if (second > 0) {
                duration = String.valueOf(hour * 60 + minute + 1);
            } else {
                duration = String.valueOf(hour * 60 + minute);
            }
        } else if (duration.matches("[0-9]+")) {

        } else {
            System.out.println("格式不正确：" + duration);
        }
        return duration;
    }
    
    /**
     * 获取当前标准日期时间 
     */
    public static String getStandardNow() {
        return DateUtil.getDateTime("yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取运行时间 
     * @param adddays为延期天数
     */
    public static String getStandardRound(String adddays) {
        return getStandardRound(adddays, true);
    }

    /**
     * 获取运行时间 当前时间标准返回,未来时间只保留日期,时间为00:00:00
     * @param adddays 延期天数
     * @param readspecial 是否读取特殊含义值 keep 永不失效 将原值返回
     * @return
     */
    public static String getStandardRound(String adddays, boolean readspecial) {
        String runDate = new String();
        if ("".equals(adddays)) {
            adddays = "0";
        }
        if ("keep".equals(adddays)) {
            if (readspecial) {
                return "keep";
            } else {
                adddays = "0";
            }
        }
        if ("永不失效".equals(adddays)) {
            if (readspecial) {
                return "永不失效";
            } else {
                adddays = "0";
            }
        }
        /*
         * Pattern
         * pattern=Pattern.compile("\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}");
         * Matcher matcher=pattern.matcher(runtime); if(matcher.find()){ runDate
         * = runtime; //已经是一个完成的时间格式yyyy-MM-dd HH:mm:ss }
         */
        if (adddays.indexOf(":") != -1) {
            runDate = adddays; // 已经是一个完成的时间格式yyyy-MM-dd HH:mm:ss
        } else {
            adddays = adddays.trim().replace("+", "").trim();
            runDate = DateUtil.getDateTime("yyyy-MM-dd HH:mm:ss");
            try {
                runDate = DateUtil.convertDateToString(DateUtil.getDateAfter(DateUtil.convertStringToDate(DateUtil.getDateTime("MM/dd/yyyy")),
                        Integer.valueOf(adddays)));
                runDate = runDate.substring(6, 10) + "-" + runDate.substring(0, 2) + "-" + runDate.substring(3, 5) + " ";
                if (Integer.valueOf(adddays) == 0) {
                    runDate += DateUtil.getDateTime("HH:mm:ss");
                } else {
                    runDate += "00:00:00";
                }
            } catch (ParseException e) {
                e.printStackTrace();
                return runDate;
            }
        }
        return runDate;
    }

    /**
     * 判断是否达到指定标准时间
     * @param date 2014-01-12 15:00:00
     * @return 达到true 未达到false
     */
    public static boolean isreachStandard(String date) {
        // 将仅含日期的date添加上时间
        if (date != null && date.length() == 10 && "-".equals(String.valueOf(date.charAt(4))) && "-".equals(String.valueOf(date.charAt(7)))) {
            date += " 00:00:00";
        }
        if (date == null || "null".equals(date) || date.length() != 19) {
            return false;
        }
        String nowdate = getStandardRound("0");
        if (nowdate.compareTo(date) < 0) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 标准时长转为秒数
     * @param type : 26:15:04 -> 94504
     */
    public static long standardtime2secondslong(String duration) {
        long sum = 0;
        try {
            if (duration != null && duration.indexOf(":") >= 0) {
                String[] durationArr = duration.split(":");
                Long hour = Long.parseLong(durationArr[0]);
                Long minute = Long.parseLong(durationArr[1]);
                Long second = Long.parseLong(durationArr[2]);
                sum = hour * 3600 + minute * 60 + second;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sum;
    }

    /**
     * 秒数转为标准时长
     * @param type : 94504 -> 26:15:04
     * 
     */
    public static String seconds2standardtime(Long seconds) {
        Long second = seconds % 60;
        Long minute = (seconds % 3600 - second) / 60;
        Long hour = (seconds - minute * 60 - second) / 3600;
        return hour + ":" + (minute >= 10 ? minute : "0" + minute) + ":" + (second >= 10 ? second : "0" + second);
    }

    /**
     * 将yyyyMMdd格式的日期转换为标准格式
     * @param type : 20150105 -> 2015-01-05
     * @return
     */
    public static String yyyyMMdd2StandardDate(String stringdate) {
        if (stringdate != null && stringdate.length() == 8) {
            String yearString = stringdate.substring(0, 4);
            String monthString = stringdate.substring(4, 6);
            String dateString = stringdate.substring(6, 8);
            stringdate = yearString + "-" + monthString + "-" + dateString;
        }
        return stringdate;
    }

    /**
     * 将获取的时间转换为标准时间
     * @param type : 135000 -> 13:50:00
     */
    public static String HHmmss2StandardTime(String HH24mmss) {
        if (HH24mmss != null && HH24mmss.length() == 6) {
            String hourString = HH24mmss.substring(0, 2);
            String minuteString = HH24mmss.substring(2, 4);
            String secondsString = HH24mmss.substring(4, 6);
            HH24mmss = hourString + ":" + minuteString + ":" + secondsString;
        }
        return HH24mmss;
    }

    /**
     * 获取某标准日期时间节点经过某时长后的时间节点
     * 例初始时间节点: 2014-12-31 23:00:00
     * 经过时长：15:00:00
     * @return 2015-01-01 14:00:00
     */
    public static String StandardaddHHmmss(String starttime, String duration) {
        int durationtime = (int) DateUtil.standardtime2secondslong(duration);
        String endtime = starttime;
        // int starthour = Integer.parseInt(starttime.substring(11,12));
        // int startminute = Integer.parseInt(starttime.substring(14,15));
        //
        // int durationhour = Integer.parseInt(duration.substring(0,1));
        // int durationminute = Integer.parseInt(duration.substring(3,4));

        // starttime = starttime.substring(11,18);
        // if(starttime)
        // String endtime = ;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = sdf.parse(starttime);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.SECOND, durationtime);// 对秒数进行操作

            endtime = sdf.format(calendar.getTime());
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return endtime;
    }
    
    public static String formatDate(Date date,String formatter){
        try{
            SimpleDateFormat sdf = new SimpleDateFormat(formatter);
            return sdf.format(date);
        }catch(Throwable e){
            return "";
        }
    }

    public static String formatDateWithT(Date date,String formatter){
        try{
            SimpleDateFormat sdf = new SimpleDateFormat(formatter);
            String temp = sdf.format(date);
            temp = temp.replace(" ", "T");
            return temp;
        }catch(Throwable e){
            return "";
        }
    }
    
    public static Calendar formatString2Date(String date,String formateer){
        SimpleDateFormat format1 = new SimpleDateFormat(formateer);  
        try {
            Date temp =  format1.parse(date);
            Calendar cal = Calendar.getInstance();
            cal.setTime(temp);
            return cal;
        } catch (ParseException e) {
            return null;
        }
    }
    
    public static Calendar formatString2DateWithT(String date,String formateer){
        date = date.replace("T", " ");
        SimpleDateFormat format1 = new SimpleDateFormat(formateer);  
        try {
            Date temp =  format1.parse(date);
            Calendar cal = Calendar.getInstance();
            cal.setTime(temp);
            return cal;
        } catch (ParseException e) {
            return null;
        }
    }
    
    public static String getTransactionID(){
        Calendar cal = Calendar.getInstance();
        String transactionID = "" + cal.get(Calendar.YEAR) + cal.get(Calendar.MONTH) + cal.get(Calendar.DAY_OF_MONTH) + cal.get(Calendar.HOUR_OF_DAY) + cal.get(Calendar.MINUTE) + cal.get(Calendar.SECOND) ;
        return transactionID;
    }
    
    // 计算间隔时间
    public String intervalTime(String beginTime, String endTime) throws ParseException{
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        java.util.Date beginTimeDate = df.parse(beginTime);
        java.util.Date endTimeDate = df.parse(endTime);
        
        long l = endTimeDate.getTime() - beginTimeDate.getTime();
        long day = l / (24 * 60 * 60 * 1000);
        long hour = (l / (60 * 60 * 1000) - day * 24);
        long min = ((l / (60 * 1000)) - day * 24 * 60 - hour * 60);
        long s = (l / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
        
        return day + "天" + hour + "小时" + min + "分" + s + "秒";
    }
    
    public static void main(String[] args) throws ParseException {
//        String startDate = "2014-09-22";
//        String startTime = "2014-09-22 09:05:02";
//        String endTime = "2014-09-22 12:00:00";

        System.out.println(yyyyMMdd2StandardDate("20140102"));
        System.out.println(HHmmss2StandardTime("151617"));
        System.out.println(StandardaddHHmmss("2014-12-31 23:00:00","15:00:00"));
        
        
        System.out.println("2015-04-24 11:00:00" + isreachStandard("2015-04-24 11:00:00"));
        System.out.println("2011-04-23" + isreachStandard("2011-04-23"));
        System.out.println("EMPTY" + isreachStandard(""));
        System.out.println("123" + isreachStandard("123"));
        System.out.println(isreachStandard(null));
//        
//        Calendar cal = Calendar.getInstance();
//        String s = formatDate(cal.getTime(),"yyyy-MM-ddThh:mm:ss");
//        String s1 = formatDateWithT(cal.getTime(),"yyyy-MM-dd HH:mm:ss");
//        
//        System.out.println(s + "
" + s1 + "
" + new Timestamp(cal.getTime().getTime()));
        System.out.println("2011-04-23".length());

        // 计算间隔时间
        DateUtil dateUtil = new DateUtil();
        String beginTime = "2009-02-28 11:30:41";
        String endTime = "2009-03-01 13:31:40";
        String str = dateUtil.intervalTime(beginTime,endTime);
        System.out.println(str);

    }
}