java 中计算任意2个日期之间的工作天数

java 代码

1. 对于任意2个日期比如：date_start=2006-10-1、date_end=2006-10-14 ，首先计算这连个日期之间的时间间隔（天数），然后分别对date_start 和date_end 取得它们下一个星期一的日期，这样就可以得到一个新的可以整除7的完整日期间隔（这个新的日期间隔已经把星期几的问题剔出掉了），换一种说法就是我们可以得到，这两个新的日期之间的周数，拿这个周数乘以5就是工作日期了（tmpWorkingDays）。但是这个日期并不是我们所要的日期，接下来我们要做的就是计算date_start,date_end这两个日期对于根据它们所产生的新的日期之间的时间偏移量，date_start的偏移量（date_start_change）是需要加的，而date_end的这个偏移量（date_end_change）是需要减去的。 最后我们只要用tmpWorkingDays+date_start_change-date_end_change就是我们所要求的实际工作日了。以下是所有实现代码（两个日期跨年也没有问题）。    
2.   
3.   
4. 主要思路：   
5.   
6. 对于任意2个日期比如：date_start=2006-10-1、date_end=2006-10-14 ，首先计算这连个日期之间的时间间隔（天数），然后分别对date_start 和date_end 取得它们下一个星期一的日期，这样就可以得到一个新的可以整除7的完整日期间隔（这个新的日期间隔已经把星期几的问题剔出掉了），换一种说法就是我们可以得到，这两个新的日期之间的周数，拿这个周数乘以5就是工作日期了（tmpWorkingDays）。但是这个日期并不是我们所要的日期，接下来我们要做的就是计算date_start,date_end这两个日期对于根据它们所产生的新的日期之间的时间偏移量，date_start的偏移量（date_start_change）是需要加的，而date_end的这个偏移量（date_end_change）是需要减去的。 最后我们只要用tmpWorkingDays+date_start_change-date_end_change就是我们所要求的实际工作日了。以下是所有实现代码（两个日期跨年也没有问题）。   
7.   
8. 希望我的方法能对大家有用，应为这个算法没有考虑到节假日的问题，我以后会像办法处理，呵呵，今天就到这里了。   
9.   
10. package com.date.utlit;   
11.   
12. import java.text.SimpleDateFormat;   
13. import java.util.Calendar;   
14. import java.util.Date;   
15. import java.util.GregorianCalendar;   
16. /**  
17.  * 计算任意2个日期内的工作日（没有考虑到国定假日）  
18.  * @author user  
19.  *  
20.  */  
21. public class DateCal {   
22.   
23.  /**  
24.   * @param args  
25.   */  
26.  public static void main(String[] args) {   
27.   try {   
28.   
29.    String strDateStart = "2006-10-1";   
30.    String strDateEnd = "2006-10-14";   
31.    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");   
32.    Date date_start = sdf.parse(strDateStart);   
33.    Date date_end = sdf.parse(strDateEnd);   
34.    DateCal app = new DateCal();   
35.    Calendar cal_start = Calendar.getInstance();   
36.    Calendar cal_end = Calendar.getInstance();   
37.    cal_start.setTime(date_start);   
38.    cal_end.setTime(date_end);   
39.    System.out.println("星期-->" + app.getChineseWeek(cal_start)   
40.      + " 日期-->" + cal_start.get(Calendar.YEAR) + "-"  
41.      + (cal_start.get(Calendar.MONTH) + 1) + "-"  
42.      + cal_start.get(Calendar.DAY_OF_MONTH));   
43.    System.out.println("星期-->" + app.getChineseWeek(cal_end) + " 日期-->"  
44.      + cal_end.get(Calendar.YEAR) + "-"  
45.      + (cal_end.get(Calendar.MONTH) + 1) + "-"  
46.      + cal_end.get(Calendar.DAY_OF_MONTH));   
47.    System.out.println("工作日为-->"  
48.      + app.getWorkingDay(cal_start, cal_end));   
49.    System.out.println("休息日-->"+app.getHolidays(cal_start, cal_end));   
50.   } catch (Exception e) {   
51.    // TODO: handle exception   
52.   }   
53.  }   
54.   
55.  public int getDaysBetween(java.util.Calendar d1, java.util.Calendar d2) {   
56.   if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end   
57.    java.util.Calendar swap = d1;   
58.    d1 = d2;   
59.    d2 = swap;   
60.   }   
61.   int days = d2.get(java.util.Calendar.DAY_OF_YEAR)   
62.     - d1.get(java.util.Calendar.DAY_OF_YEAR);   
63.   int y2 = d2.get(java.util.Calendar.YEAR);   
64.   if (d1.get(java.util.Calendar.YEAR) != y2) {   
65.    d1 = (java.util.Calendar) d1.clone();   
66.    do {   
67.     days += d1.getActualMaximum(java.util.Calendar.DAY_OF_YEAR);   
68.     d1.add(java.util.Calendar.YEAR, 1);   
69.    } while (d1.get(java.util.Calendar.YEAR) != y2);   
70.   }   
71.   return days;   
72.  }   
73.   
74.  /**  
75.   * 计算2个日期之间的相隔天数  
76.   * @param d1  
77.   * @param d2  
78.   * @return  
79.   */  
80.  public int getWorkingDay(java.util.Calendar d1, java.util.Calendar d2) {   
81.   int result = -1;   
82.   if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end   
83.    java.util.Calendar swap = d1;   
84.    d1 = d2;   
85.    d2 = swap;   
86.   }   
87.   
88.   int betweendays = getDaysBetween(d1, d2);   
89.   
90.      
91.   int charge_date = 0;   
92.   int charge_start_date = 0;//开始日期的日期偏移量   
93.   int charge_end_date = 0;//结束日期的日期偏移量   
94.    // 日期不在同一个日期内   
95.    int stmp;   
96.    int etmp;   
97.    stmp = 7 - d1.get(Calendar.DAY_OF_WEEK);   
98.    etmp = 7 - d2.get(Calendar.DAY_OF_WEEK);   
99.    if (stmp != 0 && stmp != 6) {// 开始日期为星期六和星期日时偏移量为0   
100.     charge_start_date = stmp - 1;   
101.    }   
102.    if (etmp != 0 && etmp != 6) {// 结束日期为星期六和星期日时偏移量为0   
103.     charge_end_date = etmp - 1;   
104.    }   
105. //  }   
106.   result = (getDaysBetween(this.getNextMonday(d1), this.getNextMonday(d2)) / 7)   
107.     * 5 + charge_start_date - charge_end_date;   
108.   //System.out.println("charge_start_date>" + charge_start_date);   
109.   //System.out.println("charge_end_date>" + charge_end_date);   
110.   //System.out.println("between day is-->" + betweendays);   
111.   return result;   
112.  }   
113.   
114.  public String getChineseWeek(Calendar date) {   
115.   final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",   
116.     "星期六" };   
117.   
118.   int dayOfWeek = date.get(Calendar.DAY_OF_WEEK);   
119.   
120.   // System.out.println(dayNames[dayOfWeek - 1]);   
121.   return dayNames[dayOfWeek - 1];   
122.   
123.  }   
124.   
125.  /**  
126.   * 获得日期的下一个星期一的日期  
127.   *   
128.   * @param date  
129.   * @return  
130.   */  
131.  public Calendar getNextMonday(Calendar date) {   
132.   Calendar result = null;   
133.   result = date;   
134.   do {   
135.    result = (Calendar) result.clone();   
136.    result.add(Calendar.DATE, 1);   
137.   } while (result.get(Calendar.DAY_OF_WEEK) != 2);   
138.   return result;   
139.  }    
140.     
141.  /**  
142.   *   
143.   * @param d1  
144.   * @param d2  
145.   * @return  
146.   */  
147.  public int getHolidays(Calendar d1,Calendar d2){   
148.   return this.getDaysBetween(d1, d2)-this.getWorkingDay(d1, d2);   
149.      
150.  }   
151.   
152. }   
153.   
154.   
155.