某时间段生成自然周、月、季度或固定周、月、季度（初级写法，个人笔记）

最新推荐文章于 2024-06-16 11:53:17 发布
最新推荐文章于 2024-06-16 11:53:17 发布
阅读量970 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JAVA_Hunger/article/details/109225932
版权
这段代码展示了如何在Java中计算两个日期之间的自然周、月和季度，以及如何按固定周期（周、月、季度）进行时间划分。主要方法包括`naturalPeriod`用于获取自然周期，`period`、`month`和`quarter`分别处理自然周、月和季度的计算，而`fixationPeriod`则用于计算固定周期的时间段。
摘要由CSDN通过智能技术生成

1、自然周、月、季度

1.1、调用自然周 、月、季度 方法
import java.text.SimpleDateFormat;
import java.util.*;
/**
  * 自然周期
  * @param start_time
  * @param end_time
  * @param period  周期  1：周  2：月  3：季度
  * @return
  */
 private Map<String,Object> naturalPeriod(Date start_time,Date end_time,String period){
     SimpleDateFormat sdf_s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     //开始时间从零点开始
     long start_m = 0;
     long end_m = 0;
     try {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         start_m = sdf_s.parse(sdf.format(start_time)+" 00:00:00").getTime();
         //结束时间到23:59:59
         end_m = sdf_s.parse(sdf.format(end_time)+" 00:00:00").getTime();
     } catch (ParseException e) {
         logger.error("时间转换异常=={}",e.getMessage());
         start_m = new Date().getTime();
         end_m = new Date().getTime();
     }
     Map<String,Object> result = new HashMap<String, Object>();
     //开始时间小于结束时间
     if(end_m - start_m < 0){
         result.put("state",false);
         return result;
     }
     List<Map<String,Date>> list = new ArrayList<Map<String, Date>>();
     if("1".equals(period)){
         //自然周
         list.addAll(this.period(start_m, end_m));

     }else if("2".equals(period)){
         //自然月
         list.addAll(this.month(start_m, end_m));
     }else if("3".equals(period)){
         //自然季度
         list.addAll(this.quarter(start_m, end_m));
     }
     result.put("state",true);
     result.put("date",list);
     return result;
 }
1.2、自然周
import java.text.SimpleDateFormat;
import java.util.*;
/**
 * 两时间段的自然周  开始时间与结束时间均从零点开始
 * @param start_m
 * @param end_m
 * @return
 */
private List<Map<String,Date>> period(long start_m,long end_m){
    List<Map<String,Date>> list = new ArrayList<Map<String, Date>>();
    Date start_date = new Date();
    Date end_date = new Date();
    //开始时间与结束时间相同
    if(end_m == start_m){
        Map<String,Date> w_map = new HashMap<String, Date>();
        start_date = new Date();
        end_date = new Date();
        start_date.setTime(start_m);
        w_map.put("start_time",start_date);
        end_date.setTime(end_m);
        w_map.put("end_time",end_date);
        list.add(w_map);
        return list;
    }


    long one_day = 24*60*60*1000;

    //获取开始时间的结束周
    Calendar start = Calendar.getInstance(); // 获得一个日历
    start.setTimeInMillis(start_m);
    int start_w = start.get(Calendar.DAY_OF_WEEK); // 指示一个星期中的某天。
    long start_end_w = 0;
    if(start_w == 1){
        start_end_w = start_m;
    }else if(start_w == 2){
        start_end_w = start_m + (6*one_day);
    }else if(start_w == 3){
        start_end_w = start_m + (5*one_day);
    }else if(start_w == 4){
        start_end_w = start_m + (4*one_day);
    }else if(start_w == 5){
        start_end_w = start_m + (3*one_day);
    }else if(start_w == 6){
        start_end_w = start_m + (2*one_day);
    }else if(start_w == 7){
        start_end_w = start_m + one_day;
    }

    //开始时间的结束周与结束时间相同
    Map<String,Date> start_w_map = new HashMap<String, Date>();
    start_date = new Date();
    end_date = new Date();
    if(start_end_w == end_m){
        start_date.setTime(start_m);
        start_w_map.put("start_time",start_date);
        end_date.setTime(start_end_w);
        start_w_map.put("end_time",end_date);
        list.add(start_w_map);
        return list;
    }else if(start_end_w > end_m){
        start_date.setTime(start_m);
        start_w_map.put("start_time",start_date);
        end_date.setTime(end_m);
        start_w_map.put("end_time",end_date);
        list.add(start_w_map);
        return list;
    }else {
        start_date.setTime(start_m);
        start_w_map.put("start_time", start_date);
        end_date.setTime(start_end_w);
        start_w_map.put("end_time", end_date);
        list.add(start_w_map);
    }

    //获取结束时间的开始周
    Calendar end = Calendar.getInstance(); // 获得一个日历
    end.setTimeInMillis(end_m);
    int end_w = end.get(Calendar.DAY_OF_WEEK); // 指示一个星期中的某天。
    long end_start_w = 0;
    if(end_w == 1){
        end_start_w = end_m - (6*one_day);
    }else if(end_w == 2){
        end_start_w = end_m;
    }else if(end_w == 3){
        end_start_w = end_m - (one_day);
    }else if(end_w == 4){
        end_start_w = end_m - (2*one_day);
    }else if(end_w == 5){
        end_start_w = end_m - (3*one_day);
    }else if(end_w == 6){
        end_start_w = end_m - (4*one_day);
    }else if(end_w == 7){
        end_start_w = end_m - (5*one_day);
    }
    //计算中间的时间    开始周和结束周不相同
    if(end_start_w-start_end_w+one_day > 0 ){
        long day = 0;
        if((end_start_w-one_day-start_end_w)%one_day == 0){
            day = (end_start_w-one_day-start_end_w)/one_day;
        }else{
            day = (end_start_w-one_day-start_end_w)/one_day+1;
        }
        long period_day = day/7;
        long s_time = 0;
        long next_time = 0;
        for(long i = 0;i<period_day;i++){
            Map<String,Date> map = new HashMap<String, Date>();
            if(i == 0){
                //第一次的开始时间
                s_time = start_end_w+one_day;
            }else{
                //以后次数的开始时间
                s_time = next_time + one_day;
            }
            next_time = s_time + (6*one_day);
            if(i == period_day -1){
                next_time = end_start_w-one_day;
            }
            start_date = new Date();
            end_date = new Date();
            start_date.setTime(s_time);
            map.put("start_time",start_date);
            end_date.setTime(next_time);
            map.put("end_time",end_date);
            list.add(map);
        }

    }
    Map<String,Date> end_w_map = new HashMap<String, Date>();
    start_date = new Date();
    end_date = new Date();
    start_date.setTime(end_start_w);
    end_w_map.put("start_time",start_date);
    end_date.setTime(end_m);
    end_w_map.put("end_time",end_date);
    list.add(end_w_map);
    return list;
}
1.3、自然月
/**
 * 两时间段的自然月  开始时间与结束时间均从零点开始
 * @param start_m
 * @param end_m
 * @return
 */
private List<Map<String,Date>> month(long start_m,long end_m){
    List<Map<String,Date>> list = new ArrayList<Map<String, Date>>();
    Date start_date;
    Date end_date;
    Map<String,Date> m_map ;

    long one_day = 24*60*60*1000;
    //获取两个时间段的月
    Calendar c_start = Calendar.getInstance(); // 获得一个日历
    c_start.setTimeInMillis(start_m);

    Calendar c_end = Calendar.getInstance(); // 获得一个日历
    c_end.setTimeInMillis(end_m);
    //计算间隔多少月
    int result = c_end.get(Calendar.MONTH) - c_start.get(Calendar.MONTH);
    int month = (c_end.get(Calendar.YEAR) - c_start.get(Calendar.YEAR)) * 12;
    int abs = Math.abs(month + result);
    //开始月和结束月不相同
    if(abs == 0 ){
        m_map = new HashMap<String, Date>();
        start_date = new Date();
        end_date = new Date();
        start_date.setTime(start_m);
        m_map.put("start_time",start_date);
        end_date.setTime(end_m);
        m_map.put("end_time",end_date);
        list.add(m_map);
        return list;

    }


    long max_day_m = 0;
    for(int i = 0;i<=abs;i++){
        m_map = new HashMap<String, Date>();
        start_date = new Date();
        end_date = new Date();
        long day_m = 0;
        //开始时间
        if(i == 0){
            start_date.setTime(start_m);
            m_map.put("start_time", start_date);
            day_m = start_m;
        } else{
            day_m = max_day_m + one_day;
            start_date.setTime(day_m);
            m_map.put("start_time", start_date);
        }
        //结束时间
        if(i == abs){
            end_date.setTime(end_m);
            m_map.put("end_time",end_date);
        }else {
            Calendar next_end = Calendar.getInstance();
            next_end.setTimeInMillis(day_m);
            next_end.set(Calendar.DAY_OF_MONTH, next_end.getActualMaximum(Calendar.DAY_OF_MONTH));
            max_day_m = next_end.getTime().getTime();
            end_date.setTime(max_day_m);
            m_map.put("end_time",end_date);
        }
        list.add(m_map);
    }

    return list;
}
1.4、自然季度
/**
 * 两个时间段的自然季度
 * @param start_m
 * @param end_m
 * @return
 */
private List<Map<String,Date>> quarter(long start_m,long end_m){
    List<Map<String,Date>> list = new ArrayList<Map<String, Date>>();
    Date start_date;
    Date end_date;
    Map<String,Date> q_map ;

    long one_day = 24*60*60*1000;
    //开始时间的结束季度时间
    long startQuarterStartTime = this.getQuarterStartTime(start_m);
    long startQuarterEndTime = this.getQuarterEndTime(start_m);
    //结束时间的开始季度时间
    long endQuarterStartTime = this.getQuarterStartTime(end_m);
    long endQuarterEndTime = this.getQuarterEndTime(end_m);
    //判断两个时间是否在同一个季度中
    if(startQuarterStartTime == endQuarterStartTime && startQuarterEndTime == endQuarterEndTime){
        q_map = new HashMap<String, Date>();
        start_date = new Date();
        end_date = new Date();
        start_date.setTime(start_m);
        q_map.put("start_time",start_date);
        end_date.setTime(end_m);
        q_map.put("end_time",end_date);
        list.add(q_map);
        return list;
    }
    //获取开始时间的结束季度的月
    Calendar c_start = Calendar.getInstance(); // 获得一个日历
    c_start.setTimeInMillis(startQuarterEndTime);
    //获取结束时间的结束季度的月
    Calendar c_end = Calendar.getInstance(); // 获得一个日历
    c_end.setTimeInMillis(endQuarterStartTime);
    //计算间隔多少月
    int result = c_end.get(Calendar.MONTH) - c_start.get(Calendar.MONTH);
    int month = (c_end.get(Calendar.YEAR) - c_start.get(Calendar.YEAR)) * 12;
    int abs = Math.abs(month + result);
    if(abs%3==0){
        abs = abs/3;
    }else{
        abs = abs/3+1;
    }

    long nextQuarterStart = 0;

    for(int i = 0;i<=abs;i++){
        q_map = new HashMap<String, Date>();
        if(i == 0){
            start_date = new Date();
            end_date = new Date();
            start_date.setTime(start_m);
            q_map.put("start_time",start_date);
            end_date.setTime(startQuarterEndTime);
            q_map.put("end_time",end_date);
            list.add(q_map);

            nextQuarterStart = startQuarterEndTime+one_day;

        }else if(i == abs){
            start_date = new Date();
            end_date = new Date();
            start_date.setTime(endQuarterStartTime);
            q_map.put("start_time",start_date);
            end_date.setTime(end_m);
            q_map.put("end_time",end_date);
            list.add(q_map);
        }else{
            start_date = new Date();
            end_date = new Date();
            start_date.setTime(nextQuarterStart);
            q_map.put("start_time",start_date);

            //下一个季度的结束时间
            long nextQuarterEndTime = this.getQuarterEndTime(nextQuarterStart);
            end_date.setTime(nextQuarterEndTime);
            q_map.put("end_time",end_date);
            list.add(q_map);
            nextQuarterStart = nextQuarterEndTime + one_day;
        }
    }

    return list;
}
/**
 * 季度的开始时间
 *
 * @return
 */
public long getQuarterStartTime(long time) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Calendar c = Calendar.getInstance();
    c.setTimeInMillis(time);
    int currentMonth = c.get(Calendar.MONTH) + 1;
    Date now = null;
    try {
        if (currentMonth >= 1 && currentMonth <= 3) {
            c.set(Calendar.MONTH, 0);
        }else if (currentMonth >= 4 && currentMonth <= 6){
            c.set(Calendar.MONTH, 3);
        }else if (currentMonth >= 7 && currentMonth <= 9){
            c.set(Calendar.MONTH, 6);
}       else if (currentMonth >= 10 && currentMonth <= 12) {
            c.set(Calendar.MONTH, 9);
        }
        c.set(Calendar.DATE, 1);
        now = sdf1.parse(sdf.format(c.getTime()) + " 00:00:00");
    } catch (Exception e) {
        e.printStackTrace();
    }
    return now.getTime();
}

/**
 * 季度的结束时间
 *
 * @return
 * @param start_m
 */
public long getQuarterEndTime(long start_m) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Calendar c = Calendar.getInstance();
    c.setTimeInMillis(start_m);
    int currentMonth = c.get(Calendar.MONTH) + 1;
    Date now = null;
    try {
        if (currentMonth >= 1 && currentMonth <= 3) {
            c.set(Calendar.MONTH, 2);
        } else if (currentMonth >= 4 && currentMonth <= 6) {
            c.set(Calendar.MONTH, 5);
        } else if (currentMonth >= 7 && currentMonth <= 9) {
            c.set(Calendar.MONTH, 8);
        } else if (currentMonth >= 10 && currentMonth <= 12) {
            c.set(Calendar.MONTH, 11);
        }
        c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
        now = sdf1.parse(sdf.format(c.getTime()) + " 00:00:00");
    } catch (Exception e) {
        e.printStackTrace();
    }
    return now.getTime();
}

2、固定周、月、季度

/**
 * 计算固定周期得时间
 * @param start_time
 * @param end_time
 * @param period  1：周，2：月，3：季度
 */
private Map<String,Object> fixationPeriod(Date start_time,Date end_time,String period){
    Map<String,Object> result = new HashMap<String, Object>();
    SimpleDateFormat sdf_s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //开始时间从零点开始
    long one_day = 24*60*60*1000;
    long start = 0;
    long end = 0;
    try {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        start = sdf_s.parse(sdf.format(start_time)+" 00:00:00").getTime();
        //结束时间到23:59:59
        end = sdf_s.parse(sdf.format(end_time)+" 00:00:00").getTime();
    } catch (ParseException e) {
        logger.error("时间转换异常=={}",e.getMessage());
        start = new Date().getTime();
        end = new Date().getTime();
    }
    //计算一共有多少天
    long day = 0;
    if((end - start)%one_day == 0){
        day = (end - start)/one_day;
    }else{
        day = (end - start)/one_day+1;
    }

    List<Map<String,Date>> list = new ArrayList<Map<String, Date>>();
    long period_day = 0;
    long interval_day = 0;
    //根据周期计算间隔
    if("1".equals(period)){
        interval_day = 6;
        //周
        if(day < 7){
            result.put("status",false);
            return result;
        }
        if(day%7==0){
            period_day = day/7;
        }else{
            period_day = day/7 +1 ;
        }
    }else if("2".equals(period)){
        interval_day = 29;
        //月
        if(day >= 30){
            if(day%30==0){
                period_day = day/30;
            }else{
                period_day = day/30 +1 ;
            }
        }

    }else if("3".equals(period)){
        interval_day = 89;
        //季度
        if(day >= 90){
            if(day%90==0){
                period_day = day/90;
            }else{
                period_day = day/90 +1 ;
            }
        }

    }
    long s_time = 0;
    long next_time = 0;
    for(long i = 0;i<period_day;i++){
        Map<String,Date> map = new HashMap<String, Date>();
        if(i == 0){
            //第一次的开始时间
            s_time = start;
        }else{
            //以后次数的开始时间
            s_time = next_time + one_day;
        }
        next_time = s_time + (interval_day*one_day);
        if(i == period_day -1){
            next_time = end;
        }
        Date sd = new Date();
        sd.setTime(s_time);
        map.put("start_time",sd);
        Date ed = new Date();
        ed.setTime(next_time);
        map.put("end_time",ed);
        list.add(map);
    }
    result.put("state",true);
    result.put("date",list);
    return result;
}
JAVA_Hunger
关注
专栏目录
Calendar日历类显示年、季度、月、天
qq_32635971的博客
05-11 1690
使用Calendar获取时间分量 1.生成实例 Calendar cal1 = Calendar.getInstance(); 2.设置 时间  按照：年 月 日 时 分 秒 cal1.set(cal1.get(Calendar.YEAR),cal1.get(Calendar.MONDAY), cal1.get(Calendar.DAY_OF_MONTH), 0, 0,0)
MySql查询某个时间段内的数据（前一周、前三个月、前一年等）
热门推荐
m0_67394002的博客
08-02 2万+
DATE_SUB函数在当前时间一定的时间date合法日期，可以是当前时间now()expr希望减去的时间，整数unit减去时间的单位，如day，week，month，year实例u_user表（1）、前一周的数据当前时间sql结果另一种sql写法（2）、前三个月的数据sql结果（3）、前一年的数据sql。...
Calendar时间获取天，周，月，季度，年度时间段
weixin_33843409的博客
05-15 373
Date类 Date类的大多数构造函数和方法都已经抛弃，只留下和毫秒有关的操作，目前常用的构造函数 常用方法 设置毫秒数 读取毫秒数 toString()打印结果 //创建日期对象，把当前的毫秒值转成日期对象 Date date = new Date(1607616000000L); System.out.println(date); //打印结果：Fri De...
关于JAVA使用Calendar操作自然周的工具类
weixin_44916238的博客
12-19 739
关于JAVA使用Calendar操作自然周的工具类 这个工具类中目前有三个关于自然周的方法。 方法一：通过输入当前时间计算当前时间是本年度第几个自然周 /** * @author qisw * @date 2019-12-06 17:03 * @return * @throws * @desc 根据传入的date时间类型 得出该时间是所属...
根据指定时间获取时间（日，周，月，季度，年）
weixin_55713874的博客
09-15 381
java获取时间
Calendar类获取本天、本周、本月、本季度、半年度、本年度的起始和结束时间
更阑一霎的博客
01-09 1149
很多时候别人对你好，并不是因为别人喜欢你，而是因为他们喜欢对人好。 Calendar类获取本天、本周、本月、本季度、半年度、本年度的起始时间 构建TimeUtils类 public class TimeUtils { /** * 获取 当前年、半年、季度、月、日、小时 开始结束时间 */ private final static SimpleDateForma...
excel按季度分类汇总_Excel 分类汇总按年、月和周且用数据透视表与公式实现，并把汇总结果提取出来...
weixin_36002475的博客
12-30 4647
在 Excel 中，按年、月、日和周分类汇总用数据透视表比较简单方便，进行简单的设置就可以返回它们的汇总结果；按年、月和日汇总可以直接显示它们，但按周汇总只能用日期表示周；而用公式汇总可以实现把属于每周的日期转为第几周。用公式实现按年、月和周分类汇总，主要用 Sum、SumIfs、SumProduct、Value、WeekNum、Date、Row 和 Text 等函数，例如按年和月汇总用前四个函数...
oracle取每日固定时间,Oracle查询每天固定时间段的数据
weixin_33327330的博客
04-11 5388
select * from GPS_LOG t where to_char(t.gps_time,'hh24:mm:ss')>='15:30:00'and to_char(t.gps_time,'hh24:mm:ss')<='17:00:00' order by t.gps_time…要实现这个功能需要用到trunc这个函数对时间的操作 select trunc(sysdate) fr...
mysql 一个月以前_mysql查询昨天 一周前 一月前 一年前的数据
weixin_35545135的博客
01-19 4061
mysql 昨天 一周前 一月前 一年前的数据 这里主要用到了DATE_SUB，参考如下代码如下:SELECT * FROM yh_contentwhere inputtime>DATE_SUB(CURDATE(), INTERVAL 1 DAY)where inputtime>DATE_SUB(CURDATE(), INTERVAL 1 WEEK)where inputtime&gt...
【愚公系列】《短视频生成与剪辑实战》002-利用ChatGPT生成脚本文案
最新发布
时光隧道
06-16 3万+
亲爱的读者朋友们，在这里，我们致力于为您提供最前沿、最有趣的短视频创作技巧和灵感。今天，我们特别向大家介绍一种高效、创新且经济的方法——利用ChatGPT生成短视频脚本文案。ChatGPT不仅能够帮助我们快速生成高质量的文本内容，还能为我们带来源源不断的创意和灵感。通过与ChatGPT的互动，我们可以获得高度定制化的脚本文案，满足不同受众和主题的需求。在保证内容风格和质量一致性的同时，它还能显著降低创作成本，特别适合预算有限的小团队或个人创作者。
查询日期所在的自然周，月的起始日期
02-09
查询所传过来的日期所在的自然周，月的起始和截止的日期
oracle获得日期自然周-函数
minghe_zy
12-21 565
文章来源：http://lijun0349-163-com.iteye.com/blog/616318   select to_week_by_year(to_date('2010-1-1', 'yyyy-MM-dd'))   from bak_member where rownum = 1  //输出:1 select to_week_by_year(to_date('2010-1-3', ...
根据时间段拆分出自然周和月时间段
Mr_faded的博客
09-02 636
根据日，周，月三个维度统计数据，2拆分周，3拆分月 /** * 2周 3月 * 根据时间段拆分出自然周和月时间段 * type * @param type * @param map * @return * @throws ParseException */ public static List<String> splitDateByType(Integer type, Map<String, O.
给定一个时间范围,以起始时间为头,以结束时间为尾,按月,季度,年进行分段时间范围提供
Umbrella Corporation
08-07 2万+
/** * 通过开始时间和结束时间查询中间的每个月的开始和结束时间 * @param startTime * @param endTime * @return * @throws ParseException */ public static List&lt;Map&lt;String, String&gt;&gt; quer...
获取小时、天、周、月、年五个维度的起止时间
weixin_44122204的博客
08-24 374
工具类如下 package com.simple.utils; import java.text.ParseException; import java.text.SimpleDateFormat; import java.time.DayOfWeek; import java.time.LocalDate; import java.time.temporal.TemporalAdjusters; import java.util.Calendar; import java.util.Date; /**
日期按、天、月、季度计算及格式化
萝卜&青菜的博客
03-03 1757
最近开发的项目平凡用到时间的各种计算及转化，虽然没多少技术含量但也记录一下。 直接上代码拿走不谢。 import org.apache.http.client.utils.DateUtils; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; public class...
java 获取当前时间的天、周、月、季度、半年度、年度开始和结束时间
iwuyuetian的专栏
08-10 2192
android 获取当前时间的天、周、月、季度、半年度、年度开始和结束时间 public class DateUtils{    /**       * 获取 当前年、半年、季度、月、日、小时 开始结束时间       */          private final static SimpleDateFormat shortSdf = new SimpleDateFormat(
时间工具（当月第一天，最后一天，当天最早和最晚，季度，年月日时分秒）
qq_36636312的博客
04-29 622
时间工具类 public static Date getMaxMonthDate(String date) { //格式化为年月 Calendar calendar = null; try { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM"); calendar = Calendar.getInstance();
java 获取当前季度
aydxl的博客
09-09 4358
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM"); String yearMonth = simpleDateFormat.format(date); String year = yearMonth.substring(0, 4); String month = yearMonth.substring(5, 7); int intMonth ...
考勤周汇总写法思路java
10-14
考勤周汇总的写法思路可以分为以下几个步骤： 1. 获取考勤数据：从数据库或者文件中读取考勤数据，可以使用 JDBC 或者文件读写操作实现。 2. 统计考勤数据：对考勤数据进行统计，计算出每个员工的出勤天数、迟到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值