精华内容
下载资源
问答
  • 适合各类请假 时间计算,除去双休,计算固定工作日时间数,可以自定义上班时间 午休时间 下班时间,非常好用的时间计算
  • 计算实际上班时间

    千次阅读 2016-01-05 12:56:27
    计算实际上班时间
    package com.soft.util;
    
    import java.text.ParseException;  
    import java.text.SimpleDateFormat;  
    import java.util.Date;  
      
      
    public class CalculateHoursUtil {  
      
        static SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss"); //这里的格式可以自己设置   
      
        //设置上班时间:该处时间可以根据实际情况进行调整  
        static int abh = 8;//上午上班时间,小时  
        static  int abm = 30;//上午上班时间,分钟  
        static  int aeh = 12;//下午下班时间,小时  
        static int aem = 0;//下午下班时间,分钟  
        static int pbh = 12;//下午上班时间,小时  
        static int pbm = 00;//下午上班时间,分钟  
        static int peh = 18;//下午下班时间,小时  
        static int pem = 30;//下午下班时间,分钟  
      
        static  float h1 = abh+(float)abm/60;  
        static  float h2 = aeh+(float)aem/60;  
        static    float h3 = pbh+(float)pbm/60;  
        static float h4 = peh+(float)pem/60;  
      
        static  float hoursPerDay = h2-h1+h4-h3;//每天上班小时数  
      
        static  int daysPerWeek = 5;//每周工作天数  
        static  long milsecPerDay = 1000*60*60*24;//每天的毫秒数  
        static float hoursPerWeek = hoursPerDay*daysPerWeek;//每星期小时数  
      
        public static Float calculateHours(String beginTime, String endTime){  
      
            System.out.println("设置的上班时间为:"+abh+":"+abm+"-"+aeh+":"+aem  
                    +"   "+pbh+":"+pbm+"-"+peh+":"+pem);  
            System.out.println("每天工作时间为:"+hoursPerDay+"小时");  
      
            //对输入的字符串形式的时间进行转换  
            Date t1 = stringToDate(beginTime);//真实开始时间  
            Date t2 = stringToDate(endTime);//真实结束时间  
      
            System.out.println("设置的开始时间为:"+printDate(t1));  
            System.out.println("设置的结束时间为:"+printDate(t2));  
      
            //对时间进行预处理  
            t1 = processBeginTime(t1);  
            t2 = processEndTime(t2);  
              
            System.out.println("预处理后的开始时间为:"+printDate(t1));  
            System.out.println("预处理后的结束时间为:"+printDate(t2));  
              
            //若开始时间晚于结束时间,返回0  
            if(t1.getTime()>t2.getTime()){  
                System.out.println("总工作时间为:0小时");  
                return 0f;  
            }  
              
            //开始时间到结束时间的完整星期数  
            int weekCount = (int) ((t2.getTime()-t1.getTime())/(milsecPerDay*7));  
            System.out.println("时间间隔内共包含了"+weekCount+"个完整的星期");  
              
            float totalHours = 0;  
            totalHours += weekCount * hoursPerWeek;  
      
            //调整结束时间,使开始时间和结束时间在一个星期的周期之内  
            t2.setTime(t2.getTime()-weekCount*7*milsecPerDay);  
            System.out.println("结束时间调整为:"+printDate(t2));  
              
            int dayCounts = 0;//记录开始时间和结束时间之间工作日天数  
              
            //调整开始时间,使得开始时间和结束时间在同一天,或者相邻的工作日内。  
            while(t1.getTime()<=t2.getTime()){  
                Date temp = new Date(t1.getTime()+milsecPerDay);  
                temp = processBeginTime(temp);  
                temp.setHours(t1.getHours());  
                temp.setMinutes(t1.getMinutes());  
                if(temp.getTime()>t2.getTime()){  
                    break;  
                }else{  
                    t1 = temp;  
                    dayCounts++;  
                }  
            }  
            System.out.println("开始时间向后移动了"+dayCounts+"个工作日");  
            System.out.println("开始时间调整为:"+printDate(t1));  
            totalHours += dayCounts * hoursPerDay;  
              
            float hh1 = t1.getHours() + (float)t1.getMinutes()/60;  
            float hh2 = t2.getHours() + (float)t2.getMinutes()/60;  
              
            //处理开始结束是同一天的情况  
            if(t1.getDay()==t2.getDay()){  
                float tt = 0;  
                tt = hh2 - hh1;  
                if(hh1>=h1&&hh1<=h2&&hh2>=h3){  
                    tt = tt - (h3-h2);  
                }  
                totalHours += tt;  
            }else{  
                //处理开始结束不是同一天的情况  
                float tt1 = h4 - hh1;  
                float tt2 = hh2 - h1;  
                if(hh1<=h2){  
                    tt1 = tt1 - (h3-h2);  
                }  
                if(hh2>=h3){  
                    tt2 = tt2 - (h3-h2);  
                }  
                totalHours += (tt1 + tt2);  
            }  
            System.out.println("每天工作小时:"+totalHours+"小时");  
            return totalHours;  
        }  
      
        /** 
         * 格式化输出时间: yyyy-mm-dd hh:mm:ss 星期x 
         * @param t 
         * @return 
         */  
        private static String printDate(Date t) {  
            String str;  
            String xingqi = null;  
            switch (t.getDay()) {  
            case 0:  
                xingqi = "星期天";  
                break;  
            case 1:  
                xingqi = "星期一";  
                break;  
            case 2:  
                xingqi = "星期二";  
                break;  
            case 3:  
                xingqi = "星期三";  
                break;  
            case 4:  
                xingqi = "星期四";  
                break;  
            case 5:  
                xingqi = "星期五";  
                break;  
            case 6:  
                xingqi = "星期六";  
                break;  
            default:  
                break;  
            }  
            str = format.format(t)+"  "+xingqi;  
            return str;  
        }  
      
        /** 
         * 对结束时间进行预处理,使其处于工作日内的工作时间段内 
         * @param t 
         * @return 
         */  
        private static Date processEndTime(Date t) {  
      
            float h = t.getHours() + (float)t.getMinutes()/60;  
      
            //若结束时间晚于下午下班时间,将其设置为下午下班时间  
            if(h>=h4){  
                t.setHours(peh);  
                t.setMinutes(pem);  
            }else {  
                //若结束时间介于中午休息时间,那么设置为上午下班时间  
                if(h>=h2&&h<=h3){  
                    t.setHours(aeh);  
                    t.setMinutes(aem);  
                }else{  
                    //若结束时间早于上午上班时间,日期向前推一天,并将时间设置为下午下班时间  
                    if(t.getHours()<=h1){  
                        t.setTime(t.getTime()-milsecPerDay);  
                        t.setHours(peh);  
                        t.setMinutes(pem);  
                    }  
                }  
            }  
      
            //若结束时间是周末,那么将结束时间向前推移到最近的工作日的下午下班时间  
            if(t.getDay()==0||t.getDay()==6){  
                t.setTime(t.getTime()-milsecPerDay*(t.getDay()==6?1:2));  
                t.setHours(peh);  
                t.setMinutes(pem);  
            }  
              
            return t;  
        }  
      
        /** 
         * 对开始时间进行预处理 
         * @param t1 
         * @return 
         */  
        private static Date processBeginTime(Date t) {  
      
            float h = t.getHours() + (float)t.getMinutes()/60;  
      
            //若开始时间晚于下午下班时间,将开始时间向后推一天  
            if(h>=h4){  
                t.setTime(t.getTime()+milsecPerDay);  
                t.setHours(abh);  
                t.setMinutes(abm);  
            }else {  
                //若开始时间介于中午休息时间,那么设置为下午上班时间  
                if(h>=h2&&h<=h3){  
                    t.setHours(pbh);  
                    t.setMinutes(pbm);  
                }else{  
                    //若开始时间早于上午上班时间,将hour设置为上午上班时间  
                    if(t.getHours()<=h1){  
                        t.setHours(abh);  
                        t.setMinutes(abm);  
                    }  
                }  
            }  
      
            //若开始时间是周末,那么将开始时间向后推移到最近的工作日的上午上班时间  
            if(t.getDay()==0||t.getDay()==6){  
                t.setTime(t.getTime()+milsecPerDay*(t.getDay()==6?2:1));  
                t.setHours(abh);  
                t.setMinutes(abm);  
            }  
            return t;  
        }  
      
      
        /** 
         * 将字符串形式的时间转换成Date形式的时间 
         * @param time 
         * @return 
         */  
        private static Date stringToDate(String time){  
      
            try {  
                return format.parse(time);  
            } catch (ParseException e) {  
                e.printStackTrace();  
                return null;  
            }  
        }  
        public static void main(String[] args) {  
            String beginTime = "2015-12-21 10:45:00";  
            String endTime = "2015-12-29 10:45:00";  
            CalculateHoursUtil ch = new CalculateHoursUtil();  
            ch.calculateHours(beginTime, endTime);  
        } 
    }  
    展开全文
  • 上班时间 所谓上班时间是指从上班到下班的时间里,能够被算作工时的那部分时间总和。 算法 从上班到下班之间至少有一个时间段是不算工作时间的,即中午的休息时间,一般是12:00-14:00,如果晚上有加班,则傍晚的16:00...

    上班时间

    所谓上班时间是指从上班到下班的时间里,能够被算作工时的那部分时间总和。

    算法

    从上班到下班之间至少有一个时间段是不算工作时间的,即中午的休息时间,一般是12:00-14:00,如果晚上有加班,则傍晚的16:00-19:00也不算工作时间。
    而上班时间可以从一天之中的任何时段开始,需要根据不同的上下班情况来累积上班时间。

    设定A为按起始顺序排序的、且任意两个区间没有时间交集的非工作时间段列表
    设start,end分别为上下班的时间(以分钟为单位),则计算上下班的算法如下:

    # 通过遍历跳过非工作时间进行工作时间的累加
    calculate(A,start,end):
        if end < start:
            # 如果是次日凌晨下班,则需要调整分钟时间
            end = end + 24*60
        sum = 0
        error = False
        completed = False
        for rangeTime in A:
            rangeStart,rangeEnd = rangeTime
            # validate
            if rangeEnd < rangeStart:
                error = True
                break
            if start >= rangeStart:
                if end <= rangeEnd:
                    # 没有更多有效区间
                    completed = True
                    break
                if start < rangeEnd:
                    start = rangeEnd
                continue
            if end <= rangeStart:
                sum = sum + end - start
                completed = True
                break
            sum += rangeStart - start
            start = rangeEnd
            if start >= end:
                completed = True
                break
        if not error:
            if not completed and end >= start:
                sum = sum + end - start
            return sum
       return -1
    
    展开全文
  • 上班时间应该包含交通时间     红朝儒生 2012-8-30   关键字:上班 交通 时间 简介:为了上下班而消耗的交通时间,都应该在交通时间之内。这样显得人性化,以人为本,而且实现了真正公平。      ...

    上班时间应该包含交通时间

     

     

    红朝儒生

    2012-8-30

     

    关键字:上班 交通 时间

    简介:为了上下班而消耗的交通时间,都应该算在交通时间之内。这样显得人性化,以人为本,而且实现了真正公平。

     

     

      工作紧张压力大,想必是每个人的痛苦。这工作紧张,就包括上班时间,比如说是加班。加班很痛苦,不加班就好吗?也不见得。比如说,汝在大城市(如上海)工作,家住城东,办公地点在城东,上个班两三个小时,这吓人不?一天上下班就五六个小时浪费在路上,痛苦吧。更痛苦的是,城市还在不断扩大,这种情况越来越普遍。

      怎么办呢?吾提出,为了上下班而消耗的交通时间,都应该算在交通时间之内。这样住得远也不怕,不会浪费自己的时间。因为现在人性化了嘛,以人为本嘛,而且实现了真正公平。

      

      自然的,这样也引起新问题:

      怎样计算上下班时间?这个应该不难解决。宾主双方在热情友好的气氛中协商解决。

      真正严重的问题是,公司一看汝住得这么远,就不愿意招聘了,人家资本家不能保证利润企业倒闭了怎么办?怎么办?

      洋奴曰,连洋大人霉国都没有这样的制度,说明这个制度不好。乃洋大人当年还是奴隶制度呢,还种族隔离呢。

      怎么办?吾有办法,乃有何妙计?

    展开全文
  • Python计算两日期之间排除节假日与非上班时间的工作时间前言一、基本思路二、代码示例总结 文章目录前言一、基本思路二、代码示例总结 前言 工作中遇见需要写UDF计算事项办理时间的需求,事项申请和办结由于在线上...

    Python计算两日期之间排除节假日与非上班时间的工作时间


    前言

    工作中遇见需要写UDF计算事项办理时间的需求,事项申请和办结由于在线上,可能不在办理时间内,因此要求排除节假日与工作日的非工作时间(午休时间、上班前与下班后的时间),在次做下记录。


    一、基本思路

    首先需要获取法定节假日,这里参考了另一篇从万年历爬取全年法定节假日时间的文章:
    Python获取全年法定节假日时间
    文章中已经很详细地叙述了从万年历爬取节假日日期的方法,逻辑也比较简明,有具体节假日爬取需求可以参考一下。
    代码示例:

    # -*- coding: utf-8 -*-
    import requests
    from lxml import etree
    
    def get_holiday(year):
        """Params:year 四位数年份字符串"""
        """页面解析"""
        url = 'https://wannianrili.51240.com/ajax/'
        headers = {
            'Host': 'wannianrili.51240.com',
            'Connection': 'keep-alive',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
            'Accept': '*/*',
            'Sec-Fetch-Site': 'same-origin',
            'Sec-Fetch-Mode': 'cors',
            'Sec-Fetch-Dest': 'empty',
            'Referer': 'https://wannianrili.51240.com/',
            'Accept-Encoding': 'gzip, deflate, br',
            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
        }
        list_holiday = []
        # 生成月份列表
        dateList = [year + '-' + '%02d' % i for i in range(1, 13)]
        for year_month in dateList:
            s = requests.session()
            url = 'https://wannianrili.51240.com/ajax/'
            payload = {'q': year_month}
            response = s.get(url, headers=headers, params=payload)
            element = etree.HTML(response.text)
            html = element.xpath('//div[@class="wnrl_riqi"]')
            for _element in html:
                # 获取节点属性
                item = _element.xpath('./a')[0].attrib
                if 'class' in item:
                    if item['class'] == 'wnrl_riqi_xiu' or item['class'] == 'wnrl_riqi_mo':
                        _span = _element.xpath('.//text()')
                        list_holiday.append(year_month + '-' + _span[0])
        return list_holiday
    

    然而因为这个网站时不时会崩,因此可以考虑稳妥的方式,就是使用chinesecalendar这个库,其中is_holiday方法可以判断法定节假日。
    代码示例:

    # -*- coding: utf-8 -*-
    
    from chinese_calendar import is_holiday
    from datetime import date
    
    def get_holiday(year):
        list_holiday=[]
        year=int(year)
        for month in range(1,13):
            for day in range(1,32):
                try:
                    dt=date(year,month,day)
                except:
                    break
                if is_holiday(dt):
                    list_holiday.append('{}-{:02d}-{:02d}'.format(year,month,day))
        return list_holiday
    

    在获得了节假日期后,就需要对开始时间与办结时间做对应的精准化判断,判断逻辑上略显繁琐但也比较简单,计算主要是使用datetime库中的timedelta,其实如果常用的话可以模块化一下流程中的日期处理方法,我这里写的比较糙。
    我这边的案例口径是只将工作日中08:30-12:00,14:00-18:00的时间纳入计算,时间参数的格式需要是“YYYY-MM-DD HH24:MI:SS”。

    二、代码示例

    总体代码示例:

    # -*- coding: utf-8 -*-
    
    from chinese_calendar import is_holiday
    from datetime import date
    from datetime import datetime
    from datetime import timedelta
    
    
    def get_holiday(year):
        list_holiday=[]
        year=int(year)
        for month in range(1,13):
            for day in range(1,32):
                try:
                    dt=date(year,month,day)
                except:
                    break
                if is_holiday(dt):
                    list_holiday.append('{}-{:02d}-{:02d}'.format(year,month,day))
        return list_holiday
    
    def datediff_no_holiday(start,end):
        """Params:
        start:开始时间
        end:结束时间
        'yyyy-mm-dd hh24:mi:ss'格式字符串"""
        if start>=end or not start or not end:return 0
        if start[:4]==end[:4]:
            list_holiday=get_holiday(end[:4])
        else:
            list_holiday=[]
            for year in range(int(start[:4]),int(end[:4])+1):
                list_holiday=list_holiday+get_holiday(str(year))
        list_holiday=list( map(lambda x : datetime.strptime(x,'%Y-%m-%d'), list_holiday) )
        result=0
        list_start=start.split(' ')
        start=datetime.strptime(start, '%Y-%m-%d %H:%M:%S')
        start_d=datetime.strptime(list_start[0],'%Y-%m-%d')
        list_end=end.split(' ')
        end=datetime.strptime(end, '%Y-%m-%d %H:%M:%S')
        end_d=datetime.strptime(list_end[0],'%Y-%m-%d')
        #首先判断结束时间是否在工作时间内,如果早于当天工作时间则转换为上班时间,如果大于则转换为后一天上班时间
        if list_end[1]>'18:00:00':
            end=end_d+timedelta(hours=18)
        if list_end[1]<'08:30:00':
            end=end_d+timedelta(hours=8, minutes=30)
            list_end[1]='08:30:00'
        #同理判断开始时间,如果大于则转换为后一天上班时间
        if list_start[1]>'18:00:00':
            start_d+=timedelta(days=1)
            start=start_d+timedelta(hours=8, minutes=30)
            list_start[1]='08:30:00'
        #判断是否在节假日(包括不补班的周末)中,如果是则转入下一天进行循环判断
        if start_d in list_holiday:
            while start_d in list_holiday:
                start_d+=timedelta(days=1)
            start=start_d+timedelta(hours=8, minutes=30)
            list_start[1]='08:30:00'
        if end_d in list_holiday:
            while end_d in list_holiday:
                end_d+=timedelta(days=1)
            end=end_d+timedelta(hours=8, minutes=30)
            list_end[1]='08:30:00'
        #判断开始时间,如果早于当天工作时间则转换为当天上班时间
        if list_start[1]<'08:30:00':
            start=start_d+timedelta(hours=8, minutes=30)
        #剔除12点到14点的午休时间
        if '12:00:00'<list_start[1]<'14:00:00':
            start=start_d+timedelta(hours=14)
            list_start[1]='14:00:00'
        if start>=end:return 0
        #如果开始与结束在同一日期里
        if start_d==end_d:
            result=(end-start).seconds
            if list_start[1]<='14:00:00':
                if list_end[1]>='14:00:00':
                    result-=7200
                if '12:00:00'<list_end[1]<'14:00:00':
                    result-=(end-(end_d+timedelta(hours=12))).seconds
        #如果开始与结束不在同一日期里,排除中间可能存在的节假日
        else:
            if list_start[1]<='12:00:00':
                result-=7200
            result+=(start_d+timedelta(hours=18)-start).seconds
            start_d+=timedelta(days=1) #
            while start_d<end_d:
                if start_d not in list_holiday:
                    result+=25200
                start_d+=timedelta(days=1)
            result+=(end-(end_d+timedelta(hours=8, minutes=30))).seconds
            if list_end[1]>='14:00:00':
                result-=7200
        if result<0:result=0
        return result
        """返回相差的秒数"""
    
    if __name__ == '__main__':
        start='2020-09-30 13:00:00'
        end='2020-10-09 15:00:00'
        hours=datediff_no_holiday(start,end)
        print(hours/3600,'小时')
    

    结果为 8.5 小时

    总结

    呱。

    展开全文
  • diffTime (startDate, endDate) { startDate = new Date(startDate) endDate = new Date(endDate) const diff = endDate.getTime() - startDate.getTime() const days = Math.floor(diff / (24 * 3600 * 1000)) ...
  • 现在有一个计算用户连续上班天数的报表,发现通过用row_number分析函数可以完美计算这个问题。这个SQL可以解决计算用户连续登陆、签到、上班、旷工等问题。首先将row_number按照日期排序将日期的日,比如2016-7-1,...
  • 记录上班打卡的时间

    万次阅读 2018-10-30 16:24:30
    1.问题转化成记录电脑开机的时间上班打卡和电脑开机时间基本上差不多,按照电脑开机时间算上班的时长肯定是够的 2.查电脑开机日志,开关机eventId为6005,6006,发现和期待的不一致(即和上班打卡的时间差别较大...
  • sql server上班时间计算

    千次阅读 2011-06-16 16:31:00
    --如果是下午,则下午上班时间与@dt2之差,并加上上午的195分钟 else --如果不是第一天和最后一天,则405分钟  select datediff(minute,'2011-06-10 8:30','2011-06-10 11:45')+ datediff(minute,'2011-06-10 14:...
  • 计算上班日期

    2015-05-04 13:53:55
    计算日期时间,可以显示不同颜色,方便上班和换班的计算
  • 上班时长计算

    2019-06-13 09:48:36
    封装了常用的计算上班时长的方法
  • # 查询时间段内的工作时间函数(剔除周末与非工作时间) # 参数解释 # _st: 开始时间 # _ed: 结束时间 # _hour1: 工作时间开始小时 # _hour2: 工作时间结束小时 # _minute1: 工作时间开始分钟 # _minute2: 工作时间...
  • 计划在新版来电通来电弹屏软件中用C#实现下班时间或周末休息时间自动接听并播放音频信息给来电者,比如:感谢致电xx公司,现在是休息时间,有事请在上班时间联系,谢谢! 以下是参考的思路代码: private string _...
  • 指标 上班总时长 = SUM(下班时间-上班时间) ,但在特殊的业务场景下并没有那么容易得到,如: 某员工一天的操作为:1→1→1→2→2(上班打卡为1,下班打卡为2)。 因为可以重复打卡,该员工打完卡后不确定是否打卡...
  • 上班时间刷leetcode 简介 Here are my algorithm notes. 这里是我的算法笔记。 本人定位后端开发攻城狮,主要使用 PHP 语言进行开发,但是刷题用 Java 语言,一方面由于 PHP 自身的数据结构限制,另一方面则是 Java ...
  • 上班时间刷leetcode data-structure-algorithms 非计算机科班出身,平常接触Python比较多,一直没意识到数据结构的重要性。找实习时意识到这个问题,初步看了一些入门的算法书 《算法神探》、《图解算法》、《啊哈!...
  • NULL 博文链接:https://vipbooks.iteye.com/blog/1694976
  • SQL判断上班时间,具体到分钟

    千次阅读 2018-06-06 10:11:38
    -- 获取某公司(或项目)的一个时间段内的休息日天数(暂用在SP3_SystemJumpCheckTach及CTCheckContentView.GetCheckOption中) ALTER FUNCTION [dbo].[F3_GetHolidays] ( @WCCID VARCHAR(50), -- 公司或项目ID @...
  • 截止30号早,各大互联网公司最新上班时间汇总

    万次阅读 多人点赞 2020-01-30 12:02:00
    :本地 3 号上班,外地返回北京后自行隔离 14 天后上班 三、以下公司正常上班(ಥ_ಥ) 华为、爱奇艺、小米、贝壳找房、平安、好未来、搜狐 :2.3 正常上班(你怎么看?) 58 同城 :2.10 上班,不过 2.3 - ...
  • 自动去除节假日中午休息时间和下午下班后上午上班前的时间。绝对物有所值,并且已经经过验证正在使用。赚点辛苦豆子想买自己需要的资源。后面计划更新函数可以根据值班表自动把晚上加班的或者休息日加班的时间...
  • 用户提一个申请单,提单时间...现在的问题是:计算这个完成时间要除去上班和周末的时间,只计算管理员上班的时间(上班时间:9:30-12:30&&14:00-18:30)。  举个例子:用户现在提个申请单,时间为2013-04-08 16:00:0
  • 今年这个春节真的是不太平,魔幻就像电影一般,很多人回家过年,发现无法回来上班了,很多人出去旅行,结果发现回不了家,还有的飞机落地直接被拉到宾馆隔离。大街上都没有什么人,从饭店,到电影,酒...
  • 正常上班时间为周一至周五 9:00 -12:00,13:00-18:00,实现了选择了请假起始时间与终止时间后,出请假的总小时数,此总小时数扣除了非上班时间(周末,还有一天中的非上班时间:如午休的那一个小时。...
  • 上班时间刷leetcode A-Plan——A计划 项目来源: A计划项目是我对于数据结构与算法学习过程的总结,和一些感悟和体会的分享。A来源于单词 algorithm (算法)的第一个字母,同时也是26个英文字母中第一个字母,寓意着...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,770
精华内容 23,108
关键字:

上班时间怎么计算