1 package util;
2
3
4 import java.text.ParseException;
5 import java.text.SimpleDateFormat;
6 import java.util.Calendar;
7 import java.util.Date;
8
9 import org.apache.commons.lang.StringUtils;
10 import org.apache.commons.logging.Log;
11 import org.apache.commons.logging.LogFactory;
12
13 /**

14 * 日期处理工具类

15 * @author 程欢

16 * 2013-1-11 04:33:50

17 */
18 public class DateUtil {
      19
      20 private static final transient Log log = LogFactory.getLog(DateUtil.class);
      21
      22 /**

23 * 缺省的日期格式

24 */
      25 private static final String DAFAULT_DATE_FORMAT = yyyy-M-d;
      26
      27 private static final String DATE_FORMAT = yyyy-MM-dd;
      28
      29 /**

30 * 默认日期类型格试.

31 * 

32 * @see DAFAULT_DATE_FORMAT

33 */
      34 private static SimpleDateFormat dateFormat = new SimpleDateFormat(DAFAULT_DATE_FORMAT);
      35
      36 /**

37 * 缺省的日期时间格式

38 */
      39 private static final String DAFAULT_DATETIME_FORMAT = yyyy-M-d HH:mm:ss;
      40
      41 /**

42 * 时间格式

43 */
      44 private static String DATETIME_FORMAT = DAFAULT_DATETIME_FORMAT;
      45
      46 private static SimpleDateFormat datetimeFormat = new SimpleDateFormat(DATETIME_FORMAT);
      47
      48 /**

49 * 缺省的时间格式

50 */
      51 private static final String DAFAULT_TIME_FORMAT = HH:mm:ss;
      52
      53 /**

54 * 时间格式

55 */
      56 private static String TIME_FORMAT = DAFAULT_TIME_FORMAT;
      57
      58 private static SimpleDateFormat timeFormat = new SimpleDateFormat(TIME_FORMAT);
      59
      60 private DateUtil()
      61 {
            62 // 私用构造主法.因为此类是工具类.
      63 }
      64
      65 /**

66 * 获取格式化实例.

67 * 

68 * @param pattern

69 * 如果为空使用DAFAULT_DATE_FORMAT

70 * @return

71 */
      72 public static SimpleDateFormat getFormatInstance(String pattern) {
            73 if (pattern == null || pattern.length() == 0)
            74 {
                  75 pattern = DAFAULT_DATE_FORMAT;
            76 }
            77 return new SimpleDateFormat(pattern);
      78 }
      79
      80 /**

81 * 格式化Calendar

82 * 

83 * @param calendar

84 * @return

85 */
      86 public static String formatCalendar(Calendar calendar) {
            87 if (calendar == null)
            88 {
                  89 return ;
            90 }
            91 return dateFormat.format(calendar.getTime());
      92 }
      93
      94 public static String formatDateTime(Date d) {
            95 if (d == null)
            96 {
                  97 return ;
            98 }
            99 return datetimeFormat.format(d);
      100 }
      101
      102 public static String formatDate(Date d) {
            103 if (d == null)
            104 {
                  105 return ;
            106 }
            107 return dateFormat.format(d);
      108 }
      109
      110 /**

111 * 格式化时间

112 * 

113 * @param calendar

114 * @return

115 */
      116 public static String formatTime(Date d) {
            117 if (d == null)
            118 {
                  119 return ;
            120 }
            121 return timeFormat.format(d);
      122 }
      123
      124 /**

125 * 格式化整数型日期

126 * 

127 * @param intDate

128 * @return

129 */
      130 public static String formatIntDate(Integer intDate) {
            131 if (intDate == null)
            132 {
                  133 return ;
            134 }
            135 Calendar c = newCalendar(intDate);
            136 return formatCalendar(c);
      137 }
      138
      139 /**

140 * 根据指定格式化来格式日期.

141 * 

142 * @param date

143 * 待格式化的日期.

144 * @param pattern

145 * 格式化样式或分格,如yyMMddHHmmss

146 * @return 字符串型日期.

147 */
      148 public static String formatDate(Date date, String pattern) {
            149 if (date == null)
            150 {
                  151 return ;
            152 }
            153 if (StringUtils.isBlank(pattern))
            154 {
                  155 return formatDate(date);
            156 }
            157 SimpleDateFormat simpleDateFormat = null;
            158 try
            159 {
                  160 simpleDateFormat = new SimpleDateFormat(pattern);
            161 } catch (Exception e)
            162 {
                  163 e.printStackTrace();
                  164 return formatDate(date);
            165 }
            166 return simpleDateFormat.format(date);
      167 }
      168
      169 /**

170 * 取得Integer型的当前日期

171 * 

172 * @return

173 */
      174 public static Integer getIntNow() {
            175 return getIntDate(getNow());
      176 }
      177
      178 /**

179 * 取得Integer型的当前日期

180 * 

181 * @return

182 */
      183 public static Integer getIntToday() {
            184 return getIntDate(getNow());
      185 }
      186
      187 /**

188 * 取得Integer型的当前年份

189 * 

190 * @return

191 */
      192 public static Integer getIntYearNow() {
            193 Calendar c = Calendar.getInstance();
            194 int year = c.get(Calendar.YEAR);
            195 return year;
      196 }
      197
      198 /**

199 * 取得Integer型的当前月份

200 * 

201 * @return

202 */
      203 public static Integer getIntMonthNow() {
            204 Calendar c = Calendar.getInstance();
            205 int month = c.get(Calendar.MONTH) + 1;
            206 return month;
      207 }
      208
      209 public static String getStringToday() {
            210 return getIntDate(getNow()) + ;
      211 }
      212
      213 /**

214 * 根据年月日获取整型日期

215 * 

216 * @param year

217 * @param month

218 * @param day

219 * @return

220 */
      221 public static Integer getIntDate(int year, int month, int day) {
            222 return getIntDate(newCalendar(year, month, day));
      223 }
      224
      225 /**

226 * 某年月的第一天

227 * 

228 * @param year

229 * @param month

230 * @return

231 */
      232 public static Integer getFirstDayOfMonth(int year, int month) {
            233 return getIntDate(newCalendar(year, month, 1));
      234 }
      235
      236 /**

237 * 某年月的第一天

238 * 

239 * @param year

240 * @param month

241 * @return

242 */
      243 public static Integer getFirstDayOfThisMonth() {
            244 Integer year = DateUtil.getIntYearNow();
            245 Integer month = DateUtil.getIntMonthNow();
            246 return getIntDate(newCalendar(year, month, 1));
      247 }
      248
      249 /**

250 * 某年月的第一天

251 * 

252 * @param date

253 * @return

254 * @time:2008-7-4 上午09:58:55

255 */
      256 public static Integer getFistDayOfMonth(Date date) {
            257 Integer intDate = getIntDate(date);
            258 int year = intDate / 10000;
            259 int month = intDate % 10000 / 100;
            260 return getIntDate(newCalendar(year, month, 1));
      261 }
      262
      263 /**

264 * 某年月的最后一天

265 * 

266 * @param year

267 * @param month

268 * @return

269 */
      270 public static Integer getLastDayOfMonth(int year, int month) {
            271 return intDateSub(getIntDate(newCalendar(year, month + 1, 1)), 1);
      272 }
      273
      274 /**

275 * 根据Calendar获取整型年份

276 * 

277 * @param c

278 * @return

279 */
      280 public static Integer getIntYear(Calendar c) {
            281 int year = c.get(Calendar.YEAR);
            282 return year;
      283 }
      284
      285 /**

286 * 根据Calendar获取整型日期

287 * 

288 * @param c

289 * @return

290 */
      291 public static Integer getIntDate(Calendar c) {
            292 int year = c.get(Calendar.YEAR);
            293 int month = c.get(Calendar.MONTH) + 1;
            294 int day = c.get(Calendar.DAY_OF_MONTH);
            295 return year * 10000 + month * 100 + day;
      296 }
      297
      298 /**

299 * 根据Date获取整型年份

300 * 

301 * @param d

302 * @return

303 */
      304 public static Integer getIntYear(Date d) {
            305 if (d == null)
            306 {
                  307 return null;
            308 }
            309 Calendar c = Calendar.getInstance();
            310 c.setTime(d);
            311 return getIntYear(c);
      312 }
      313
      314 /**

315 * 根据Date获取整型日期

316 * 

317 * @param d

318 * @return

319 */
      320 public static Integer getIntDate(Date d) {
            321 if (d == null)
            322 {
                  323 return null;
            324 }
            325 Calendar c = Calendar.getInstance();
            326 c.setTime(d);
            327 return getIntDate(c);
      328 }
      329
      330 /**

331 * 根据Integer获取Date日期

332 * 

333 * @param n

334 * @return

335 */
      336 public static Date getDate(Integer n) {
            337 if (n == null)
            338 {
                  339 return null;
            340 }
            341 Calendar c = Calendar.getInstance();
            342 c.set(n / 10000, n / 100 % 100 - 1, n % 100);
            343 return c.getTime();
      344 }
      345
      346 public static Date getDate(String date) {
            347 if (date == null || date.length() == 0)
            348 {
                  349 return null;
            350 }
            351
            352 try
            353 {
                  354 if (date.contains(/))
                  355 {
                        356 date = date.replaceAll(/, -);
                  357 }
                  358 return getFormatInstance(DATE_FORMAT).parse(date);
            359 } catch (ParseException e)
            360 {
                  361 log.error(解析[ + date + ]错误！, e);
                  362 return null;
            363 }
      364 }
      365
      366 /**

367 * 根据年份Integer获取Date日期

368 * 

369 * @param year

370 * @return

371 */
      372 public static Date getFirstDayOfYear(Integer year) {
            373 if (year == null)
            374 {
                  375 return null;
            376 }
            377 Calendar c = Calendar.getInstance();
            378 c.set(year, 1, 1);
            379 return c.getTime();
      380 }
      381
      382 /**

383 * 根据年月日生成Calendar

384 * 

385 * @param year

386 * @param month

387 * @param day

388 * @return

389 */
      390 public static Calendar newCalendar(int year, int month, int day) {
            391 Calendar ret = Calendar.getInstance();
            392 if (year < 100)
            393 {
                  394 year = 2000 + year;
            395 }
            396 ret.set(year, month - 1, day);
            397 return ret;
      398 }
      399
      400 /**

401 * 根据整型日期生成Calendar

402 * 

403 * @param date

404 * @return

405 */
      406 public static Calendar newCalendar(int date) {
            407 int year = date / 10000;
            408 int month = (date % 10000) / 100;
            409 int day = date % 100;
            410
            411 Calendar ret = Calendar.getInstance();
            412 ret.set(year, month - 1, day);
            413 return ret;
      414 }
      415
      416 /**

417 * 取得Date型的当前日期

418 * 

419 * @return

420 */
      421 public static Date getNow() {
            422 return new Date();
      423 }
      424
      425 /**

426 * 取得Date型的当前日期

427 * 

428 * @return

429 */
      430 public static Date getToday() {
            431 return DateUtil.getDate(DateUtil.getIntToday());
      432 }
      433
      434 /**

435 * 整数型日期的加法

436 * 

437 * @param date

438 * @param days

439 * @return

440 */
      441 public static Integer intDateAdd(int date, int days) {
            442 int year = date / 10000;
            443 int month = (date % 10000) / 100;
            444 int day = date % 100;
            445
            446 day += days;
            447
            448 return getIntDate(year, month, day);
      449 }
      450
      451 /**

452 * 整数型日期的减法

453 * 

454 * @param date

455 * @param days

456 * @return

457 */
      458 public static Integer intDateSub(int date, int days) {
            459 return intDateAdd(date, -days);
      460 }
      461
      462 /**

463 * 计算两个整型日期之间的天数

464 * 

465 * @param startDate

466 * @param endDate

467 * @return

468 */
      469 public static Integer daysBetweenDate(Integer startDate, Integer endDate) {
            470 if (startDate == null || endDate == null)
            471 {
                  472 return null;
            473 }
            474 Calendar c1 = newCalendar(startDate);
            475 Calendar c2 = newCalendar(endDate);
            476
            477 Long lg = (c2.getTimeInMillis() - c1.getTimeInMillis()) / 1000 / 60 / 60 / 24;
            478 return lg.intValue();
      479 }
      480
      481 /**

482 * 计算两个整型日期之间的天数

483 * 

484 * @param startDate

485 * @param endDate

486 * @return

487 */
      488 public static Integer daysBetweenDate(Date startDate, Date endDate) {
            489 if (startDate == null || endDate == null)
            490 {
                  491 return null;
            492 }
            493 Long interval = endDate.getTime() - startDate.getTime();
            494 interval = interval / (24 * 60 * 60 * 1000);
            495 return interval.intValue();
      496 }
      497
      498 /**

499 * 取得当前日期.

500 * 

501 * @return 当前日期,字符串类型.

502 */
      503 public static String getStringDate() {
            504 return getStringDate(DateUtil.getNow());
      505 }
      506
      507 /**

508 * 根据calendar产生字符串型日期

509 * 

510 * @param d

511 * @return eg:20080707

512 */
      513 public static String getStringDate(Date d) {
            514 if (d == null)
            515 {
                  516 return ;
            517 }
            518 SimpleDateFormat sdf = new SimpleDateFormat(yyyyMMdd);
            519 return sdf.format(d);
      520 }
      521
      522 public static String getFormatStringDate(Date d) {
            523 if (d == null)
            524 {
                  525 return ;
            526 }
            527 SimpleDateFormat sdf = new SimpleDateFormat(yyyy年MM月dd日);
            528 return sdf.format(d);
      529 }
      530 // /**

531 // * 国际化。

532 // */
      533 // public static String formatI18nDate(Date date){
            534 // if(date == null){
                  535 // return ;
            536 // }
            537 // ActionSupport actionSupport = new ActionSupport();
            538 // SimpleDateFormat sdf = new
            539 // SimpleDateFormat(actionSupport.getText(date.i18n.format));
            540 // return sdf.format(date);
      541 // }
      542
543 }

该贴由koei转至本版2014-5-2 16:22:06