计算请假时间（不算节假日）

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量1.6k 收藏 7
点赞数 4
分类专栏： 日期 时间点间隔的日期 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012122796/article/details/123852762
版权 
//计算小时数
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Double hours= HolidayDateUtil.calculateTimeHour(format.format(leave.getStart_time()),format.format(leave.getEnd_time()),"08:00:00","11:30:00","13:00:00","17:30:00");
Double day=0.0;
//计算半天
if(leave.getStart_time().getHours()<12){
    if(hours<=3.5){
        day=0.5;
    }else if(hours>3.5&&hours<=8){
        day=1.0;
    }else{
        day=Math.ceil(hours/8);
    }
}else{
    if(hours<=4.5){
        day=0.5;
    }else if(hours>4.5&&hours<=8){
        day=1.0;
    }else{
        day=Math.ceil(hours/8);
    }
}
leave.setDays(day);
leave.setCreate_user_id(userId);
leave.setCreate_user_name(userName);
int count = leaveMapper.add(leave);
if(count < 0 ){
    return RTN.rtn501("添加数据失败！");
}

------------------------------------------------------------------------------------------------------------------------------

HolidayDateUtil 放在util里
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * 请假计算（小时）
 * 1.除去 节假日
 * 2.除去 其他规定的 非工作时间(有具体的  实行者指定)
 * 3.考虑一点 其他不上班时间 有些公司的特别
 * @author fengjing
 *
 */
public class HolidayDateUtil {

    /**
     * 节假日查询接口
     * 使用方法 url+yyyyMMdd
     */


//时间格式化
    public final static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public final static SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");

//    /**
//     * 从公认网站上获取 节假日信息
//     * @param date 获取节假日的 公认网站 url="网站地址"+时间 时间格式yyyyMMdd
//     * @param
//     * @return 工作日对应结果为 0, 休息日对应结果为 1, 节假日对应的结果为 2, 网站失效-1, 数据格式改变-2
//     */
//    public static String getHoliday(String date) {
//        ChineseCalendarUtils cc = new ChineseCalendarUtils();
//        try {
//            return cc.checkDate(date);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return null;
//    }

    /**
     * 判断某年某月有多少天
     * @param year 年  "yyyy"
     * @param moun 月 "m"
     * @return
     */
    public static int daysMonth(int year,int moun){
        switch(moun){
            case 0: return 31;
            case 1: return ((year%4==0&&year%100!=0)||year%400==0)?29:28;
            case 2: return 31;
            case 3: return 30;
            case 4: return 31;
            case 5: return 30;
            case 6: return 31;
            case 7: return 31;
            case 8: return 30;
            case 9: return 31;
            case 10: return 30;
            case 11: return 31;
            default: return 0;
        }
    }
    /**
     * 通过时间秒毫秒数判断两个时间的间隔
     * @param tiny 开始时间
     * @param large 结束时间
     * @return 返回几天
     */
    public static int differentDaysByMillisecond(Date tiny,Date large){
        if(format1.format(tiny).equals(format1.format(large))){
            return 0;
        }
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        c1.setTime(tiny);
        c2.setTime(large);
        int result = c2.get(Calendar.DAY_OF_YEAR) - c1.get(Calendar.DAY_OF_YEAR);
    /*Double why = Double.valueOf((large.getTime() - tiny.getTime()))/(1000*3600*24);
    double d = Math.ceil(why);*/
        return result;
    }

    /**
     * 通过时间秒毫秒数判断两个时间的间隔
     * @param tiny 开始时间
     * @param large 结束时间
     * @return 返回几小时
     */
    public static double differentHoursByMillisecond(Date tiny,Date large){
        double hours = ((double) ((large.getTime() - tiny.getTime())) / (1000*3600));
        return hours;
    }

    /**
     * 时间格式yyyy-MM-dd HH:mm:ss
     * @param start 请假开始时间 yyyy-MM-dd HH:mm:ss
     * @param end 请假结束时间 yyyy-MM-dd HH:mm:ss
     * @param startM 上班早晨开始时间 HH:mm:ss
     * @param endE   上班早晨结束时间 HH:mm:ss
     * @param startAf 上班下午开始时间 HH:mm:ss
     * @param endAf      上班下午结束时间 HH:mm:ss
     * @return
     */
    public static double calculateTimeHour(String start, String end, String startM, String endE, String startAf, String endAf){
        if(start!=null&&end!=null&&startM!=null&&endE!=null&&startAf!=null&&endAf!=null){//确保时间格式正确和值存在
            try {
                Date dataStart =cn.waifutong.supplyChain.util.HolidayDateUtil.format.parse(start);
                Date dataEnd = cn.waifutong.supplyChain.util.HolidayDateUtil.format.parse(end);

                double hours = 0;
                int monthDays = -1;
                int yearTime = dataStart.getYear()+1900;
                int mounthTime = dataStart.getMonth();
                int dataTime = dataStart.getDate();

                double lunchBreak;
                int interval = cn.waifutong.supplyChain.util.HolidayDateUtil.differentDaysByMillisecond(dataStart,dataEnd);

                //判断这年这月有多少天
                monthDays = HolidayDateUtil.daysMonth(yearTime,mounthTime);
                //第一天请假开始时间
                String startday = start.substring(start.lastIndexOf(" ")+1,start.length()-1);
                //最后一天请假结束时间
                String endday = end.substring(end.lastIndexOf(" ")+1,end.length()-1);
                double totalDay = 0;//累积总共请假多少天
                for(int i=0;i<=interval;i++){
                    if(interval==0){//间隔0天 也就是 请假在一天之内
//                        if(!"0".equals(HolidayDateUtil.getHoliday(yearTime+"-"+(((mounthTime+1))>=10?(mounthTime+1):"0"+(mounthTime+1))+"-"+(dataTime>10?dataTime:"0"+dataTime)))){
//                            System.out.println(""+yearTime+(((mounthTime+1))>10?(mounthTime+1):"0"+(mounthTime+1))+(dataTime>10?dataTime:"0"+dataTime)+"非工作日期不需要计算");
//                            return 0;
//                        }
                        String s = start.substring(0,10)+" "+endE;
                        String s1 = start.substring(0,10)+" "+startAf;
                        String s2 = start.substring(0,10)+" "+startM;
                        String s3 = start.substring(0,10)+" "+endAf;
                        Date dataMorning = HolidayDateUtil.format.parse(s2);
                        Date dataAfternoon = HolidayDateUtil.format.parse(s3);
                        Date dataCenter1 = HolidayDateUtil.format.parse(s);
                        Date dataCenter2 = HolidayDateUtil.format.parse(s1);
                        //开始时间在9点前 结束时间：①9点前 ②9点到12点 ③12点到1点 ④1点到6点 ⑤6点后
                        if(dataStart.compareTo(dataMorning) <= 0){
                            if(dataEnd.compareTo(dataMorning) <= 0){
                                hours = 0;
                                lunchBreak = 0;
                            }else if(dataEnd.compareTo(dataMorning) > 0 && dataEnd.compareTo(dataCenter1) <= 0){
                                hours = differentHoursByMillisecond(dataMorning,dataEnd);
                                lunchBreak = 0;
                            }else if(dataEnd.compareTo(dataCenter1) > 0 && dataEnd.compareTo(dataCenter2) <= 0){
                                hours = differentHoursByMillisecond(dataMorning,dataCenter1);
                                lunchBreak = 0;
                            }else if(dataEnd.compareTo(dataCenter2) > 0 && dataEnd.compareTo(dataAfternoon) <= 0){
                                hours = differentHoursByMillisecond(dataMorning,dataEnd);
                                lunchBreak = 1;
                            }else{
                                hours = 8;
                                lunchBreak = 0;
                            }
                        }
                        //开始时间在9点到12点 结束时间：②9点到12点 ③12点到1点 ④1点到6点 ⑤6点后
                        else if(dataStart.compareTo(dataMorning) > 0 && dataStart.compareTo(dataCenter1) <= 0){
                            if(dataEnd.compareTo(dataMorning) > 0 && dataEnd.compareTo(dataCenter1) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = 0;
                            }else if(dataEnd.compareTo(dataCenter1) > 0 && dataEnd.compareTo(dataCenter2) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = differentHoursByMillisecond(dataCenter1,dataEnd);
                            }else if(dataEnd.compareTo(dataCenter2) > 0 && dataEnd.compareTo(dataAfternoon) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = 1;
                            }else{
                                hours = differentHoursByMillisecond(dataStart,dataAfternoon);
                                lunchBreak = 1;
                            }
                        }
                        //开始时间在12点到1点 结束时间：③12点到1点 ④1点到6点 ⑤6点后
                        else if(dataStart.compareTo(dataCenter1) > 0 && (dataStart.compareTo(dataCenter2)) <= 0){
                            if(dataEnd.compareTo(dataCenter1) > 0 && dataEnd.compareTo(dataCenter2) <= 0){
                                hours = 0;
                                lunchBreak = 0;
                            }else if(dataEnd.compareTo(dataCenter2) > 0 && dataEnd.compareTo(dataAfternoon) <= 0){
                                hours = differentHoursByMillisecond(dataCenter2,dataEnd);
                                lunchBreak = 0;
                            }else{
                                hours = differentHoursByMillisecond(dataStart,dataAfternoon);
                                lunchBreak = differentHoursByMillisecond(dataStart,dataCenter2);
                            }
                        }
                        //开始时间在1点到6点 结束时间： ④1点到6点 ⑤6点后
                        else if(dataStart.compareTo(dataCenter2) >0 && dataStart.compareTo(dataAfternoon) <= 0){
                            if(dataEnd.compareTo(dataCenter2) > 0 && dataEnd.compareTo(dataAfternoon) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = 0;
                            }else{
                                hours = differentHoursByMillisecond(dataStart,dataAfternoon);
                                lunchBreak = 0;
                            }
                        }
                        //开始时间在6点后
                        else{
                            hours = 0;
                            lunchBreak = 0;
                        }


                    }else{//间隔超过一天
                        dataTime +=(i==0?0:1);
                        if(dataTime>monthDays){
                            mounthTime ++;
                            dataTime=1;
                            if(mounthTime>11){
                                yearTime++;
                                mounthTime=0;
                                dataTime=1;
                            }
                            monthDays = HolidayDateUtil.daysMonth(yearTime,mounthTime);
                        }

                        //判断是否是节假日
//                        if(!"0".equals(HolidayDateUtil.getHoliday(yearTime+"-"+(((mounthTime+1))>=10?(mounthTime+1):"0"+(mounthTime+1))+"-"+(dataTime>10?dataTime:"0"+dataTime)))){
//                            System.out.println(""+yearTime+(((mounthTime+1))>10?(mounthTime+1):"0"+(mounthTime+1))+(dataTime>10?dataTime:"0"+dataTime)+"非工作日期不需要计算");
//                            continue;
//                        }
                        String s1 = yearTime+"-"+(((mounthTime+1))>=10?(mounthTime+1):"0"+(mounthTime+1))+"-"+(dataTime>=10?dataTime:"0"+dataTime)+" "+(i==0?startday:startM);
                        String s2 = yearTime+"-"+(((mounthTime+1))>=10?(mounthTime+1):"0"+(mounthTime+1))+"-"+(dataTime>=10?dataTime:"0"+dataTime)+" "+(i==interval?endday:endAf);
                        Date dateMorning = HolidayDateUtil.format.parse(s1.substring(0,10)+" "+startM);
                        Date dateAfternoon = HolidayDateUtil.format.parse(s1.substring(0,10)+" "+endAf);
                        Date dateCenter1 = HolidayDateUtil.format.parse(s1.substring(0,10)+" "+endE);
                        Date dateCenter2 = HolidayDateUtil.format.parse(s1.substring(0,10)+" "+startAf);
                        dataStart = HolidayDateUtil.format.parse(s1);
                        dataEnd = HolidayDateUtil.format.parse(s2);
                        //第一天 dataEnd为6点 判断开始时间 ①9点前 ②9点到12点 ③12点到1点 ④ 1点到6点 ⑤ 6点之后
                        if(i == 0){
                            if(dataStart.compareTo(dateMorning) <= 0){
                                hours = 8;
                                lunchBreak = 0;
                            }else if(dataStart .compareTo(dateMorning) > 0 && dataStart.compareTo(dateCenter1) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = 1;
                            }else if(dataStart.compareTo(dateCenter1) > 0 && dataStart.compareTo(dateCenter2) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = differentHoursByMillisecond(dateCenter1,dataStart);
                            }else if(dataStart.compareTo(dateCenter2) > 0 && dataStart.compareTo(dateAfternoon) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = 0;
                            }else{
                                hours = 0;
                                lunchBreak = 0;
                            }
                            //中间天 hours 为8 lunchBreak为0
                        }else if( i != 0 && i != interval){
                            hours = 8;
                            lunchBreak = 0;
                            //最后一天 dataStart为9点 判断结束时间 ①9点前 ②9点到12点 ③12点到1点 ④ 1点到6点 ⑤ 6点之后
                        }else{
                            if(dataEnd.compareTo(dateMorning) <= 0){
                                hours = 0;
                                lunchBreak = 0;
                            }else if(dataEnd .compareTo(dateMorning) > 0 && dataEnd.compareTo(dateCenter1) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = 0;
                            }else if(dataEnd.compareTo(dateCenter1) > 0 && dataEnd.compareTo(dateCenter2) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = differentHoursByMillisecond(dateCenter1,dataEnd);
                            }else if(dataEnd.compareTo(dateCenter2) > 0 && dataEnd.compareTo(dateAfternoon) <= 0){
                                hours = differentHoursByMillisecond(dataStart,dataEnd);
                                lunchBreak = 1;
                            }else{
                                hours = 8;
                                lunchBreak = 0;
                            }
                        }
                    }
                    System.out.println(yearTime+"-"+(((mounthTime+1))>10?(mounthTime+1):"0"+(mounthTime+1))+"-"+(dataTime>10?dataTime:"0"+dataTime)+" 请假："+(hours-lunchBreak)+"小时");
                    totalDay+=hours-lunchBreak;
                }
                System.out.println(totalDay);
                return totalDay;
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 累积请假共多少天
     * @param totalDay
     * @return totalDay < 24小时按小时算   totalDay >= 24小时按天算
     */
    public String totalDay(double totalDay){
        if(totalDay > 24){
            return (totalDay/24) + "天";
        }else{
            return totalDay + "小时";
        }
    }

    public static void main(String args[]) throws IOException{
        HolidayDateUtil qj= new HolidayDateUtil();
        //测试
//        qj.calculateTimeHour("2019-10-01 09:00:00","2019-10-03 12:00:00","08:00:00","11:30:00","13:00:00","17:30:00");
//       qj.calculateTimeHour("2019-10-01 07:30:00","2019-10-01 22:00:00","00:00:00","08:00:00","17:30:00","24:00:00");

    }
}

捕捉一只Java小菜菜
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP 根据时间区间计算请假时长
02-23
根据两个时间戳,计算相差分钟,再加上天数. 跨天主要计算第一天开始时间和最后一天的时间 加上日期相差的天数
请假时间计算方式java_求一计算请假时间的算法。
weixin_35869861的博客
02-24 896
protectedvoidbtnCount_Click(objectsender, EventArgs e){try{intTotalCount=0;DateTime dtStart=Convert.ToDateTime(tbStartDateTime.Text);DateTime dtEnd=Convert.ToDateTime(tbEndDateTime.Text);intFirstCount...
一、前端开发-JS请假时间计算
qq_42522404的博客
09-06 374
计算请假时间还是蛮考虑逻辑的，可以借鉴借鉴我的，有啥需要改进的记得留言。
【入门】请假时间计算 C++题解
shen132033的博客
02-06 173
假设小明的妈妈向公司请了 n 天的假，那么请问小明的妈妈总共请了多少小时的假，多少分钟的假？（提示： 1 天有 24 小时， 1 小时有 60 分钟）两个整数，每行 1 个，第 1 行的整数代表小明妈妈请假的小时数，第 2 行的整数代表小明妈妈请假的分钟数。一个整数 n ，代表小明妈妈请假的天数。
JS计算请假时间（起始时间与终止时间）
饼干的博客
02-21 5644
正常上班时间为周一至周五9:00 -12：00，13：00-18：00，实现了选择了请假起始时间与终止时间后，算出请假的总小时数，此总小时数扣除了非上班时间（周末，还有一天中的非上班时间：如午休的那一个小时。暂不能实现跨月请假，节假日请假）。 根据网上代码改动实现（希望共同探讨） 代码贴下，未实现的后续更新 //计算两段时间工作日工时 function calculate() { ...
java后台 计算请假时间（判断了周六周末和法定节假日和国家调休）
yangniceyangyang的博客
12-11 4291
目录 1.假设上班时间如下： 2.请假时间计算方式： 3.请假可能存在的情况： 4.实现思路： 5.代码奉上，只需传入时间参数 1.假设上班时间如下： 上班时间为：08:30:00 中午休息时间为：12:00:00 到13:30:00 下班时间：18:00:00 每次请假必须至少请假半天（例如：08:30到12:00算0.5天 12:00到18:00算0....
关于请假申请的时间计算
weixin_43844392的博客
12-19 3123
最近在优化一个办公系统，需要计算请假时间 首先要实现请假时间的计算，需要以下几步 第一步、首先我们要知道时间表（我们以最常用的 上午上班时间（09：00 - 12：00）下午（13：00 - 18：00）为例） 第二步，我们分析可能出现的可能性 1、早上请假 2、下午请假 3、跨中午请假 4、跨天但又不满一天请假 5、跨天满一天请假 6、跨周请假（需要除去周末） 7、节假日请假...
Javascript 计算请假天数
weixin_30532759的博客
01-10 514
转载请注明本文地址：https://www.cnblogs.com/qiaoge0923/p/10219155.html 计算请假天数，笼统来说就是计算两个日期的差值。对于JS来说，两个时间直接相减，得到的是这两个时间差的毫秒数。 先上代码后贴图。 1.测试数据 后文中用到的测试数据如下： var dateStart = '2018-12-01 04:15', ...
js-根据时间段算出请假时长
weixin_44037153的博客
02-18 858
/** * 计算请假时长 * @param {Object} beginTime 开始时间 * @param {Object} endTime 结束时间 * @param {Object} stWorkTime 上班时间 * @param {Object} enWrokTime 下班时间 * @param {Object} isFreeTime 是否要去除午休工作时长 * @param {Object} freeTimeMon 午休开始时间 * @param {O
java 计算请假天数，去掉节假日
kingkang
10-16 2239
计算请假天数，去掉节假日的 前端 function countDays() { //外出开始日期 var startDate = new Date(DSF.getElementValueByKey("C-OUTMANAGE-0001").replace(/\-/g, "/")); //外出开始日期 var endDate = new Date(DSF.getElementValueByKey("C-OUTMANAGE-0002").replace(/\-/g, "/"));
java 请假天数计算工具类
03-27
分享之前做的一个oa请假天数计算工具类，有点伤脑筋，弄了好久，可以根据公司实际要求修改。
适合各类请假 时间计算，除去双休，计算固定工作日时间数，可以自定义上班时间 午休时间 下班时间，非常好用的时间计算。
04-04
适合各类请假 时间计算，除去双休，计算固定工作日时间数，可以自定义上班时间 午休时间 下班时间，非常好用的时间计算。
JS 请假计算按小时
12-08
选好请假日期和时间后。输出长时间。 var date=new Date(); var dat=document.all.item('a1').value; var a2=document.all.item('a2').value; var year="",y="",y2="",month="",m="",m2="",day="",d="",d2="",hour=...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 345
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 422
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1445
c++中string的模拟实现，面试必会知识点
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 550
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 614
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
请假开始时间、请假结束时间算出天数，节假日不算
06-10
在计算请假天数时，需要排除掉节假日，可以按照以下步骤进行计算： 1. 将请假开始时间和结束时间转换为时间戳（即秒数）； 2. 根据时间戳计算出请假天数，即（结束时间的时间戳 - 开始时间的时间戳）/ (24 * 60 * ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值