程序员每天工作多少个小时
 
 您如何看待，程序员每天实际工作多长时间？ 大多数人会说答案是8到9个小时。 有人说他们每天工作12个小时或更长时间。 尽管这是正确的，但它并不是大多数程序员实际工作的数量，因为您不能考虑浏览网络是否正常，对吧？ 
 
 
 因此，在本文中，我将告诉您程序员每天实际工作多长时间，而通过工作，我并不是说坐在桌子上浏览互联网。 另外，我将尝试解释为什么会这样以及哪些因素会影响某人工作多长时间。 让我们开始吧。 
 
 
 程序员的工作时间 
 
 
 大多数程序员每天工作8个小时，但在这8个小时中，您需要午休，参加团队会议，然后需要在计算机上完成工作，这是编码，研究以及所有其他附带工作那。 这就是事物在完美世界中的运作方式，但是事情并不总是完美的。 让我们看一下大多数程序员的情况。 
 
 
 大多数程序员从喝咖啡和与同事交谈开始新的一天。 完成之后，根据您的办公桌所在的位置，您可能会花一些时间来浏览互联网，阅读新闻等。 然后，您可能会开始准备开发环境，而当您真正开始工作时，便有午休时间。 假设您吃完午饭后是下午1:00。 到那时，您可能会停止20分钟，然后开始实际工作。 您工作了2个小时，然后需要参加会议。 会议结束后，下午4:00。 现在，大多数人开始等待5:00 pm，以便他们可以回家。 这可能是一天中至少25％的全球开发人员的情况。 
 
 
 什么决定了程序员的工作时间 
 
 
 有很多因素决定程序员每天实际工作多长时间。 第一个因素是桌子的位置。 如果您在一家有十排办公桌的平行公司中工作，那么每个人都可以做自己在做的事情，因此，更难于不工作而只能浏览网络。 另一方面，如果您有自己的办公室，或者角落里有几张桌子，如果他们不是专门为您寻找的话，就不会有很多人看到您。 如果您处在这种情况下，要提高工作效率非常困难，因为没有多少人强迫您。 
 
 
 第二个因素是截止日期。 如果您有截止日期，那么您将需要比没有截止时间更多的工作。 有些工作有很长的截止日期，您需要满足这些要求；有些工作的截止日期要灵活一些。 
 
 
 决定您实际需要工作多长时间的最后一个因素是老板。 如果您的老板相对较新并且从一开始就没有加入公司，那么事情可能会容易一些。 另一方面，如果您的老板是公司的创始人之一或已经在公司工作了很长时间的人，那么事情就会有些困难。 
 
 
 为什么程序员每天不工作8小时 
 
 
 现在，剩下的问题是为什么程序员每天不工作8个小时？ 答案主要取决于动力。 如果您正在为您不特别喜欢的项目工作，那么您的动力就不会很高，并且您可能会花更多的时间浏览网络而不是工作。 另一方面，如果您拥有自己的公司，则每天可能要工作8个小时以上，因为您希望公司成功。 
 
 
 结论 
 
 
 总而言之，我们可以说大多数程序员实际上每天工作2至4个小时。 当然，有些功能更有效，但它们并不常见。 
 
 
 希望本文对您有所帮助。 如果您喜欢本文，请确保与您的朋友分享。 
 
 
 另外，如果您认为我有任何遗漏或有其他问题，请务必在评论中发表您的问题，或通过info@codequickie.com给我发送电子邮件，我将很乐意为您解答。 

 
 

  
翻译自: https://hackernoon.com/how-many-hours-per-day-do-programmers-actually-work-pn1u3y5z
 
 
程序员每天工作多少个小时

本文首发于微信公共号： 中产之路
 
 
 
华为、阿里、头条等公司的加班是出了名的，当然回报也给力。有个朋友去年去了某金服。配了3万股期权，35岁左右，按内部公允价200RMB/股，这部分期权值600万，四年兑现。
 
 
 
有次跟他聊天，问他在那边怎样，他说太累，同事之间氛围也不好，部门之间，同事之间相互抢活内斗，很不习惯。加班强度也大，晚上11点下班算早的。保温杯枸杞成了标配，不然一天根本撑不下来。
 
 
 
他说现在的策略是：不敢奢求升职，保住饭碗，混满4年，兑现全部期权，就谢天谢地了。哪怕不被裁，为了多活几天，4年之后自己也要撤。
 
 
 
前几天水木上有个帖子，如下：
 
 
 

 发信人: kanji0430 (子持年华), 信区: WorkLife 
 
 标 题: 蚂蚁金服和今日头条 
 
 发信站: 水木社区 (Tue Dec 18 10:00:32 2018), 站内 
 

 
 30+，有必要从蚂蚁金服去今日头条么？ 
 
 蚂蚁太累了，今日头条应该不会更累。但是去了蚂蚁的期权就拿不全，只能卖给公司。头条据说周末也要上班。而且头条路程单程要1小时，蚂蚁单程30分钟内。好处就是可能压力小一点，钱多一点。
 
 
 

 发信人: kanji0430 (子持年华), 信区: WorkLife 
 
 标 题: Re: 蚂蚁金服和今日头条 
 
 发信站: 水木社区 (Tue Dec 18 10:19:23 2018), 站内 
 

 
 主要是蚂蚁加班太厉害了，早上8，9点干到凌晨1点普遍情况。 
 
 【 在 xiaoweiwang 的大作中提到: 】 
 
 : 你去今日头条是为了钱，还是为了实现自我价值？ 
 
 : 如果为了钱就算了。真没必要。
 
 
 

 发信人: kanji0430 (子持年华), 信区: WorkLife 
 
 标 题: Re: 蚂蚁金服和今日头条 
 
 发信站: 水木社区 (Tue Dec 18 10:56:18 2018), 站内 
 

 
 9,1,周末在家加班。 
 
 【 在 touchsoul219 的大作中提到: 】 
 
 : 蚂蚁据说996，是真的吗
 
 
 
总结一下：发帖人30多岁，在蚂蚁金服上班，早上9点上班，晚上1点下班，工作日上班时长16小时（包括午饭、午休、晚餐时间），周末还要在家里加班。他提到期权，应该是个P7，一年期权差不多150万。
 
 
 
同样是P7，期权数量差别很大。去年入职的P7，最高可以给到3万股，今年年初是2万股左右，现在社招的P7，不到9000股。从金钱回报的角度看，同样是P7，对加班的忍受程度很定是不一样的。
 
 
 
社招P7以下级别，没有期权，加班强度和手握期权的P7一样，从这个角度看，蚂蚁真不是个好出去。
 
 
 
 
 
 
现在大多数企业经营成本高昂，盈利困难，小厂关门大吉，大厂裁员。一般来说，不到万不得已，大厂不会轻易裁员。裁员毕竟会上新闻，对企业商誉造成伤害，所以有些企业会变着法子裁员。
 
 
 
比如说全员降薪，年终奖减半。有些人受不了主动离职，省了赔偿又实现了减员，完美。这么一来可能造成逆淘汰，有能力的走了，混子老白兔留下来。你猜老板会不会跟业务骨干提前打好招呼？
 
 
 
还有一种是疯狂加班，目的可能并不是降成本，而是洗掉老白兔。比如某金服，新老板上位，push团队疯狂加班，晚上11点下班改到1点下班，加班一方面能出业绩，另一方面洗掉不能加班的老白兔，招新人，实现团队的新陈代谢，一举两得。
 
 
 
对于刚上班的年轻人，适当的加班是有好处的，但一定注意休息，身体是革命的本钱吗，来日方长。大疆25岁猝死，入职半年的应届硕士就是一个警醒。
 
 
 
上了年纪的老员工，一是有了家庭牵绊，时间上不再像年轻人富裕。二是高强度的加班，身体真的扛不过来。最后，多年积累也有了一些其他选择，主动或无奈，逐渐就退出了游戏。所以就有了XX公司员工平均年龄28岁，连续多年不变，永远是一家年轻的公司。
 
 
 
中国IT公司的加班风气，不是一天两天形成的，剧场效应，作为一个玩家，你改变不了，要走忍要么滚。
 
 
 
 
针对阿里的加班，我们「中产之路」群友是这么认为的。
 
 
 
 
公司不是家，不做没有回报的加班。
 
 
 
什么样的回报值得加班，就看个人情况来了。下文帖子中的小哥，京杭君认为他的加班强度是完全可以忍受的，毕竟好几千万的回报呢，如果是真的话。
 
 
 
 
 
 
 
 
 
你可能会喜欢
 
 
 
你什么都没做错，突然就活不下去了
 
 
程序员依然是这个时代，贫寒学子翻身的不二选择
 
 
程序员是一具“被操得很猛”的机器，报废年限很短
 

本文交代了一种求上班总时长的特殊的业务场景，并造了一个玩具数据 ，分别用MySQL和Hive SQL给出了其计算逻辑。
 
 
一、业务背景及口径说明
 
指标 上班总时长 = SUM(下班时间-上班时间) ，但在特殊的业务场景下并没有那么容易得到，如：
 
某员工一天的操作为：1→1→1→2→2（上班打卡为1，下班打卡为2）。
因为可以重复打卡，该员工打完卡后不确定是否打卡成功，又进行多次操作。
 
此时，定义指标 上班总时长 口径：
 
 
 
员工每天第一次的上班打卡时间为上班时间，第一次下班打卡时间为下班时间（即 1→1→1→2→2 取加粗的情况）；
上班总时长 = SUM(下班时间-上班时间)。
 
 
对于这个口径，该怎么写sql的计算逻辑呢？
 
 
二、计算逻辑
 
2.1 MySQL
 
 
 
MySQL 8.0之前的版本不支持窗口函数，此处不使用窗口函数。
 
 
在此，先造一个玩具数据用于说明：
 
-- 直接粘贴进查询语句里执行即可，会创建一个test数据库及test数据库里的work_time1表
-- create test database
create database if not exists test character set utf8;
-- DDL
drop table if exists test.work_time1;
create table test.work_time1 (
    id int not null auto_increment comment '主键，表示记录数'
  , user_id int not null comment '用户编号'
  , user_type int not null comment '用户类型：1表示上班，2表示下班'
  , create_time datetime not null comment '创建时间'
  , primary key(id)
) engine=innodb default charset=utf8
;
-- insert data
insert into test.work_time1(
    user_id
  , user_type
  , create_time
)
values(101, 1, '2020-01-05 09:00:00')
    , (101, 1, '2020-01-05 09:05:30')
    , (102, 1, '2020-01-05 09:15:02')
    , (101, 2, '2020-01-05 18:06:31')
    , (102, 2, '2020-01-05 18:30:31')
    , (102, 2, '2020-01-05 18:31:21')
    , (101, 1, '2020-01-06 08:45:22')
    , (101, 2, '2020-01-06 18:07:28')
    , (101, 1, '2020-01-07 09:30:02')
    , (101, 2, '2020-01-07 18:10:30')
    , (101, 2, '2020-01-07 18:15:21')
;
 
表的结果如下所示：
 
id
user_id
user_type
create_time
1
101
1
2020-01-05 09:00:00
2
101
1
2020-01-05 09:05:30
3
102
1
2020-01-05 09:15:02
4
101
2
2020-01-05 18:06:31
5
102
2
2020-01-05 18:30:31
6
102
2
2020-01-05 18:31:21
7
101
1
2020-01-06 08:45:22
8
101
2
2020-01-06 18:07:28
9
101
1
2020-01-07 09:30:02
10
101
2
2020-01-07 18:10:30
11
101
2
2020-01-07 18:15:21
其中：
 
id: 主键，仅表示记录数；
user_id: 员工id；
user_type: 员工操作类型，1表示上班，2表示下班；
create_time: 创建时间。
 
由此可知，上班时间的计算逻辑（if user_type = 1 then create_time），下班时间的计算逻辑（if user_type = 2 then create_time）。
 因为数据较少，可以先手工计算，最后与sql输出的结果做对比。只保留每天第一次的上下班记录的话，最后保留的记录只有1、3、4、5、7、8、9、10这10条记录。
 
-- 员工101的上班总时长：27.1514小时
select ((unix_timestamp('2020-01-05 18:06:31') - unix_timestamp('2020-01-05 09:00:00'))
	+ (unix_timestamp('2020-01-06 18:07:28') - unix_timestamp('2020-01-06 08:45:22'))
	+ (unix_timestamp('2020-01-07 18:10:30') - unix_timestamp('2020-01-07 09:30:02'))) / 3600
-- 员工102的上班总时长：9.2581小时
select (unix_timestamp('2020-01-05 18:30:31') - unix_timestamp('2020-01-05 09:15:02')) / 3600
 
如上所示，手工计算最后员工101的上班总时长为27.1514小时，员工102的上班总时长为9.2581小时。
 接下来用MySQL写计算逻辑：
 
step 1: 数据清洗，仅保留需要的记录
 可以将该问题理解为求组内 TopN 问题，在这个场景下就是求每个员工在每天每个打卡行为（上班或下班）时的最早的时间：
 思路1：
 因为是 Top1 问题，只要满足在组（user_id, date(create_time), user_type）中，create_time取最小值即可。
 
select id
	, user_id
	, user_type
	, create_time
from test.work_time1
where (user_id, date(create_time), user_type, create_time) in
    (
	  select user_id, date(create_time), user_type, min(create_time)
	  from test.work_time1
	  group by user_id, date(create_time), user_type
	)
;
 
思路2：
 可以将组内最早的时间理解为：组内比该时间还早的时间数 < 1。
 
select id 
	, a.user_id
	, a.user_type
	, a.create_time
from test.work_time1 a
where 1 > (select count(*)
					 from test.work_time1 b
					 where b.user_id = a.user_id
							 and date(b.create_time) = date(a.create_time)
							 and b.user_type = a.user_type
							 and b.create_time < a.create_time)
;
 
思路1和2得到的结果都是下图所示结果，与肉眼判断的id记录一致。
 
 现在得到的数据就很干净啦，每个员工每天就只有两条记录，即分别是上班打卡和下班打卡。
 step 2: 计算总时长
 只需要分别计算每个员工每天的上班时长，然后加起来即可。
 但是sql里的字段计算操作都是对于行的，怎么把每个员工每天的下班时间与上班时间合并到一行里呢？
 这里用一个关联，将step 1的sql结果分别作为临时表t1和t2关联起来，关联条件是同一个员工、同一天、t2.user_type - t1.user_type = 1（2-1=1)
 
 
 
Q：有没有更简单的通过step 1来得到每个员工的上班总时长的方法呢？
备注：
 
 
这里用了step 1中的思路2的计算逻辑，因为它效率略微高一些；
setp 1里可以将t1作为员工的上班时间表与t2作为下班时间表，再在step 2关联起来，更直观。
 
 
-- 计算每个员工的上班总时长
select t1.user_id
	, sum(unix_timestamp(t2.create_time) - unix_timestamp(t1.create_time)) / 3600 work_time
from 
	(
		select a.user_id
			, a.user_type
			, a.create_time
		from test.work_time1 a
		where 1 > (select count(*)
							 from test.work_time1 b
							 where b.user_id = a.user_id
									 and date(b.create_time) = date(a.create_time)
									 and b.user_type = a.user_type
									 and b.create_time < a.create_time)
	) t1
	left join 
	(
		select a.user_id
			, a.user_type
			, a.create_time
		from test.work_time1 a
		where 1 > (select count(*)
							 from test.work_time1 b
							 where b.user_id = a.user_id
									 and date(b.create_time) = date(a.create_time)
									 and b.user_type = a.user_type
									 and b.create_time < a.create_time)
	) t2 on t1.user_id = t2.user_id and date(t1.create_time) = date(t2.create_time)
				and 1 = t2.user_type - t1.user_type
where t1.user_type = 1
group by t1.user_id
;
 
得到结果如下：
 
 结果与手工计算一致，代码无误。
 
2.2 Hive SQL
 
在 hive 中使用 lag 分析窗口函数可以更高效的得到我们想要的结果。
 先造个数据，数据同上。
 
create database if not exists test comment '测试数据库';
drop table if exists test.work_time1;
create table test.work_time1 (
    user_id int comment '用户编号'
  , user_type int comment '用户类型：1表示上班，2表示下班'
  , create_time string comment '创建时间'
)
;
-- insert data
insert into test.work_time1(
    user_id
  , user_type
  , create_time
)
values(101, 1, '2020-01-05 09:00:00')
    , (101, 1, '2020-01-05 09:05:30')
    , (102, 1, '2020-01-05 09:15:02')
    , (101, 2, '2020-01-05 18:06:31')
    , (102, 2, '2020-01-05 18:30:31')
    , (102, 2, '2020-01-05 18:31:21')
    , (101, 1, '2020-01-06 08:45:22')
    , (101, 2, '2020-01-06 18:07:28')
    , (101, 1, '2020-01-07 09:30:02')
    , (101, 2, '2020-01-07 18:10:30')
    , (101, 2, '2020-01-07 18:15:21')
;


 
简要介绍一个 lag 函数，它的主要作用是将数据向后偏移：
 
lag(col, n, default) over(partition by … order by …)
 
lag中的内容：col表示字段名称，即对哪个字段使用lag函数；n表示滞后阶数；default表示滞后后没有值的位置用什么填充；
over中的内容：partition by 后接需要作为分区的字段（可多个，也可以不使用这个关键字，即所有数据为一个分区），order by 即在每个分区中排序
 
总而言之，对某个字段使用 lag 函数，按照指定分区或排序规则（可以不指定分区或排序规则），生成一个新的列。
 可以理解为，lag后字段看到的是原字段前一行中的值。
 假如一个员工在一段时间（几天）的上下班打卡操作为：12112的试想一下，我们要取的1之前是不是只有没有值（即1是该员工这几天第一个操作）或2，我们要取的2前一定是1。
 
with a as (
    select user_id
        , user_type
        , create_time
        , lag(user_type, 1, null) over(partition by user_id order by create_time) type_lag
    from xn_test.work_time1
),
b as (
    select a.user_id
        , a.user_type
        , a.create_time
        , row_number() over(partition by a.user_id order by a.create_time) rn
    from a
    where (a.user_type = 1 and (a.type_lag is null or a.type_lag = 2))
        or (a.user_type = 2 and a.type_lag = 1)
),
c as (
    select b.user_id
        , case when b.rn % 2 = 0 then b.rn - 1 else b.rn end
        , (unix_timestamp(max(b.create_time)) - unix_timestamp(min(b.create_time))) / 3600 work_time
    from b
    group by b.user_id
        , case when b.rn % 2 = 0 then b.rn - 1 else b.rn end
)
select c.user_id
    , sum(work_time) work_time
from c
;

项目组有一个需求，计算两个Date类型参数，相差的小时数。业务上有一些特殊的用途，可能用于绩效考核的目的吧…
 
如果不排除节假日周六日的话，处理起来非常easy，是个程序员都能写出来，但是…如果要排除法定节假日，排除正常周六日，同时特殊支持法定的工作日（有一些周六日，国家强制正常上班），那么处理起来就非常麻烦，我耗时大概1天半的时间，用基础的Date和Calendar实现，下面是具体的实现代码，要是有更好的实现，欢迎大家留言。
 
注意：项目组要求如果开始或者截止时间属于休息日，对应当天处理小时数为0。例如：2018-2-14 8:00:00 到2018-2-15 10:00:00，2-15是国家规定放假时间，不算时间，只算2-14号的16个小时。可以根据你们自己项目组的需求，灵活的修改哦
 
/**
	 * 判断输入的年月日日期是否属于休息日
	 * @param date  需要判断的日期（年月日）
	 * @param lawHolidayList  国家规定放假的时间
	 * @param lawWorkList  国家规定的工作日期
	 * @return
	 */
	public static boolean isDayOff(Date date,List<Date> lawHolidayList,List<Date> lawWorkList){

		for(Date date1 :lawHolidayList){
			int c = date.compareTo(date1);
			if(c==0){
				//休息日
				return true;
			}
		}

		for(Date date1 :lawWorkList){
			int c = date.compareTo(date1);
			if(c==0){
				//工作日
				return false;
			}
		}

		return isZhouLiuZhouRiDate(date);
    }


	/**
	 * 判断时间是否属于正常周六日
	 * @param date
	 * @return
	 */
	public static boolean isZhouLiuZhouRiDate(Date date){

		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int week = cal.get(Calendar.DAY_OF_WEEK) - 1;
		//是否属于周六日
		boolean flag = (week == 0 || week == 6);
		return flag;

	}

	/**
	 * 排除国家法定的休息日、正常周六日，计算两个时间相差多少小时数（休息日当天时间为零处理）
	 * @param startTimeYYYYMMDDHHMMSS  年月日时分秒
	 * @param endTimeYYYYMMDDHHMMSS  年月日时分秒
	 * @param lawHolidayList
	 * @param lawWorkList
	 * @return
	 */
	public static long workHours(Date startTimeYYYYMMDDHHMMSS,
								 Date endTimeYYYYMMDDHHMMSS,
								 List<Date> lawHolidayList,
								 List<Date> lawWorkList) throws Exception {
		//开始时间转成年月日格式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String strStartTimeYYYYMMDD = sdf.format(startTimeYYYYMMDDHHMMSS);
		Date startTimeYYYYMMDD = sdf.parse(strStartTimeYYYYMMDD);
		//开始时间是否属于休息日
		boolean startTimeIsDayOff = isDayOff(startTimeYYYYMMDD, lawHolidayList, lawWorkList);

		//结束时间转成年月日格式
		String strEndTimeYYYYMMDD = sdf.format(endTimeYYYYMMDDHHMMSS);
		Date endTimeYYYYMMDD = sdf.parse(strEndTimeYYYYMMDD);
		//结束时间是否属于休息日
		boolean endTimeIsDayOff = isDayOff(endTimeYYYYMMDD, lawHolidayList, lawWorkList);

		//分为4种情况
		if (startTimeIsDayOff) {
			if (!endTimeIsDayOff) {
				//开始时间在休息日里，结束时间不在休息日里（开始那天不计算小时数，结束那天计算小时数）
				Calendar cal = Calendar.getInstance();
				cal.setTime(startTimeYYYYMMDD);
				cal.add(Calendar.DAY_OF_MONTH, +1);
				Date validStartTimeYYYYMMDD = cal.getTime();
				Date validStartTimeYYYYMMDDTemp = validStartTimeYYYYMMDD;
				int skipDay = 0;

				//循环遍历开始时间之后的每一个日期
				while (validStartTimeYYYYMMDDTemp.compareTo(endTimeYYYYMMDDHHMMSS) != 1) {
					if (isDayOff(validStartTimeYYYYMMDDTemp, lawHolidayList, lawWorkList)) {
						skipDay += 1;
					}
					cal.add(Calendar.DAY_OF_MONTH, +1);
					validStartTimeYYYYMMDDTemp = cal.getTime();
				}

				return ((endTimeYYYYMMDDHHMMSS.getTime() - validStartTimeYYYYMMDD.getTime()) / (60 * 60 * 1000)) - skipDay * 24;
			} else {
				//开始时间在休息日里，结束时间也在休息日里（开始那天不计算小时数，结束那天也不计算小时数，看中间有多少个工作日）
					Calendar cal = Calendar.getInstance();
				cal.setTime(startTimeYYYYMMDD);
				cal.add(Calendar.DAY_OF_MONTH, +1);
				Date validStartTimeYYYYMMDD = cal.getTime();
				//工作日天数
				int workDays = 0;
				//循环遍历开始时间之后的每一个日期
				while (validStartTimeYYYYMMDD.compareTo(endTimeYYYYMMDDHHMMSS) != 1) {
					if (!isDayOff(validStartTimeYYYYMMDD, lawHolidayList, lawWorkList)) {
						workDays += 1;
					}
					cal.add(Calendar.DAY_OF_MONTH, +1);
					validStartTimeYYYYMMDD = cal.getTime();
				}
				return workDays * 24;
			}
		} else {
			if (endTimeIsDayOff) {

				int skipDay = 0;
				//开始时间不在休息日里，结束时间在休息日里
				Calendar cal = Calendar.getInstance();
				cal.setTime(startTimeYYYYMMDD);
				cal.add(Calendar.DAY_OF_MONTH, +1);
				Date validStartTimeYYYYMMDD = cal.getTime();
				while (validStartTimeYYYYMMDD.compareTo(endTimeYYYYMMDDHHMMSS) != 1) {
					if (!isDayOff(validStartTimeYYYYMMDD, lawHolidayList, lawWorkList)) {
						skipDay += 1;
					}
					cal.add(Calendar.DAY_OF_MONTH, +1);
					validStartTimeYYYYMMDD = cal.getTime();
				}

				Calendar ca = Calendar.getInstance();
				ca.setTime(startTimeYYYYMMDDHHMMSS);
				int startHour = ca.get(Calendar.HOUR_OF_DAY);
				return (24-startHour) + skipDay * 24;
			} else {
				//开始时间在不在休息日里，结束时间也不在休息日里
				int skipDay = 0;
				Calendar cal = Calendar.getInstance();
				cal.setTime(startTimeYYYYMMDD);
				cal.add(Calendar.DAY_OF_MONTH, +1);
				Date validStartTimeYYYYMMDD = cal.getTime();
				while (validStartTimeYYYYMMDD.compareTo(endTimeYYYYMMDDHHMMSS) != 1) {
					if (isDayOff(validStartTimeYYYYMMDD, lawHolidayList, lawWorkList)) {
						skipDay += 1;
					}
					cal.add(Calendar.DAY_OF_MONTH, +1);
					validStartTimeYYYYMMDD = cal.getTime();
				}
				return ((endTimeYYYYMMDDHHMMSS.getTime() - startTimeYYYYMMDDHHMMSS.getTime()) / (60 * 60 * 1000)) - skipDay * 24;
			}
		}
	}




	public static void main(String args[]) throws Exception{

		SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyy-MM-dd");
		List<Date> lawHolidayDate = new ArrayList<>();
		List<Date> lawWorkDate = new ArrayList<>();
		String [] lawHolidayDateStr =
				new String[] {
				        "2018-01-01",
						"2018-02-15",
						"2018-02-16",
						"2018-02-17",
						"2018-02-18",
						"2018-02-19",
						"2018-02-20",
						"2018-02-21",
						"2018-04-05",
						"2018-04-06",
						"2018-04-07",
						"2018-04-29",
						"2018-04-30",
						"2018-05-01",
						"2018-06-16",
						"2018-06-17",
						"2018-06-18",
						"2018-09-22",
						"2018-09-23",
						"2018-09-24",
						"2018-10-01",
						"2018-10-02",
						"2018-10-03",
						"2018-10-04",
						"2018-10-05",
						"2018-10-06",
						"2018-10-07",
						"2018-12-30",
						"2018-12-31",
						"2019-01-01",
						"2019-02-04",
						"2019-02-05",
						"2019-02-06",
						"2019-02-07",
						"2019-02-08",
						"2019-02-09",
						"2019-02-10",
						"2019-04-05",
						"2019-04-06",
						"2019-04-07",
						"2019-05-01",
						"2019-06-07",
						"2019-06-08",
						"2019-06-09",
						"2019-09-13",
						"2019-09-14",
						"2019-09-15",
						"2019-10-01",
						"2019-10-02",
						"2019-10-03",
						"2019-10-04",
						"2019-10-05",
						"2019-10-06",
						"2019-10-07"};
		String [] lawWorkDateStr =
				new String[] {
						"2018-02-11",
						"2018-02-24",
						"2018-04-08",
						"2018-04-28",
						"2018-09-29",
						"2018-09-30",
						"2018-12-29",
						"2019-02-02",
						"2019-02-03",
						"2019-09-29",
						"2019-10-12"};

		for(String str :lawHolidayDateStr){
			lawHolidayDate.add(yyyyMMdd.parse(str));
		}

		for(String str :lawWorkDateStr){
			lawWorkDate.add(yyyyMMdd.parse(str));
		}

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date startDate = sdf.parse("2018-02-22 8:45:10");
		Date endDate = sdf.parse("2018-02-24 7:10:10");


		System.out.println("相差小时数："+workHours(startDate,endDate,lawHolidayDate,lawWorkDate));
	}
 
上面的例子，需要在项目里配置两种时间，一是国家法律规定的休息的时间，二是国家规定要正常上班的时间（例如一些周六日，为了十一的一天放假，调休前一个或者后一个周六日必须上班）。上面的例子是直接写死的2018/2019年的两种时间，自己项目的话，可以配置在配置文件或者数据库中哦！