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 }
