JAVA 时间工具类

  1 package com.XXXXX.XXXXXXX.XXXXXXXX;
  2 
  3 import java.sql.Timestamp;
  4 import java.text.DateFormat;
  5 import java.text.ParseException;
  6 import java.text.SimpleDateFormat;
  7 import java.util.Calendar;
  8 import java.util.Date;
  9 import java.util.StringTokenizer;
 10 import java.util.regex.Matcher;
 11 import java.util.regex.Pattern;
 12 
 13 /**
 14  * 日期时间管理类.
 15  * <p>
 16  * Title: CicroDate
 17  * </p>
 18  * <p>
 19  * Description: 日期时间管理
 20  * </p>
 21  * <p>
 22  * Copyright: Copyright (c) 2002
 23  * </p>
 24  * <p>
 25  * Company: Cicro
 26  * </p>
 27  * 
 28  * @author kongxx
 29  * @author Sunyi
 30  * @version 1.3 *
 31  */
 32 
 33 public class DateUtil {
 34     private static final String DATE_PATTERN = "yyyy-MM-dd";
 35     private static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
 36 
 37     /**
 38      * 获取当前系统时间. 默认模板格式yyyy-MM-dd hh:mm:ss.
 39      * 
 40      * @return 当前系统时间
 41      */
 42     public static String getCurrentDateTime() {
 43         return getCurrentDateTime(DATETIME_PATTERN);
 44     }
 45 
 46     /**
 47      * 获取当前系统同期。
 48      * 
 49      * @return 当前系统日期
 50      * @author zhenggz 2003-11-09
 51      */
 52     public static String getCurrentDate() {
 53         return getCurrentDateTime(DATE_PATTERN);
 54     }
 55 
 56     /**
 57      * 获取当前系统时间.
 58      * 
 59      * @param strPattern
 60      *            时间模板
 61      * @return 当前系统时间
 62      */
 63     public static String getCurrentDateTime(String pattern) {
 64         Calendar cal = Calendar.getInstance();
 65         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
 66         return sdf.format(cal.getTime());
 67     }
 68 
 69     /**
 70      * 把字串转化成为Date对象，时间字串格式为2000-01-01 00:00:00
 71      * 
 72      * @param dateString
 73      *            被转化的时间字串，以 yyyy-MM-dd HH:mm:ss 的格式
 74      * @throws ParseException
 75      * */
 76     public static Date getDate(String dateStr) throws ParseException {
 77         return getDate(dateStr, DATETIME_PATTERN);
 78     }
 79 
 80     /**
 81      * 把字串转化成为Date对象，时间字串格式需要设定
 82      * 
 83      * @param dateString
 84      *            被转化的时间字串
 85      * @param pattern
 86      *            时间字串的日期格式，如yyyy-MM-dd
 87      * @throws ParseException
 88      * */
 89     public static Date getDate(String dateStr, String pattern)
 90             throws ParseException {
 91         Date date = null;
 92         SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
 93         date = dateFormat.parse(dateStr);
 94 
 95         return date;
 96     }
 97 
 98     /**
 99      * 取得日期字串
100      * 
101      * @param date
102      *            Date对象
103      * @return 日期字串，格式如：2003-12-02
104      * */
105     public static String getDateString(Date date) {
106         return getString(date, DATE_PATTERN);
107     }
108 
109     /**
110      * 取得日期时间字串
111      * 
112      * @param date
113      *            Date对象
114      * @return 日期时间字串，格式如：2003-12-02 13:10:00
115      * */
116     public static String getDateTimeString(Date date) {
117         return getString(date, DATETIME_PATTERN);
118     }
119 
120     /**
121      * 按照指定格式取得时间字串
122      * 
123      * @param date
124      *            Date对象
125      * @param pattern
126      *            时间字串的日期格式，如yyyy-MM-dd
127      * @return 日期时间字串，格式如：2003-12-02 13:10:00
128      * */
129     public static String getString(Date date, String pattern) {
130         SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
131 
132         return dateFormat.format(date);
133     }
134 
135     /**
136      * 格式化日期字串
137      * 
138      * @param dateStr
139      * @return 格式化后的字串，格式如：2003-12-02
140      * */
141     public static String formatToDateString(String dateStr)
142             throws ParseException {
143         return formatToString(dateStr, DATE_PATTERN);
144     }
145 
146     /**
147      * 格式化日期时间字串
148      * 
149      * @param dateTimeStr
150      * @return String　格式化后的字串，格式如：2003-12-02 12:12:10
151      * */
152     public static String formatToDateTimeString(String dateTimeStr)
153             throws ParseException {
154         return formatToString(dateTimeStr, DATETIME_PATTERN);
155     }
156 
157     /**
158      * 格式化日期时间字串为指定的格式字串
159      * 
160      * @param String
161      *            时间字串
162      * @param String
163      *            时间字串的日期格式，如yyyy-MM-dd
164      * @return String　格式化后的字串，格式如：2003-12-02 12:12:10
165      * */
166     public static String formatToString(String dateStr, String pattern)
167             throws ParseException {
168         dateStr = format(dateStr);
169         Date date = null;
170         if (checkDateString(dateStr)) {
171             date = getDate(dateStr, DATE_PATTERN);
172             return getString(date, pattern);
173         } else if (checkDateTimeString(dateStr)) {
174             date = getDate(dateStr);
175             return getString(date, pattern);
176         } else {
177             throw new ParseException("日期格式不正确", 1);
178         }
179     }
180 
181     /**
182      * 检查日期字串的格式
183      * 
184      * @param String
185      *            时间字串 YYYY-MM-DD
186      * @return boolean　true or false
187      * */
188     public static boolean checkDateString(String dateStr) {
189         Pattern pattern = Pattern.compile("\\d{2,4}-\\d{1,2}-\\d{1,2}");
190         Matcher matcher = pattern.matcher(dateStr);
191 
192         return matcher.matches();
193     }
194 
195     /**
196      * 检查日期时间字串的格式
197      * 
198      * @param String
199      *            时间字串 YYYY-MM-DD hh:mm:ss
200      * @return boolean　true or false
201      * */
202     public static boolean checkDateTimeString(String dateTimeStr) {
203         Pattern pattern = Pattern
204                 .compile("\\d{2,4}-\\d{1,2}-\\d{1,2}\\s\\d{1,2}:\\d{1,2}:\\d{1,2}");
205         Matcher matcher = pattern.matcher(dateTimeStr);
206 
207         return matcher.matches();
208     }
209 
210     /**
211      * 规范化时间字串
212      * 
213      * @param String
214      *            时间字串
215      * @return String　格式化后的字串，格式如：2003-12-02 12:12:10
216      * */
217     public static String format(String dateStr) {
218         Pattern pattern = Pattern
219                 .compile("\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}.*");
220         Matcher matcher = pattern.matcher(dateStr);
221         if (matcher.matches()) {
222             dateStr = dateStr.substring(0, 19);
223         } else {
224             pattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}.*");
225             matcher = pattern.matcher(dateStr);
226             if (matcher.matches()) {
227                 dateStr = dateStr.substring(0, 10);
228             }
229         }
230 
231         return dateStr;
232     }
233 
234     /**
235      * History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
236      * 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
237      * 
238      * @param Date
239      *            date 时间对象
240      * @return int 返回这日期的年份　格式如：2010
241      */
242     public static int getYear(Date date) {
243         Calendar calendar = Calendar.getInstance();
244         calendar.setTime(date);
245         int year = calendar.get(Calendar.YEAR);
246         return year;
247     }
248 
249     /**
250      * History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
251      * 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
252      * 
253      * @param Date
254      *            date 时间对象
255      * @return　int 返回这日期的月份　格式如：11
256      */
257     public static int getMonth(Date date) {
258         Calendar calendar = Calendar.getInstance();
259         calendar.setTime(date);
260         int month = calendar.get(Calendar.MONTH);
261         return month;
262     }
263 
264     /**
265      * History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
266      * 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
267      * 
268      * @param Date
269      *            date 时间对象
270      * @return　int 返回这日期在当月的第几天　格式如：15
271      */
272     public static int getDayOfMonth(Date date) {
273         Calendar calendar = Calendar.getInstance();
274         calendar.setTime(date);
275         int day = calendar.get(Calendar.DAY_OF_MONTH);
276         return day;
277     }
278 
279     /**
280      * History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
281      * 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
282      * 
283      * @param Date
284      *            date 时间对象
285      * @return int　返回这日期在第几周　格式如：52
286      */
287     public static int getDayOfWek(Date date) {
288         Calendar calendar = Calendar.getInstance();
289         calendar.setTime(date);
290         int day = calendar.get(Calendar.DAY_OF_WEEK);
291         return day;
292     }
293 
294     /**
295      * History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
296      * 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
297      * 
298      * @param Date
299      *            date 时间对象
300      * @return int　返回这日期的小时　格式如：23
301      */
302     public static int getHour(Date date) {
303         Calendar calendar = Calendar.getInstance();
304         calendar.setTime(date);
305         int hour = calendar.get(Calendar.HOUR_OF_DAY);
306         return hour;
307     }
308 
309     /**
310      * History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
311      * 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
312      * 
313      * @param Date
314      *            date 时间对象
315      * @return int　返回这日期的分钟　格式如：59
316      */
317     public static int getMinute(Date date) {
318         Calendar calendar = Calendar.getInstance();
319         calendar.setTime(date);
320         int minute = calendar.get(Calendar.MINUTE);
321         return minute;
322     }
323 
324     /**
325      * History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
326      * 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
327      * 
328      * @param Date
329      *            date 时间对象
330      * @return　int 返回这日期的秒钟　格式如：40
331      */
332     public static int getSecond(Date date) {
333         Calendar calendar = Calendar.getInstance();
334         calendar.setTime(date);
335         int second = calendar.get(Calendar.SECOND);
336         return second;
337     }
338 
339     /**
340      * 获得某天的开始时间的Date对象，一般用来作比较用
341      * 
342      * @param Date
343      *            date 时间对象
344      * @return Date
345      */
346     public static Date getStartOfDay(Date date) {
347         Date startDate = null;
348         try {
349             startDate = DateUtil.getDate(
350                     DateUtil.getString(date, "yyyy-MM-dd"), "yyyy-MM-dd");
351         } catch (Exception e) {
352             return null;
353         }
354         return startDate;
355     }
356 
357     /**
358      * 获得某天的结束时间的Date对象，一般用来作比较用
359      * 
360      * @param Date
361      *            date 时间对象
362      * @return Date
363      */
364     public static Date getEndOfDay(Date date) {
365         Calendar calendar = Calendar.getInstance();
366         Date endDate = null;
367         try {
368             calendar.set(DateUtil.getYear(date), DateUtil.getMonth(date),
369                     DateUtil.getDayOfMonth(date), 23, 59, 59);
370             endDate = calendar.getTime();
371         } catch (Exception e) {
372             return null;
373         }
374         return endDate;
375     }
376 
377     /**
378      * 获得某天所在的星期的第一天（星期一）的开始时间（0时0分0秒）Date对象，一般用来作比较用
379      * 
380      * @param Date
381      *            date 时间对象
382      * @return Date
383      */
384     public static Date getStartOfWeek(Date date) {
385         Calendar calendar = Calendar.getInstance();
386         calendar.setTime(date);
387         int n = 0;
388         int day = calendar.get(Calendar.DAY_OF_WEEK);
389         switch (day) {
390         case Calendar.MONDAY: {
391             n = 0;
392             break;
393         }
394         case Calendar.TUESDAY: {
395             n = 1;
396             break;
397         }
398         case Calendar.WEDNESDAY: {
399             n = 2;
400             break;
401         }
402         case Calendar.THURSDAY: {
403             n = 3;
404             break;
405         }
406         case Calendar.FRIDAY: {
407             n = 4;
408             break;
409         }
410         case Calendar.SATURDAY: {
411             n = 5;
412             break;
413         }
414         case Calendar.SUNDAY: {
415             n = 6;
416             break;
417         }
418         }
419         Date monday = new Date(date.getTime() - 24 * 60 * 60 * 1000 * n);
420         Date startDate = getStartOfDay(monday);
421         return startDate;
422     }
423 
424     /**
425      * 获得某天所在的星期的最后一天（星期天）的结束时间（23时59分59秒）Date对象，一般用来作比较用
426      * 
427      * @param Date
428      *            date 时间对象
429      * @return Date
430      */
431     public static Date getEndOfWeek(Date date) {
432         Calendar calendar = Calendar.getInstance();
433         calendar.setTime(date);
434         int n = 0;
435         int day = calendar.get(Calendar.DAY_OF_WEEK);
436         switch (day) {
437         case Calendar.MONDAY: {
438             n = 6;
439             break;
440         }
441         case Calendar.TUESDAY: {
442             n = 5;
443             break;
444         }
445         case Calendar.WEDNESDAY: {
446             n = 4;
447             break;
448         }
449         case Calendar.THURSDAY: {
450             n = 3;
451             break;
452         }
453         case Calendar.FRIDAY: {
454             n = 2;
455             break;
456         }
457         case Calendar.SATURDAY: {
458             n = 1;
459             break;
460         }
461         case Calendar.SUNDAY: {
462             n = 0;
463             break;
464         }
465         }
466         Date sunday = new Date(date.getTime() + 24 * 60 * 60 * 1000 * n);
467         Date startDate = getEndOfDay(sunday);
468         return startDate;
469     }
470 
471     /**
472      * 判断两个日期之间相差的天数
473      * 
474      * @param String
475      *            day1 时间1 2010-01-03
476      * @param String
477      *            day1 时间2 2010-01-05
478      * @return long 相差天数
479      */
480     public static long daysOf2Day(String day1, String day2) {
481         try {
482             day1 += " 00:00:00";
483             day2 += " 00:00:00";
484             long secs = secsOf2Day(day1, day2);
485             return secs / (24 * 60 * 60);
486         } catch (Exception e) {
487             return -1;
488         }
489     }
490 
491     /**
492      * 判断两个时间之间相差的天数
493      * 
494      * @param String
495      *            day1 时间1 2010-01-03 00:00:00
496      * @param String
497      *            day1 时间2 2010-01-05 10:25:44
498      * @return long 相差天数
499      */
500     public static long secsOf2Day(String day1, String day2) {
501         try {
502             Date date1 = getDate(day1);
503             Date date2 = getDate(day2);
504             long secs = Math.abs(date1.getTime() - date2.getTime()) / 1000;
505             return secs;
506         } catch (Exception e) {
507             return -1;
508         }
509     }
510 
511     /**
512      * 获得到当前时间为止的天数,不足一天按一天计.
513      * 
514      * @param strDateTime
515      *            ‘yyyy-mm-dd hh:mm:ss‘
516      * @return 天数
517      */
518     public static String getDaysToNow(String strDateTime) {
519         try {
520             StringTokenizer strToken = new StringTokenizer(strDateTime, " ");
521             StringTokenizer strTokenDate = new StringTokenizer(
522                     strToken.nextToken(), "-");
523             StringTokenizer strTokenTime = new StringTokenizer(
524                     strToken.nextToken(), ":");
525             int intYear = Integer.parseInt(strTokenDate.nextToken());
526             int intMonth = Integer.parseInt(strTokenDate.nextToken()) - 1;
527             int intDay = Integer.parseInt(strTokenDate.nextToken());
528             int intHour = Integer.parseInt(strTokenTime.nextToken());
529             int intMin = Integer.parseInt(strTokenTime.nextToken());
530             int intSec = Integer.parseInt(strTokenTime.nextToken());
531 
532             Calendar cal = Calendar.getInstance();
533             cal.set(intYear, intMonth, intDay, intHour, intMin, intSec);
534             long longDays = (new Date().getTime() - cal.getTimeInMillis()) / 24
535                     / 60 / 60 / 1000;
536             longDays = longDays == 0 ? 1 : longDays;
537 
538             return "" + longDays;
539         } catch (Exception e) {
540             return "0";
541         }
542     }
543 
544     /**
545      * 比较两个时间的差值
546      * 
547      * @param date1
548      *            yyyy-MM-dd HH:mm:ss
549      * @param date2
550      *            yyyy-MM-dd HH:mm:ss
551      * @return int 小时
552      */
553     public static long compareDatetime(String date1, String date2) {
554         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
555         long timestamp1 = -1;
556         long timestamp2 = -1;
557         // 先将时间格式转换成Timestamp
558         try {
559             timestamp1 = df.parse(date1).getTime() / 1000;
560             timestamp2 = df.parse(date2).getTime() / 1000;
561         } catch (ParseException e) {
562             System.out.println("时间格式 [ " + date1 + " ] 或 [ " + date2
563                     + " ] 无法被解析");
564             return -1;
565         }
566         if (timestamp1 > timestamp2)
567             return (timestamp1 - timestamp2) / 3600;
568         else
569             return (timestamp2 - timestamp1) / 3600;
570 
571     }
572 
573     /**
574      * 得到某个数值之后的时间
575      * 
576      * @param String
577      *            yyyy-MM-dd HH:mm:ss
578      * @param int 整数
579      * @return String yyyy-MM-dd HH:mm:ss
580      */
581     public static Date getDateTimesAfter(String datetimes, int day) {
582         Calendar now = Calendar.getInstance();
583         try {
584             now.setTime(getDate(datetimes, DATETIME_PATTERN));
585         } catch (ParseException e) {
586             System.out.println("时间格式 [ " + datetimes + " ]  无法被解析");
587             return null;
588         }
589         now.set(Calendar.DATE, now.get(Calendar.DATE) + day);
590         return now.getTime();
591     }
592 
593     /**
594      * 得到某个数值之后的时间
595      * 
596      * @param String
597      *            yyyy-MM-dd HH:mm:ss　or yyyy-MM-dd
598      * @param int 整数
599      * @return String yyyy-MM-dd
600      */
601     public static Date getDateAfter(String datetimes, int day) {
602         Calendar now = Calendar.getInstance();
603         try {
604             now.setTime(getDate(datetimes, DATE_PATTERN));
605         } catch (ParseException e) {
606             System.out.println("时间格式 [ " + datetimes + " ]  无法被解析");
607             return null;
608         }
609         now.set(Calendar.DATE, now.get(Calendar.DATE) + day);
610         return now.getTime();
611     }
612 
613     /**
614      * 得到某个数值之前的日期
615      * 
616      * @param String
617      *            yyyy-MM-dd HH:mm:ss　or yyyy-MM-dd
618      * @param int 整数
619      * @return String yyyy-MM-dd
620      */
621     public static String getDateBefore(String datetimes, int day) {
622         Calendar now = Calendar.getInstance();
623         try {
624             now.setTime(getDate(datetimes, DATE_PATTERN));
625         } catch (ParseException e) {
626             System.out.println("时间格式 [ " + datetimes + " ]  无法被解析");
627             return null;
628         }
629         now.set(Calendar.DATE, now.get(Calendar.DATE) - day);
630         return getString(now.getTime(), "yyyy-MM-dd");
631     }
632 
633     /**
634      * 将某个时间的Timestamp转换成Datetime
635      * 
636      * @param long 时间数值
637      * @param String
638      *            时间格式　yyyy-MM-dd hh:mm:ss
639      * @return String yyyy-MM-dd hh:mm:ss
640      */
641     public static String timestampToDate(long timestamp, String format) {
642         Date date = new Timestamp(timestamp);
643         DateFormat df = new SimpleDateFormat(format);
644         return df.format(date);
645     }
646 
647     /**
648      * 得到当前时间的数值
649      * 
650      * @return String yyyy-MM-dd hh:mm:ss
651      */
652     public static long dateToTimestamp() {
653         long ts = System.currentTimeMillis();
654         return ts;
655     }
656 
657     /**
658      * 得到指定时间之后的时间
659      * 
660      * @param String
661      *            time
662      * @param int num
663      * @return String yyyy-MM-dd hh:mm:ss
664      */
665     public static String getDateTimeAfter(String times, int num) {
666         if (times == null || "".equals(times))
667             times = getCurrentDateTime();
668 
669         long tl = dateToTimestamp(times) + num * 1000;
670         return timestampToDate(tl, "yyyy-MM-dd HH:mm:ss");
671     }
672 
673     /**
674      * 将某个时间的Datetime转换成Timestamp
675      * 
676      * @param dateFormat
677      *            yyyy-MM-dd HH:mm:ss
678      * @return long
679      */
680     public static long dateToTimestamp(String dateFormat) {
681         long timestamp = -1;
682         try {
683             DateFormat df = new SimpleDateFormat(DATETIME_PATTERN);
684             Date date = df.parse(dateFormat);
685             timestamp = date.getTime();
686         } catch (Exception e) {
687             System.out.println("时间格式 [ " + dateFormat + " ] 无法被解析");
688         }
689         return timestamp;
690     }
691 
692     public static long compareDatetime2(String date1, String date2) {
693         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
694         long timestamp1 = -1;
695         long timestamp2 = -1;
696         // 先将时间格式转换成Timestamp
697         try {
698             timestamp1 = df.parse(date1).getTime();
699             timestamp2 = df.parse(date2).getTime();
700         } catch (ParseException e) {
701             System.out.println("时间格式 [ " + date1 + " ] 或 [ " + date2
702                     + " ] 无法被解析");
703             return -1;
704         }
705         if (timestamp1 > timestamp2)
706             return (timestamp1 - timestamp2);
707         else
708             return (timestamp2 - timestamp1);
709 
710     }
711 
712     // 对比两个日期大小
713     public static boolean compare_date(String DATE1, String DATE2) {
714         DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
715         try {
716             Date dt1 = df.parse(DATE1);
717             Date dt2 = df.parse(DATE2);
718             if (dt1.getTime() > dt2.getTime()) {
719                 // System.out.println("dt1 在dt2前");
720                 return false;
721             } else if (dt1.getTime() < dt2.getTime()) {
722                 // System.out.println("dt1在dt2后");
723                 return true;
724             } else {
725                 return true;
726             }
727         } catch (Exception exception) {
728             exception.printStackTrace();
729         }
730         return true;
731     }
732 
733     public static void main(String[] args) throws Exception {
734         // System.out.println(getDaysToNow("2010-01-10 00:00:00"));
735         // System.out.println(compare_date("2011-05-16 17:50:50","2011-05-16 17:50:55"));
736         // System.out.println(getDateTimesAfter("2010-01-10 12:00:00",-5));
737         // System.out.println(getDateAfter("2010-01-10",-5));
738         // System.out.println(timestampToDate(1262575579707L,"yyyy-MM-dd HH:mm:ss"));
739         System.out.println(compareDatetime("2012-02-02 17:36:46:673",
740                 "2012-02-03 18:47:37:392"));
741 
742         // "2010-01-20 17:58:37:319","2010-01-20 18:44:32:592" ibatis + bonecp
743         // 27ss
744         // "2010-01-21 14:51:49:307","2010-01-21 15:47:45:794" hib + c3p0 33ss
745         // "2010-01-21 17:36:46:673","2010-01-21 18:47:37:392" ibatis + c3p0
746         // 42ss
747 
748         // System.out.println(dateToTimestamp());
749         // System.out.println(timestampToDate(1268231397000L-120000,"yyyy-MM-dd HH:mm:ss"));
750 
751         System.out.println(DateUtil.getDateString(getDateAfter(
752                 "2012-02-02 17:36:46", 30)));
753     }
754 }