设计获取超时时间的方法

1.工作日为9：00-12：00及14：00-17:30(周一-周五）。
2.获取系统当前时间作为开始时间，时效可以为大于0的正整数（1-*）。
3.用java实现工作日范围内获取超过时效的时间的方法。

/**
主要思路：
1.根据系统当前日期判断开始计算的时间。
2.结合时效跟开始计算时间相差的周末数。
3.结合时效以及开始计算时间的时段获取超时的时间。
可能想的比较复杂，还有更简单的办法，只是时间比较紧，所以暂时只考虑到这种方案。暂时来说验证没有出现问题。
*/

package test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import com.sun.org.apache.xerces.internal.impl.dv.xs.DayDV;

获取超时时间 by zyh
*/
public class Test_0213 {
static String time0 = "00:00";
static String time1 = "9:00";
static String time2 = "12:00";
static String time3 = "14:00";
static String time4 = "17:30";
static String time5 = "24:00";
public static void main(String[] args) throws ParseException {
Calendar cal = Calendar.getInstance();
long hourNum = 181;
Date overTime = getOverTime(hourNum);
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
cal.setTime(overTime);
int a = cal.get(Calendar.DAY_OF_WEEK) - 1;
System.out.println("时效=1min,"+"，超时时间："+getOverTime(1));
System.out.println("时效=180min,"+"，超时时间："+getOverTime(180));
System.out.println("时效=181min,"+"，超时时间："+getOverTime(181));
System.out.println("时效=210min,"+"，超时时间："+getOverTime(210));
System.out.println("时效=390min,"+"，超时时间："+getOverTime(390));
System.out.println("时效=391min,"+"，超时时间："+getOverTime(391));
System.out.println("时效=390*2 min,"+"，超时时间："+getOverTime(390*2));
System.out.println("时效=390*3 min,"+"，超时时间："+getOverTime(390*3));
System.out.println("时效=390*4 min,"+"，超时时间："+getOverTime(390*4));
System.out.println("时效=390*5 min,"+"，超时时间："+getOverTime(390*5));
System.out.println("时效=390*6 min,"+"，超时时间："+getOverTime(390*6));
System.out.println("时效=390*5+1 min,"+"，超时时间："+getOverTime(390*5+1));
System.out.println("时效=390*5+180 min,"+"，超时时间："+getOverTime(390*5+180));
System.out.println("时效=390*5+182 min,"+"，超时时间："+getOverTime(390*5+182));
System.out.println("时效=390*13 min,"+"，超时时间："+getOverTime(390*13));
System.out.println("时效=390*15 min,"+"，超时时间："+getOverTime(390*15));
System.out.println("时效=390*20-1 min,"+"，超时时间："+getOverTime(390*20-1));
System.out.println("时效=390*20+1 min,"+"，超时时间："+getOverTime(390*20+1));
}
public static Date getOverTime(long hourNum) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
Calendar cal = Calendar.getInstance();
/*
* Date date = new Date();// 系统当前时间 cal.setTime(date);
*/
```
String date2 = "2017-02-19 18:31";
cal.setTime(sdf2.parse(date2));
```
// System.out.println("startTime="+date2+",星期"+(cal.get(Calendar.DAY_OF_WEEK) - 1));
int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1; // 判断系统当前时间是星期几
long workTime = dateDiff(time2, time1) + dateDiff(time4, time3);
// 判断开始时间
if (week_index == 6) {// 将当前时间加2天，并从上班时间开始计算。
cal.add(Calendar.DAY_OF_MONTH, 2);
cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(time1.split(":")[0]));
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MINUTE, Integer.parseInt(time1.split(":")[1]));
} else if (week_index == 0) {// 将当前时间加1天，并从上班时间开始计算。
cal.add(Calendar.DAY_OF_MONTH, 1);
cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(time1.split(":")[0]));
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MINUTE, Integer.parseInt(time1.split(":")[1]));
} else {// 判断周一-周五在哪个时段
long current_pm_end = dateDiff(sdf.format(cal.getTime()), time4);// 当前时间距离下午下班的分钟数
long current_am_start = dateDiff(sdf.format(cal.getTime()), time1);// 当前时间距离上午上班的分钟数
long current_am_end = dateDiff(sdf.format(cal.getTime()), time2);// 当前时间距离上午下班的分钟数
long current_pm_start = dateDiff(sdf.format(cal.getTime()), time3);// 当前时间距离下午上班的分钟数
```
    if (current_pm_end > 0) {// 时段在17：30-24：00
                                // 则将当前时间加*天，从第*天开始上班时间计算，第*天的获取见下方
        if (week_index == 5) {
            cal.add(Calendar.DAY_OF_MONTH, 3);// 周五
        } else {
            cal.add(Calendar.DAY_OF_MONTH, 1);// 周一-周四
        }
        cal.set(Calendar.HOUR_OF_DAY,
                Integer.parseInt(time1.split(":")[0]));
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, Integer.parseInt(time1.split(":")[1]));
    } else if (current_am_start < 0) { // 时段在00：00-9：00
        cal.set(Calendar.HOUR_OF_DAY,
                Integer.parseInt(time1.split(":")[0]));
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, Integer.parseInt(time1.split(":")[1]));
    } else if (current_am_end > 0 && current_pm_start < 0) { //时段在12:00-14:00
        cal.set(Calendar.HOUR_OF_DAY,
                Integer.parseInt(time3.split(":")[0]));
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, Integer.parseInt(time3.split(":")[1]));
    }

}
long weekend = searchWeekend(hourNum, cal.getTime(), workTime);
```
/* System.out.println("周末天数:" + weekend + ",时效:" + hourNum + "当前-下午下班:"
+ dateDiff(time4, sdf.format(sdf2.parse(date2))) + ",当前-上午下班:"
+ dateDiff(time2, sdf.format(sdf2.parse(date2))));*/
Calendar overTime = searchWorkOverTime(cal, workTime, hourNum);
overTime.add(Calendar.DAY_OF_MONTH, (int) weekend);
return overTime.getTime();
}
/**
- 根据系统当前时间、时效获取除工作日外的超时时间
- @param date
- @return
- @throws ParseException
  /
  private static Calendar searchWorkOverTime(Calendar cal, long workNum,
  long hourNum) throws ParseException {
  SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
  // 判断传入的时间在哪个时间段
  long time2_current = dateDiff(time2, sdf.format(cal.getTime()));// 当前时间距离上午下班时间的分钟数
  long time4_current = dateDiff(time4, sdf.format(cal.getTime()));// 当前时间距离下午下班时间的分钟数
  long am_min = dateDiff(time2, time1);// 上午工作日分钟数
  long noon = dateDiff(time3, time2);// 中午休息时间
  long pm_min = dateDiff(time4, time3);// 下午工作日分钟数
  long morning = dateDiff(time1, time0);// 上午非工作日分钟数
  long night = dateDiff(time5, time4);// 晚上非工作日分钟数
  if (time2_current>= 0&&time2_current<am_min) {
  /
  * 传入时间在9：01-12：00
  * 1. 当前时间大于上午上班时间:开始时间=当前时间；
  * A.是:开始时间的分钟数+中午休息分钟数+时效%工作日分钟数 B.否：开始时间的分钟数+时效%工作日分钟数
  * 3.overTime=开始时间+(时效/工作日分钟数)天+第二点得到的分钟数
  */
  long tmp2 = dateDiff(time2, sdf.format(cal.getTime()));// 当前时间与上午下班时间做对比
  long min_time = 0;
  min_time = cal.get(Calendar.MINUTE);
  if (hourNum % workNum > tmp2) {// 时效%工作日不在上午工作日时数内
  min_time += noon;// 超过上午工作日则加上中午休息时间
  if ((hourNum % workNum - tmp2) > pm_min) {
  min_time += night + morning;
  }
  }
  cal.add(Calendar.DAY_OF_MONTH, (int) (hourNum / workNum));
  min_time += hourNum % workNum;
  cal.set(Calendar.MINUTE, (int) min_time);
  }else if(time2_current==am_min){//9：00
  if(hourNum % workNum==0){
  cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(time4.split(":")[0]));
  cal.set(Calendar.MINUTE, Integer.parseInt(time4.split(":")[1]));
  cal.add(Calendar.DAY_OF_MONTH, (int)(hourNum/workNum-1));
  }else if(hourNum % workNum>am_min){
  cal.set(Calendar.MINUTE, (int)(noon+hourNum % workNum));
  cal.add(Calendar.DAY_OF_MONTH, (int)(hourNum/workNum));
  }else{
  cal.set(Calendar.MINUTE, (int)(hourNum % workNum));
  cal.add(Calendar.DAY_OF_MONTH, (int)(hourNum/workNum));
  }
  }else if (time4_current >= 0 && time2_current < 0) {
  /*
  * 传入时间在12：01-17：30
  * 1.(时效%工作日分钟)>下午上班分钟数:
  * A.是:开始时间的分钟数+时效%工作日分钟数+下班后休息分钟数+第二天上午上班前的分钟数
  * B.否：开始时间的分钟数+时效%工作日分钟数3.overTime=开始时间+(时效/工作日分钟数)天+第二点得到的分钟数
  */
  long min_time = 0;
  min_time = cal.get(Calendar.MINUTE);
  if (hourNum % workNum > time4_current) {// 时效%工作日不在下午工作日分钟数内
  min_time += morning + night;
  if ((hourNum % workNum - time4_current) > am_min) {// 超过上午工作日则加上中午休息时间
  min_time += noon;
  }
  }
  min_time += hourNum % workNum;
  cal.set(Calendar.MINUTE, (int) min_time);
  cal.add(Calendar.DAY_OF_MONTH, (int) (hourNum / workNum));
  }
  return cal;
  }
/**
- 根据时效以及系统当前时间判断周末天数
- @param hourNum
- 时效（分钟）
- @param workNum
- 每天的工作日数（分钟）
- @param am_pm
- 上午/下午 0：上午 1：下午
- @param am_end
- 上午下班时间
- @param pm_end
- 下午下班时间
- @return
- @throws ParseException
  */
  public static long searchWeekend(long hourNum, Date date, long workNum)
  throws ParseException {
  long weekDay = 0;// 周末天数
  Calendar cal = Calendar.getInstance();
  cal.setTime(date);
  SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
  int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
  if (week_index == 6 || week_index == 7) {// 周六或周日（未包括当前周的天数）
  long T = 0;// 获取总时效的天数
  if (hourNum % workNum > 0) {
  T = hourNum / workNum;
  } else {
  T = hourNum / hourNum + 1;
  }
  // 判断时效是否超过一周
  if (T > 5) {
  if (hourNum % (workNum * 5) > 0) {// 判断周数
  weekDay = hourNum / (workNum * 5);
  } else {
  weekDay = hourNum / (workNum * 5) + 1;
  }
  }// 若时效不超过一周，周末数默认为0
  } else {// 周一-周五
  long hourNum1 = 0;// 第一天的时效数
  if (dateDiff(time2, sdf.format(date)) >= 0) {// 上午
  hourNum1 = dateDiff(time2, sdf.format(date))
  + dateDiff(time4, time3);
  } else {// 下午
  hourNum1 = dateDiff(time4, sdf.format(date));
  }
  // 对比总时效数与第一天时效数的大小
  if (hourNum > hourNum1) {
  long T = 0;// 获取总时效的天数
  if ((hourNum - hourNum1) % workNum > 0) {
  T = (hourNum - hourNum1) / workNum + 1;
  } else {
  T = (hourNum - hourNum1) / workNum;
  }
  if ((5 - week_index) < T) {// 判断总时效是否超过一周
  long firstWeek = hourNum1 + (5 - week_index) * workNum;// 获取第一周时效数
  long M = hourNum - firstWeek; // 获取除第一周外的时效数
  if (M % (workNum * 5) > 0) {
  weekDay = M / (workNum * 5) + 1;
  } else {
  weekDay = M / (workNum * 5);
  }
  }// 若不超过一周，则周末数为0
  }
  }
  return weekDay * 2;
  }
/**
- 获取当天两个时间相差的分钟数
- @param endTime
- @param startTime
- @return
- @throws ParseException
  */
  public static long dateDiff(String endTime, String startTime)
  throws ParseException {
  SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
  long nm = 1000 * 60;// 一分钟的毫秒数
  long diff;
  long min = 0;
  diff = sdf.parse(endTime).getTime() - sdf.parse(startTime).getTime(); // 相差的毫秒数
  min = diff / nm;// 计算差多少分钟
  return min;
  }

}

获取系统当前时间作为开始时间，会持续进过一段时间，还是就判断当前时间是超时时间？

获取系统当前时间为开始时间，根据设置的时效，比如1小时，获取在工作日范围内与开始时间相差1小时的那个超时时间。

没怎么明白要实现什么，

获取系统当前时间，按照时间段分别对比上班正常时间，求差值，最后取和