Java中的时间格式化和时间计算的方法

最近工程项目里需要频繁地计算时间，比如取得去年的今天，上个月的现在时间，前几天，后几天等等。一开始都是在需要的地方，写个方法，后来随着工程的开发，这样的时间计算和格式化需要的越来越多。干脆索性就直接写个日期时间管理类。下面就是具体方法代码：

首先定义一些静态常量，通常会作为参数来表达时间的格式等等：

[java]  view plain copy

1. private static String TIME_PATTERN="HH:mm:ss";//定义标准时间格式  
2. private static String DATE_PATTERN_1="yyyy/MM/dd";//定义标准日期格式1  
3. private static String DATE_PATTERN_2="yyyy-MM-dd";//定义标准日期格式2  
4. private static String DATE_PATTERN_3="yyyy/MM/dd HH:mm:ss";//定义标准日期格式3，带有时间  
5. private static String DATE_PATTERN_4="yyyy/MM/dd HH:mm:ss E";//定义标准日期格式4，带有时间和星期  
6. private static String DATE_PATTERN_5="yyyy年MM月dd日 HH:mm:ss E";//定义标准日期格式5，带有时间和星期  
7. /** 
8.  * 定义时间类型常量 
9.  */  
10. private final static int SECOND=1;  
11. private final static int MINUTE=2;  
12. private final static int HOUR=3;  
13. private final static int DAY=4;  

项目里一般都是以现在时间作为参考，所以就直接定义了一个全局变量，并用构造方法初始化。

[java]  view plain copy

1. private Date now;  
2. public Date getNow() {  
3.     return now;  
4. }  
5. public void setNow(Date now) {  
6.     this.now = now;  
7. }  
8. /** 
9.  * 构造方法，初始化now时间 
10.  */  
11. public DateTimeUtil(){  
12.     now=new Date();  
13. }  

下面是Date时间和字符串时间互相转换的两个方法，主要是利用java.text.SimpleDateFormat类。其中由字符串转换为时间的时候，需要捕获异常。

[java]  view plain copy

1. /** 
2.  * 把一个日期，按照某种格式 格式化输出 
3.  * @param date 日期对象 
4.  * @param pattern 格式模型 
5.  * @return 返回字符串类型 
6.  */  
7. public String formatDate(Date date, String pattern){  
8.     SimpleDateFormat sdf = new SimpleDateFormat(pattern);  
9.     return sdf.format(date);  
10. }  
11. /** 
12.  * 将字符串类型的时间转换为Date类型 
13.  * @param str 时间字符串 
14.  * @param pattern 格式 
15.  * @return 返回Date类型 
16.  */  
17. public Date formatString(String str,String pattern){  
18.     SimpleDateFormat sdf = new SimpleDateFormat(pattern);  
19.     Date time=null;  
20.     //需要捕获ParseException异常，如不要捕获，可以直接抛出异常，或者抛出到上层  
21.     try {  
22.         time = sdf.parse(str);  
23.     } catch (ParseException e) {  
24.         e.printStackTrace();  
25.     }  
26.     return time;  
27. }  

由于需要计算时间差，例如前十分钟，前一天等等小额时间差，在这里利用将时间差转换为毫秒数，然后相加减，利用Date构造方法再转换为时间，所以就直接写了个根据时间差数值获取时间差毫秒数的方法。

[java]  view plain copy

1. /** 
2.  * 将一个表示时间段的数转换为毫秒数 
3.  * @param num 时间差数值,支持小数 
4.  * @param type 时间类型：1->秒,2->分钟,3->小时,4->天 
5.  * @return long类型时间差毫秒数，当为-1时表示参数有错 
6.  */  
7. public long formatToTimeMillis(double num, int type) {  
8.     if (num <= 0)  
9.         return 0;  
10.     switch (type) {  
11.     case SECOND:  
12.         return (long) (num * 1000);  
13.     case MINUTE:  
14.         return (long) (num * 60 * 1000);  
15.     case HOUR:  
16.         return (long) (num * 60 * 60 * 1000);  
17.     case DAY:  
18.         return (long) (num * 24 * 60 * 60  * 1000);  
19.     default:  
20.         return -1;  
21.     }  
22. }  

获取某一时间的月份和年份，一开始直接用的date.getMonth()方法和date.getYear()方法，不过还是Eclipse工具强大啊，当我写上时，一道横线提示我该方法已经过时，所以只好在换一个方法了。利用转换格式的写法写的。。。也不知道专不专业，先就这样写上了：

[java]  view plain copy

1. /** 
2.  * 只输出一个时间中的月份 
3.  * @param date 
4.  * @return 返回int数值类型 
5.  */  
6. public int getMonth(Date date){  
7.     String month=formatDate(date, "MM");//只输出时间  
8.     return Integer.parseInt(month);  
9. }  
10. /** 
11.  * 只输出一个时间中的年份 
12.  * @param date 
13.  * @return 返回数值类型 
14.  */  
15. public int getYear(Date date){  
16.     String year=formatDate(date, "yyyy");//只输出年份  
17.     return Integer.parseInt(year);  
18. }  

后来翻阅了下资料，发现Calendar类确实很强大啊，提供了很多方法和变量，可以直接使用。。。又将上面的方法改写了一下：

[java]  view plain copy

1. /** 
2.      * 只输出一个时间中的月份 
3.      * @param date 
4.      * @return 返回int数值类型 
5.      */  
6.     public int getMonth(Date date){  
7.         Calendar cal=Calendar.getInstance();//获得一个Calendar实例相当于Date date=new Date()  
8.         return cal.MONTH;  
9.     }  
10.     /** 
11.      * 只输出一个时间中的年份 
12.      * @param date 
13.      * @return 返回数值类型 
14.      */  
15.     public int getYear(Date date){  
16.         Calendar cal=Calendar.getInstance();//获得一个Calendar实例相当于Date date=new Date()  
17.         return cal.YEAR;  
18.     }  

[java]  view plain copy

1. /** 
2.      * 得到一个日期函数的格式化时间 
3.      * @param date 日期对象 
4.      * @return 
5.      */  
6.     public String getTimeByDate(Date date){  
7.          return formatDate(date, TIME_PATTERN);  
8.     }  
9.     /** 
10.      * 获取当前的时间，new Date()获取当前的日期 
11.      * @return 
12.      */  
13.     public String getNowTime(){  
14.         return formatDate(new Date(), TIME_PATTERN);  
15.     }  

获得一指定时间的前（后）X分钟（秒/小时/天）的时间，分别有输出为Date时间类型和字符串类型，其实后来考虑还有更好地方法，就是利用GregorianCalendat类来实现。

[java]  view plain copy

1. /** 
2.  * 获取某一指定时间的前一段时间 
3.  * @param num 时间差数值 
4.  * @param type 时间差类型：1->秒,2->分钟,3->小时,4->天 
5.  * @param date 参考时间 
6.  * @return 返回格式化时间字符串 
7.  */  
8. public String getPreTimeStr(double num,int type, Date date){  
9.     long nowLong=date.getTime();//将参考日期转换为毫秒时间  
10.     Date time = new Date(nowLong-formatToTimeMillis(num, type));//减去时间差毫秒数  
11.     return getTimeByDate(time);  
12. }  
13. /** 
14.  * 获取某一指定时间的前一段时间 
15.  * @param num 时间差数值 
16.  * @param type 时间差类型：1->秒,2->分钟,3->小时,4->天 
17.  * @param date 参考时间 
18.  * @return 返回Date对象 
19.  */  
20. public Date getPreTime(double num,int type, Date date){  
21.     long nowLong=date.getTime();//将参考日期转换为毫秒时间  
22.     Date time = new Date(nowLong-formatToTimeMillis(num, type));//减去时间差毫秒数  
23.     return time;  
24. }  
25. /** 
26.  * 获取某一指定时间的后一段时间 
27.  * @param num 时间差数值 
28.  * @param type 时间差类型：1->秒,2->分钟,3->小时,4->天 
29.  * @param date 参考时间 
30.  * @return 返回格式化时间字符串 
31.  */  
32. public String getNextTimeStr(double num,int type, Date date){  
33.     long nowLong=date.getTime();//将参考日期转换为毫秒时间  
34.     Date time = new Date(nowLong+formatToTimeMillis(num, type));//加上时间差毫秒数  
35.     return getTimeByDate(time);  
36. }  
37. /** 
38.  * 获取某一指定时间的后一段时间 
39.  * @param num 时间差数值 
40.  * @param type 时间差类型：1->秒,2->分钟,3->小时,4->天 
41.  * @param date 参考时间 
42.  * @return 返回Date对象 
43.  */  
44. public Date getNextTime(double num,int type, Date date){  
45.     long nowLong=date.getTime();//将参考日期转换为毫秒时间  
46.     Date time = new Date(nowLong+formatToTimeMillis(num, type));//加上时间差毫秒数  
47.     return time;  
48. }  

下面就是利用GregorianCalendar类实现的获取前几个月（或后几个月的当前时间）的方法：

[java]  view plain copy

1. /** 
2.  * 得到前几个月的现在 
3.  * 利用GregorianCalendar类的set方法来实现 
4.  * @param num 
5.  * @param date 
6.  * @return 
7.  */  
8. public Date getPreMonthTime(int num, Date date){  
9.     GregorianCalendar gregorianCal = new GregorianCalendar();  
10.     gregorianCal.set(Calendar.MONTH, gregorianCal.get(Calendar.MONTH) - num);  
11.     return gregorianCal.getTime();  
12. }  
13. /** 
14.  * 得到后几个月的现在时间 
15.  * 利用GregorianCalendar类的set方法来实现 
16.  * @param num 
17.  * @param date 
18.  * @return 
19.  */  
20. public Date getNextMonthTime(int num, Date date){  
21.     GregorianCalendar gregorianCal = new GregorianCalendar();  
22.     gregorianCal.set(Calendar.MONTH, gregorianCal.get(Calendar.MONTH) + num);  
23.     return gregorianCal.getTime();  
24. }  

从该方法中可以看到GregorianCalendar类中的set方法很好的解决了计算间隔时间差得具体时间，如果是计算前几年，前几天，等地时候只要吧set（）方法中第一个变量换成Calendar.YEAR,Calendar.DAY_OF_MONTH,Calendar.MINUTE即可。下面是是API文档里的介绍： GregorianCalendar  为每个日历字段使用以下默认值（如果该值未定义）。

字段	默认值
ERA	AD
YEAR	1970
MONTH	JANUARY
DAY_OF_MONTH	1
DAY_OF_WEEK	一个星期的第一天
WEEK_OF_MONTH	0
DAY_OF_WEEK_IN_MONTH	1
AM_PM	AM
HOUR, HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND	0