计算2个时间范围之内的有效工作时长
原始需求：
某个员工提交xxxxx申请，需要领导审批，领导收到待办通知。
问：领导从收到审批待办开始，到执行审批操作，用了多少分钟？（有效工作时长）
类似问题：你开发某个功能，从xx开始，到xx做好发布，一共用了多少有效工作时长？
那何为有效工作时长？
答：就是按实际上班时间嘛，比如上午几点上班，几点开始午休，下午几点上班，几点下班？公司是否是双休？。。。。。之类的
参数举例：
1.每天上班时间，如：
A、不定义上班时间
B、上班时间00:00到24:00 （其实就是A）
C、上班时间09:00到17:00
D、上班时间09:00到12:00；14:00到17:00 (有午休)
E、上班时间09:00到12:00；14:00到17:00 (其实就是D)
public static List> getOnWorkTimes() {
List> onWorks = new ArrayList>(2);
// 上班时间08:30-12:00,13:00-17:30
Map work1 = new HashMap(2);
Map work2 = new HashMap(2);
work1.put("begin", "08:30:00");
work1.put("end", "12:00:00");
work2.put("begin", "13:00:00");
work2.put("end", "17:30:00");
onWorks.add(work1);
onWorks.add(work2);
return onWorks;
}
2.是否排除周末，如：
A、是
B、否
定义一个方法，大概是长这样：
看似简单，其实情况复杂：
一、同一天
1.就是同一天（这里也好多情况。。。。。。。自己领悟）
2.排除周末：周五到周六这种
3.排除周末：周六到下周一这种
二、跨天
三、多天
多天只需要取前后2天按上面的一、二处理，中间的每天都是完整小时
上代码吧：（2个java文件，main方法测试效果）
A.工具类：MyUtil.java ，实现一些通用的方法，比如必要的日期格式化等：
package com.solar.oa.card.hikvision.util;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
/**
* @ClassName: MyUtil.java
* @Description: TODO
* @date 2021年1月14日 下午9:03:31
* @author yqwang
*/
public class MyUtil {
public static String PATTERN_HH_MM_SS = "HH:mm:ss";
public static String PATTERN_DEFAULT = "yyyy-MM-dd";
public static String PATTERN_FULL = "yyyy-MM-dd HH:mm:ss";
/**
* 相差毫秒数
* "10:00:00", "10:01:00", "HH:mm:ss" -->6000
* @return end-begin
*/
public static long diffMilliseconds(String begin, String end, String pattern) {
Date b = string2Date(begin, pattern);
Date e = string2Date(end, pattern);
if(b==null || e==null){
return 0;
}
return e.getTime() - b.getTime();
}
/**日期格式化*/
public static Date formatDate(Date date, String... pattern) {
try {
if (date == null) {
return null;
}
SimpleDateFormat formatter = null;
if (pattern != null && pattern.length > 0) {
formatter = new SimpleDateFormat(pattern[0].toString());
} else {
formatter = new SimpleDateFormat(PATTERN_DEFAULT);
}
return formatter.parse(formatter.format(date));
} catch (Exception e) {
return null;
}
}
/**字符串转日期*/
public static Date string2Date(String dateStr, String... pattern) {
if (StringUtils.isEmpty(dateStr)) {
return null;
}
try {
SimpleDateFormat formatter = null;
if (pattern != null && pattern.length > 0) {
formatter = new SimpleDateFormat(pattern[0].toString());
} else {
formatter = new SimpleDateFormat(PATTERN_DEFAULT);
}
return formatter.parse(dateStr);
} catch (Exception e) {
return null;
}
}
/**日期转字符串*/
public static String date2String(Date date, String... pattern) {
if (date == null) {
return "";
}
SimpleDateFormat formatter = null;
if (pattern != null && pattern.length > 0) {
formatter = new SimpleDateFormat(pattern[0].toString());
} else {
formatter = new SimpleDateFormat(PATTERN_DEFAULT);
}
return formatter.format(date);
}
/**
* 获取2个日期之间的日期列表
* @param fromDate
* @param toDate
* @param excludeWeekend 是否排除周末
*/
public static List getBetweenDates(String fromDateStr, String toDateStr, Boolean excludeWeekend) {
List stamps = new ArrayList<>();
Date fromDate = string2Date(fromDateStr);
Date toDate = string2Date(toDateStr);
while (fromDate.getTime() <= toDate.getTime()) {
// 需要排除周末，则非周末的日期才添加到集合
if (excludeWeekend) {
if (!isWeekend(fromDate)) {
stamps.add(fromDate);
}
} else {
stamps.add(fromDate);
}
fromDate = addDays(fromDate, 1);
}
if (stamps.size() == 0){
return stamps;
}
int days = stamps.size();
Date first = stamps.get(0),last = stamps.get(days-1);
//from和days.get(0)是同一天，则集合中的第一个元素刷一下
if(first.getTime() == string2Date(fromDateStr).getTime() ){
stamps.set(0, string2Date(fromDateStr, PATTERN_FULL));
}
//to和days.get(last)是同一天，则集合中的最后一个元素刷一下
if(last.getTime() == string2Date(toDateStr).getTime() ){
stamps.set(days-1, string2Date(toDateStr, PATTERN_FULL));
}
return stamps;
}
/**
* 某个时间加几天
* @param date 某个时间基础
* @param months 加的天份数（负数为减）
* @return
*/
public static Date addDays(Date date, Integer days) {
Calendar calendar = Calendar.getInstance(); // 得到日历
calendar.setTime(date);// 把当前时间赋给日历
calendar.add(Calendar.DATE, days); // 天加减
return calendar.getTime(); // 加减后的时间
}
/**是否周末*/
public static Boolean isWeekend(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int i = cal.get(Calendar.DAY_OF_WEEK);
return i == 1 || i == 7;// 周日周六
}
/**获取某个时间之后的有效时长*/
public static long getAfterHHMMMills(List> onWorks, String hhmm){
long resMills = 0;
long tsMills = 0;
if(CollectionUtils.isEmpty(onWorks)){
tsMills = diffMilliseconds(hhmm,"24:00:00",PATTERN_HH_MM_SS);
System.out.println(String.format("[%s,24:00:00]有%s分钟",hhmm,tsMills/1000/60));
return tsMills;
}
for (Map work : onWorks) {
tsMills = 0;
// 07:20与08:30-12:00
long millTemp = diffMilliseconds(hhmm, work.get("begin"), PATTERN_HH_MM_SS);
long millTemp2 = diffMilliseconds(hhmm, work.get("end"), PATTERN_HH_MM_SS);
//1提前2未到3之间
if (millTemp > 0){
System.out.print(String.format("%s < [%s，%s]", hhmm,work.get("begin"),work.get("end")));
tsMills += diffMilliseconds(work.get("begin"), work.get("end"), PATTERN_HH_MM_SS);
}else if(millTemp2 < 0){
System.out.print(String.format("%s > [%s，%s]", hhmm,work.get("begin"),work.get("end")));
}else{
System.out.print(String.format("%s in [%s，%s]", hhmm,work.get("begin"),work.get("end")));
tsMills += millTemp2;
}
resMills += tsMills;
System.out.println(String.format("之后有%s分钟", tsMills/1000/60));
}
return resMills;
}
/**获取某个时间之前的有效时长*/
public static long getBeforeHHMMMills(List> onWorks, String hhmm){
long resMills = 0;
long tsMills = 0;
if(CollectionUtils.isEmpty(onWorks)){
tsMills = diffMilliseconds("00:00:00", hhmm, PATTERN_HH_MM_SS);
System.out.println(String.format("[00:00:00,%s]有%s分钟",hhmm,tsMills/1000/60));
return tsMills;
}
for (Map work : onWorks) {
tsMills = 0;
// 07:20与08:30-12:00
long millTemp = diffMilliseconds(hhmm, work.get("begin"), PATTERN_HH_MM_SS);
long millTemp2 = diffMilliseconds(hhmm, work.get("end"), PATTERN_HH_MM_SS);
//1提前2未到3之间
if (millTemp > 0){
System.out.print(String.format("%s < [%s，%s]", hhmm,work.get("begin"),work.get("end")));
}else if(millTemp2 < 0){
System.out.print(String.format("%s > [%s，%s]", hhmm,work.get("begin"),work.get("end")));
tsMills += diffMilliseconds(work.get("begin"), work.get("end"), PATTERN_HH_MM_SS);
}else{
System.out.print(String.format("%s in [%s，%s]", hhmm,work.get("begin"),work.get("end")));
tsMills += (-millTemp);
}
resMills += tsMills;
System.out.println(String.format("之前有%s分钟", tsMills/1000/60));
}
return resMills;
}
/**
* 毫秒数转换为日时分秒，
* @param ms
* @return
*/
public static String formatResult(long ms){
Integer ss = 1000;
Integer mi = ss * 60;
Integer hh = mi * 60;
Integer dd = hh * 24;
Long day = ms / dd;
Long hour = (ms - day * dd) / hh;
Long minute = (ms - day * dd - hour * hh) / mi;
Long second = (ms - day * dd - hour * hh - minute * mi) / ss;
Long milliSecond = ms - day * dd - hour * hh - minute * mi - second * ss;
StringBuffer sb = new StringBuffer();
if(day > 0) {
sb.append(day+"天");
}
if(hour > 0) {
sb.append(hour+"小时");
}
if(minute > 0) {
sb.append(minute+"分");
}
if(second > 0) {
sb.append(second+"秒");
}
if(milliSecond > 0) {
sb.append(milliSecond+"毫秒");
}
return sb.toString();
}
}
B.具体测试main测试：MyTest.ava，一共4个方法，实际计算就是第一个方法millsDiffExcluding(x,x,x,x)
MyTest.java的完整内容：
package com.solar.oa.card.hikvision.util;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StopWatch;
/**
* @ClassName: MyTest.java
* @Description: TODO
* @date 2021年1月14日 下午9:04:44
* @author yqwang
*/
public class MyTest extends MyUtil{//为了方便用工具，我就extends了
/**
* 获取开始时间至结束时间期间的有效工作时长(精确到毫秒)
*
* @Title:minuteDiffExcluding
* @Description: TODO
* @date 2021年1月8日 下午9:20:32
* @author yqwang
* @param from
* @param to
* @param exWeek
* 是否排除周末
* @param onWorks
* 上班时间可以定义 比如 上午 08:30 - 12:00 下午 13:00 - 17:30
* @return
*/
public static long millsDiffExcluding(String from, String to, Boolean exWeek, List> onWorks) {
long resMills = 0;// 用于最终返回（毫秒数）
// A.没有定义上班时间 且 不排除周末===>end - begin
if(CollectionUtils.isEmpty(onWorks) && !exWeek){
resMills = diffMilliseconds(from,to, PATTERN_FULL);
return resMills;
}
// B.起止时间所包含的日期（有效日期） （第一天和最后一天带有时分秒）
List dates = getBetweenDates(from, to, exWeek);
int days = dates.size();
if(days == 0){
return 0;
}
System.out.println(String.format("一共%s天", days));
System.out.println("范围内有效的时间列表：");
for (Date date : dates) {
System.out.println(date2String(date, PATTERN_FULL));
}
Date first = dates.get(0),last = dates.get(days-1);
//如果一共就1天，那就3种情况，1：from和to是同一天，2：first和from一样，3：last和to一样
// C.1天 一天时，时间需要处理一下,first和last的值 doing.............. 比如要排除 周末时，1月8号10点 到 1月10号9点 or 1月10号9点到1月11号10点。。。
if(days == 1){
System.out.println("同一天！");
if(string2Date(from).getTime() == string2Date(to).getTime()){//同一天
first = string2Date(from, PATTERN_FULL);
last = string2Date(to, PATTERN_FULL);
long s = getAfterHHMMMills(onWorks, date2String(first,PATTERN_HH_MM_SS));
System.out.println("<相减>");
long e = getAfterHHMMMills(onWorks, date2String(last,PATTERN_HH_MM_SS));
resMills+= (s-e);
}else if(first.getTime() == string2Date(from, PATTERN_FULL).getTime()){//如：周五到周六
last = null;
resMills+= getAfterHHMMMills(onWorks, date2String(first,PATTERN_HH_MM_SS));
}else{//如：周六到下周一
first = null;
resMills+= getBeforeHHMMMills(onWorks, date2String(last,PATTERN_HH_MM_SS));
}
}else{
//D.跨天(包含了2天及以上)
resMills+=getAfterHHMMMills(onWorks, date2String(first,PATTERN_HH_MM_SS));
resMills+=getBeforeHHMMMills(onWorks, date2String(last,PATTERN_HH_MM_SS));
}
// E.2天以上:(days-2)*一天的有效值
if (days > 2) {
// 每个整天的有效毫秒数
long allDayMills = 0;
if (CollectionUtils.isEmpty(onWorks)) {
allDayMills = 24*60*60*1000;
} else {
for (Map work : onWorks) {
allDayMills += diffMilliseconds(work.get("begin"), work.get("end"), PATTERN_HH_MM_SS);
}
}
resMills += (days-2)*allDayMills;
System.out.println(String.format("中间%s天，每天%s分，共%s分", days-2,allDayMills/1000/60,(days-2)*allDayMills/1000/60));
}
return resMills;
}
/** 定义上班时间 */
public static List> getOnWorkTimes() {
List> onWorks = new ArrayList>(2);
// 上班时间08:30-12:00,13:00-17:30
Map work1 = new HashMap(2);
Map work2 = new HashMap(2);
work1.put("begin", "08:30:00");
work1.put("end", "12:00:00");
work2.put("begin", "13:00:00");
work2.put("end", "17:30:00");
onWorks.add(work1);
onWorks.add(work2);
return onWorks;
}
// 有效时长计算
@Test
public void testEffTime(){
getAfterHHMMMills(null, "07:30:00");
getAfterHHMMMills(getOnWorkTimes(), "07:30:00");
getAfterHHMMMills(getOnWorkTimes(), "09:30:00");
getAfterHHMMMills(getOnWorkTimes(), "12:30:00");
getAfterHHMMMills(getOnWorkTimes(), "14:30:00");
getAfterHHMMMills(getOnWorkTimes(), "18:30:00");
getBeforeHHMMMills(null, "07:30:00");
getBeforeHHMMMills(getOnWorkTimes(), "07:30:00");
getBeforeHHMMMills(getOnWorkTimes(), "09:30:00");
getBeforeHHMMMills(getOnWorkTimes(), "12:30:00");
getBeforeHHMMMills(getOnWorkTimes(), "14:30:00");
getBeforeHHMMMills(getOnWorkTimes(), "18:30:00");
}
/*
* 获取开始时间至结束时间期间的有效工作时长(精确到分钟)
* 需求 1. 上下班时间可以定义 默认 上午 08:30 - 12:00 休息一小时 下午 13:00 - 17:30
* 2. 可根据参数判断是否排除周末
*/
public static void main(String[] args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
String from = "2021-01-15 09:02:00",to = "2021-01-18 15:22:00";
List> onWorks = new ArrayList<>();
Boolean exWeek=false;
System.out.println(String.format("========================================没有定义上班时间,不排除周末:%s,%s",from,to));
long mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
//---------------------
from = "2021-01-15 06:00:00";
to = "2021-01-15 07:00:00";
System.out.println(String.format("========================================同一天，不排除周末:%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = false;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-15 06:00:00";
to = "2021-01-15 09:00:00";
System.out.println(String.format("========================================同一天，不排除周末:%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = false;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-15 06:00:00";
to = "2021-01-15 12:30:00";
System.out.println(String.format("========================================同一天，不排除周末:%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = false;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-15 06:00:00";
to = "2021-01-15 14:30:00";
System.out.println(String.format("========================================同一天，不排除周末:%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = false;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-15 06:00:00";
to = "2021-01-15 18:30:00";
System.out.println(String.format("========================================同一天，不排除周末:%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = false;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-15 18:00:00";
to = "2021-01-15 18:30:00";
System.out.println(String.format("========================================同一天，不排除周末:%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = false;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
//---------------------
from = "2021-01-15 09:00:00";
to = "2021-01-16 15:00:00";
System.out.println(String.format("========================================周五到周六，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-16 09:00:00";
to = "2021-01-18 15:00:00";
System.out.println(String.format("========================================周六到下周一，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-16 09:00:00";
to = "2021-01-19 15:00:00";
System.out.println(String.format("========================================周六到下周二，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-14 09:00:00";
to = "2021-01-15 15:00:00";
System.out.println(String.format("========================================2天，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2021-01-15 09:00:00";
to = "2021-01-22 15:00:00";
System.out.println(String.format("========================================周五到下周五，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
from = "2020-01-15 09:00:00";
to = "2021-01-22 15:00:00";
System.out.println(String.format("========================================跨年，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
/*// 一万次跨年计算 （这里如果要测试，那就请把工具类和当前文件的System.out.print给注释掉，否则由于需要输出，会非常影响测试！！）
for(int i = 0;i<10000;i++){
from = "2020-01-15 09:00:00";
to = "2021-01-22 15:00:00";
System.out.println(String.format("========================================跨年，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
}*/
stopWatch.stop();
System.out.println(String.format("计算耗时:%s", stopWatch.getTotalTimeMillis()));
}
}
允许MyTest.java的main()方法,效果如下：
========================================没有定义上班时间,不排除周末:2021-01-15 09:02:00,2021-01-18 15:22:00
有效工作时长:3天6小时20分
有效工作时长:4700分钟
========================================同一天，不排除周末:2021-01-15 06:00:00,2021-01-15 07:00:00
一共1天
范围内有效的时间列表：
2021-01-15 07:00:00
同一天！
06:00:00 < [08:30:00，12:00:00]之后有210分钟
06:00:00 < [13:00:00，17:30:00]之后有270分钟
<相减>
07:00:00 < [08:30:00，12:00:00]之后有210分钟
07:00:00 < [13:00:00，17:30:00]之后有270分钟
有效工作时长:
有效工作时长:0分钟
========================================同一天，不排除周末:2021-01-15 06:00:00,2021-01-15 09:00:00
一共1天
范围内有效的时间列表：
2021-01-15 09:00:00
同一天！
06:00:00 < [08:30:00，12:00:00]之后有210分钟
06:00:00 < [13:00:00，17:30:00]之后有270分钟
<相减>
09:00:00 in [08:30:00，12:00:00]之后有180分钟
09:00:00 < [13:00:00，17:30:00]之后有270分钟
有效工作时长:30分
有效工作时长:30分钟
========================================同一天，不排除周末:2021-01-15 06:00:00,2021-01-15 12:30:00
一共1天
范围内有效的时间列表：
2021-01-15 12:30:00
同一天！
06:00:00 < [08:30:00，12:00:00]之后有210分钟
06:00:00 < [13:00:00，17:30:00]之后有270分钟
<相减>
12:30:00 > [08:30:00，12:00:00]之后有0分钟
12:30:00 < [13:00:00，17:30:00]之后有270分钟
有效工作时长:3小时30分
有效工作时长:210分钟
========================================同一天，不排除周末:2021-01-15 06:00:00,2021-01-15 14:30:00
一共1天
范围内有效的时间列表：
2021-01-15 14:30:00
同一天！
06:00:00 < [08:30:00，12:00:00]之后有210分钟
06:00:00 < [13:00:00，17:30:00]之后有270分钟
<相减>
14:30:00 > [08:30:00，12:00:00]之后有0分钟
14:30:00 in [13:00:00，17:30:00]之后有180分钟
有效工作时长:5小时
有效工作时长:300分钟
========================================同一天，不排除周末:2021-01-15 06:00:00,2021-01-15 18:30:00
一共1天
范围内有效的时间列表：
2021-01-15 18:30:00
同一天！
06:00:00 < [08:30:00，12:00:00]之后有210分钟
06:00:00 < [13:00:00，17:30:00]之后有270分钟
<相减>
18:30:00 > [08:30:00，12:00:00]之后有0分钟
18:30:00 > [13:00:00，17:30:00]之后有0分钟
有效工作时长:8小时
有效工作时长:480分钟
========================================同一天，不排除周末:2021-01-15 18:00:00,2021-01-15 18:30:00
一共1天
范围内有效的时间列表：
2021-01-15 18:30:00
同一天！
18:00:00 > [08:30:00，12:00:00]之后有0分钟
18:00:00 > [13:00:00，17:30:00]之后有0分钟
<相减>
18:30:00 > [08:30:00，12:00:00]之后有0分钟
18:30:00 > [13:00:00，17:30:00]之后有0分钟
有效工作时长:
有效工作时长:0分钟
========================================周五到周六，排除周末2021-01-15 09:00:00,2021-01-16 15:00:00
一共1天
范围内有效的时间列表：
2021-01-15 09:00:00
同一天！
09:00:00 in [08:30:00，12:00:00]之后有180分钟
09:00:00 < [13:00:00，17:30:00]之后有270分钟
有效工作时长:7小时30分
有效工作时长:450分钟
========================================周六到下周一，排除周末2021-01-16 09:00:00,2021-01-18 15:00:00
一共1天
范围内有效的时间列表：
2021-01-18 15:00:00
同一天！
15:00:00 > [08:30:00，12:00:00]之前有210分钟
15:00:00 in [13:00:00，17:30:00]之前有120分钟
有效工作时长:5小时30分
有效工作时长:330分钟
========================================周六到下周二，排除周末2021-01-16 09:00:00,2021-01-19 15:00:00
一共2天
范围内有效的时间列表：
2021-01-18 00:00:00
2021-01-19 15:00:00
00:00:00 < [08:30:00，12:00:00]之后有210分钟
00:00:00 < [13:00:00，17:30:00]之后有270分钟
15:00:00 > [08:30:00，12:00:00]之前有210分钟
15:00:00 in [13:00:00，17:30:00]之前有120分钟
有效工作时长:13小时30分
有效工作时长:810分钟
========================================2天，排除周末2021-01-14 09:00:00,2021-01-15 15:00:00
一共2天
范围内有效的时间列表：
2021-01-14 09:00:00
2021-01-15 15:00:00
09:00:00 in [08:30:00，12:00:00]之后有180分钟
09:00:00 < [13:00:00，17:30:00]之后有270分钟
15:00:00 > [08:30:00，12:00:00]之前有210分钟
15:00:00 in [13:00:00，17:30:00]之前有120分钟
有效工作时长:13小时
有效工作时长:780分钟
========================================周五到下周五，排除周末2021-01-15 09:00:00,2021-01-22 15:00:00
一共6天
范围内有效的时间列表：
2021-01-15 09:00:00
2021-01-18 00:00:00
2021-01-19 00:00:00
2021-01-20 00:00:00
2021-01-21 00:00:00
2021-01-22 15:00:00
09:00:00 in [08:30:00，12:00:00]之后有180分钟
09:00:00 < [13:00:00，17:30:00]之后有270分钟
15:00:00 > [08:30:00，12:00:00]之前有210分钟
15:00:00 in [13:00:00，17:30:00]之前有120分钟
中间4天，每天480分，共1920分
有效工作时长:1天21小时
有效工作时长:2700分钟
======》》》计算耗时:77ms
我已经把我能想到的情况，都测试输出了.........................
// 一万次跨年计算 （这里如果要测试，那就请把工具类和当前文件的System.out.print给注释掉，否则由于需要输出，会非常影响测试！！）
for(int i = 0;i<10000;i++){
from = "2020-01-15 09:00:00";
to = "2021-01-22 15:00:00";
System.out.println(String.format("========================================跨年，排除周末%s,%s",from,to));
onWorks = getOnWorkTimes();
exWeek = true;
mills = millsDiffExcluding(from, to, exWeek, onWorks);
System.out.println(String.format("有效工作时长:%s", formatResult(mills)));
System.out.println(String.format("有效工作时长:%s分钟", mills/1000/60));
}尽管计算10000次跨年的数据，也只需要2到3秒。
若各位看到问题，还请不吝赐教。当然如果能解决大家的问题，就最好了。