JAVA后台计算两个日期之间的工作日时间差

【代码实现】：两个日期之间的工作日时间差（精确到毫秒）

【代码特点】：

1.支持跨年。

2.获取的是精确到毫秒的时间差。

3.国家法定假日未计算在内（像阴历这种的只有通过加入LIST的方法了=。=）。

1. package com.wednesday.tools.timetools;  
2.   
3. import java.text.ParseException;  
4. import java.text.SimpleDateFormat;  
5. import java.util.Calendar;  
6. import java.util.Date;  
7.   
8. public class GetWorkDayTimeMillisecond {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         // TODO Auto-generated method stub  
15.         GetWorkDayTimeMillisecond a = new GetWorkDayTimeMillisecond();  
16.         Long b=a.getWorkdayTimeInMillis("2010-05-17 8-00-00", "2010-05-18 9-00-00", "yyyy-MM-dd HH-mm-ss");  
17.         System.out.println(b);  
18.     }  
19.     /** 
20.      * 获取两个时间之内的工作日时间（只去掉两个日期之间的周末时间，法定节假日未去掉） 
21.      * @param start -起始时间，共有3个重载方法，可以传入long型，Long型，与Date型 
22.      * @param end -结束时间，共有3个重载方法，可以传入long型，Long型，与Date型 
23.      * @return Long型时间差对象 
24.      */  
25.     public Long getWorkdayTimeInMillis(long start, long end){  
26.         //如果起始时间大于结束时间，将二者交换  
27.         if(start>end){  
28.             long temp = start;  
29.             start = end;  
30.             end = temp;  
31.         }  
32.         //根据参数获取起始时间与结束时间的日历类型对象  
33.         Calendar sdate = Calendar.getInstance();  
34.         Calendar edate = Calendar.getInstance();  
35.         sdate.setTimeInMillis(start);  
36.         edate.setTimeInMillis(end);  
37.         //如果两个时间在同一周并且都不是周末日期，则直接返回时间差，增加执行效率  
38.         if(sdate.get(Calendar.YEAR)==edate.get(Calendar.YEAR)  
39.                 && sdate.get(Calendar.WEEK_OF_YEAR)==edate.get(Calendar.WEEK_OF_YEAR)  
40.                 && sdate.get(Calendar.DAY_OF_WEEK)!=1 && sdate.get(Calendar.DAY_OF_WEEK)!=7  
41.                 && edate.get(Calendar.DAY_OF_WEEK)!=1 && edate.get(Calendar.DAY_OF_WEEK)!=7){  
42.             return new Long(end-start);  
43.         }  
44.         //首先取得起始日期与结束日期的下个周一的日期  
45.         Calendar snextM = getNextMonday(sdate);  
46.         Calendar enextM = getNextMonday(edate);  
47.         //获取这两个周一之间的实际天数  
48.         int days = getDaysBetween(snextM, enextM);  
49.         //获取这两个周一之间的工作日数(两个周一之间的天数肯定能被7整除，并且工作日数量占其中的5/7)  
50.         int workdays = days/7*5;  
51.         //获取开始时间的偏移量  
52.         long scharge = 0;  
53.         if(sdate.get(Calendar.DAY_OF_WEEK)!=1 && sdate.get(Calendar.DAY_OF_WEEK)!=7){  
54.             //只有在开始时间为非周末的时候才计算偏移量  
55.             scharge += (7-sdate.get(Calendar.DAY_OF_WEEK))*24*3600000;  
56.             scharge -= sdate.get(Calendar.HOUR_OF_DAY)*3600000;  
57.             scharge -= sdate.get(Calendar.MINUTE)*60000;  
58.             scharge -= sdate.get(Calendar.SECOND)*1000;  
59.             scharge -= sdate.get(Calendar.MILLISECOND);  
60.         }  
61.         //获取结束时间的偏移量  
62.         long echarge = 0;  
63.         if(edate.get(Calendar.DAY_OF_WEEK)!=1 && edate.get(Calendar.DAY_OF_WEEK)!=7){  
64.             //只有在结束时间为非周末的时候才计算偏移量  
65.             echarge += (7-edate.get(Calendar.DAY_OF_WEEK))*24*3600000;  
66.             echarge -= edate.get(Calendar.HOUR_OF_DAY)*3600000;  
67.             echarge -= edate.get(Calendar.MINUTE)*60000;  
68.             echarge -= edate.get(Calendar.SECOND)*1000;  
69.             echarge -= edate.get(Calendar.MILLISECOND);  
70.         }  
71.         //计算最终结果，具体为：workdays加上开始时间的时间偏移量，减去结束时间的时间偏移量  
72.         return workdays*24*3600000+scharge-echarge;  
73.     }  
74.     public Long getWorkdayTimeInMillis(Long start, Long end){  
75.         return getWorkdayTimeInMillis(start.longValue(), end.longValue());  
76.     }  
77.     public Long getWorkdayTimeInMillis(Date start, Date end){  
78.         return getWorkdayTimeInMillis(start.getTime(), end.getTime());  
79.     }  
80.     public Long getWorkdayTimeInMillis(String start, String end, String format){  
81.         SimpleDateFormat sdf = new SimpleDateFormat(format);  
82.         Date sdate;  
83.         Date edate;  
84.         try {  
85.             sdate = sdf.parse(start);  
86.             edate = sdf.parse(end);  
87.             return getWorkdayTimeInMillis(sdate, edate);  
88.         } catch (ParseException e) {  
89.             e.printStackTrace();  
90.             return new Long(0);  
91.         }  
92.     }  
93.     private Calendar getNextMonday(Calendar cal){  
94.         int addnum=9-cal.get(Calendar.DAY_OF_WEEK);  
95.         if(addnum==8)addnum=1;//周日的情况  
96.         cal.add(Calendar.DATE, addnum);  
97.         return cal;  
98.     }  
99.     /** 
100.      * 获取两个日期之间的实际天数，支持跨年 
101.      */  
102.     public int getDaysBetween(Calendar start, Calendar end){  
103.         if(start.after(end)){  
104.             Calendar swap = start;  
105.             start = end;  
106.             end = swap;  
107.         }  
108.         int days = end.get(Calendar.DAY_OF_YEAR)- start.get(Calendar.DAY_OF_YEAR);  
109.         int y2 = end.get(Calendar.YEAR);  
110.         if (start.get(Calendar.YEAR) != y2) {  
111.             start = (Calendar) start.clone();  
112.             do {  
113.                 days += start.getActualMaximum(Calendar.DAY_OF_YEAR);  
114.                 start.add(Calendar.YEAR, 1);  
115.             }while(start.get(Calendar.YEAR) != y2);  
116.         }  
117.         return days;  
118.     }  
119.   
120. }