java n个工作日后的日期

最新推荐文章于 2024-07-15 03:12:20 发布
最新推荐文章于 2024-07-15 03:12:20 发布
阅读量644 收藏 4
点赞数 7
分类专栏： java 文章标签： java n个工作日后
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35461948/article/details/138247126
版权
文章描述了一个Java类`HolidayUtils`，用于查询在给定日期基础上n个工作日后的日期，同时考虑法定节假日和周末补班的情况。它通过`isHoliday`和`isWorkWeekendDay`方法判断日期类型，并在`getIntervalWorkDate`方法中进行逻辑处理。
摘要由CSDN通过智能技术生成

接到个任务：

       获取到n个工作日后的时间，用于设置截止时间。

处理思路：

判断工作日，这种得弄个节假日表。判断时候，读取数据。

        1，设置节假日。

        2，设置周末补班。

n个工作日，从传的日期开始判断，

        1，先判断如果是节假日。不做处理

        2，判断是否是周末，再判断要不要补班。

        其它都是工作日。工作日不断叠加。

代码：

HolidayUtils

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
/**
 *  用于查询间隔n个工作日（包含法定节假日、双休日、调休）后的日期
 *  和查询间隔n个工作日（包含法定节假日、双休日、调休）后的实际间隔的天数
 */
public class HolidayUtils {
    private static final Logger logger = LoggerFactory.getLogger(HolidayUtils.class);
    private static String HOLIDAY = "holiday";
    private static String WORK_WEEKEND_DAY = "workWeekendDay";
    /**
     *  用于判断间隔n个工作日(排除节假日、周六日包含周末补班数据)后的日期
     * @param holidays 节假日数据
     * @param workWeekendDays 周末补班数据
     * @param today  计算开始时间
     * @param invervalWorkDay  间隔工作日
     * @return
     */
    public static Date getIntervalWorkDate(List<String> holidays, List<String> workWeekendDays, Date today, Integer invervalWorkDay) {
        String beginDay = DateUtils.formatDate(today);
        Date tomorrow;
        String tomorrowStr;
        int delay = 1;
        boolean workDay;
        while(delay <= invervalWorkDay){
            //获取明天的日期
            workDay = true;
            tomorrow = DateUtils.addDay(today, NumberUtils.INTEGER_ONE);
            tomorrowStr = DateUtils.formatDate(tomorrow);
            //当前日期+1即tomorrow, 先判断是否是节假日,再判断是否是周末,是周末再判断是否是补班, 直到循环间隔天数------不是节假日不是周末并且不是周末补班
            if (isHoliday(tomorrowStr, holidays)){
                workDay = false;
                logger.info("holiday {}: 是节假日", tomorrowStr);
            } else if(DateUtils.isWeekend(tomorrow)){//是周末，再判断是不是周末补班
                if(!isWorkWeekendDay(tomorrowStr, workWeekendDays)){
                    workDay = false;
                    logger.info("rest day {}: 是周末休息日", tomorrowStr);
                }else {
                    logger.info("work weekend day {}: 是周末调休补班", tomorrowStr);
                }
            } else {
                logger.info("work day {}: 是正常工作日", tomorrowStr);
            }
            if(workDay){ // 工作日，日期加1
                delay++;
            }
            today = tomorrow;
        }
        logger.info("interval date, {} 后{} 个工作日后,日期为:{}",beginDay, invervalWorkDay, DateUtils.formatDate(today));
        return today;
    }


    /**
     * 判断是否是节假日
     */
    public static boolean isHoliday(String dateStr, List<String> holidays) {
        if(!CollectionUtils.isEmpty(holidays)){
            for (String holiday : holidays) {
                if (dateStr.equals(holiday)) {
                    return true;
                }
            }
        }
        return false;
    }
    /**
     * 判断是否是周末补班
     */
    public static boolean isWorkWeekendDay(String dateStr, List<String> workWeekendDays) {
        if(!CollectionUtils.isEmpty(workWeekendDays)){
            for (String workWeekendDay : workWeekendDays) {
                if (dateStr.equals(workWeekendDay)) {
                    return true;
                }
            }
        }
        return false;
    }
    /**
     *  获取工作日后的间隔天数
     * @param holidays 节假日数据
     * @param workWeekendDays 周末补班数据
     * @param date 日期
     * @param intervalWorkDay  间隔工作日
     * @return 工作日后的间隔天数
     */
    public static Long getIntervalWorkDay(List<String> holidays, List<String> workWeekendDays, Date date, Integer intervalWorkDay) {
        Date intervalWorkDate = getIntervalWorkDate(holidays, workWeekendDays, date, intervalWorkDay);
        return DateUtils.getDiffDays(date, intervalWorkDate);
    }


    public static void main(String[] args) {
        List<HolidayConfigDTO> holidayDatas = new ArrayList<>();
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-09-29"), HOLIDAY));
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-10-02"), HOLIDAY));
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-10-03"), HOLIDAY));
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-10-04"), HOLIDAY));
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-10-05"), HOLIDAY));
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-10-06"), HOLIDAY));
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-10-07"), WORK_WEEKEND_DAY));
        holidayDatas.add(new HolidayConfigDTO(DateUtils.parseDate("2023-10-08"), WORK_WEEKEND_DAY));
        // 节假日集合
        List<String> holidays = holidayDatas.stream()
                .filter(holiday -> HOLIDAY.equals(holiday.getType()))
                .map(holiday -> DateUtils.formatDate(holiday.getHoliday())).collect(Collectors.toList());
        // 周末补班日集合
        List<String> workWeekenDays = holidayDatas.stream()
                .filter(workDay -> WORK_WEEKEND_DAY.equals(workDay.getType()))
                .map(workDay -> DateUtils.formatDate(workDay.getHoliday())).collect(Collectors.toList());
        Date createDate = DateUtils.parseDate("2023-09-27");
        Integer intervalWorkDay = 6;
        Date intervalWorkDate = HolidayUtils.getIntervalWorkDate(holidays, workWeekenDays, createDate, intervalWorkDay);
        System.out.println(DateUtils.formatDate(intervalWorkDate));
        Long diffDays = DateUtils.getDiffDays(createDate, intervalWorkDate);
        logger.info("intervalWorkDay {}, realIntervalDay {}", intervalWorkDay, diffDays);


    }


}

DateUtils

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
public class DateUtils {
    private static String datePattern = "yyyy-MM-dd";
    private static String dateHourPattern = "yyyy-MM-dd HH";
    private static String dateTimePattern = "yyyy-MM-dd HH:mm:ss";
    private static String dateTimePatternSSSXXX = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
    private static String dateTimeSuffixPattern = "yyyyMMddHHmmss";
    private static String zeroTime = " 00:00:00";
    private static String endTime = " 23:59:59";
    public static String format(Date date, String pattern) {
        if (date == null)
            return "";
        return DateFormatUtils.format(date, pattern);
    }
    public static String format(Date date, String pattern, TimeZone timeZone) {
        if (date == null)
            return "";
        return DateFormatUtils.format(date, pattern, timeZone);
    }
    public static String formatDate(Date date) {
        if (date == null)
            return "";
        return DateFormatUtils.format(date, datePattern);
    }
    public static String formatDate(Date date, TimeZone timeZone) {
        if (date == null)
            return "";
        return DateFormatUtils.format(date, datePattern, timeZone);
    }
    public static String formatDateTime(Date date) {
        if (date == null)
            return "";
        return DateFormatUtils.format(date, dateTimePattern);
    }
    public static String formatDateTime(Date date, TimeZone timeZone) {
        if (date == null)
            return "";
        return DateFormatUtils.format(date, dateTimePattern, timeZone);
    }
    public static Date parseDate(String str) {
        if (StringUtils.isBlank(str))
            return null;
        try {
            return org.apache.commons.lang3.time.DateUtils.parseDate(str, datePattern);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Date parseDateTime(String str) {
        if (StringUtils.isBlank(str))
            return null;
        try {
            return org.apache.commons.lang3.time.DateUtils.parseDate(str, dateTimePattern);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Date parseDateTime(String str, String dateTimePattern) {
        if (str == null)
            return null;
        try {
            return org.apache.commons.lang3.time.DateUtils.parseDate(str, Locale.CHINESE, dateTimePattern);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Date formatDateTimeZero(Date date) {
        String formatDate = formatDate(date);
        return parseDateTime(formatDate + zeroTime);
    }
    public static Date formatDateTimeEnd(Date date) {
        String formatDate = formatDate(date);
        return parseDateTime(formatDate + endTime);
    }
    public static Date getCurDateTime() {
        Date date = new Date();
        String curDate = DateFormatUtils.format(date, dateTimePatternSSSXXX);
        return DateUtils.parseDateTime(curDate, dateTimePatternSSSXXX);
    }


    public static Date getFirstOfHour(Date date) {
        String formatDate = format(date, dateHourPattern);
        return parseDateTime(formatDate + ":00:00");
    }
    public static Date getLastOfHour(Date date) {
        String formatDate = format(date, dateHourPattern);
        return parseDateTime(formatDate + ":59:59");
    }
    public static Date getFirstOfDay(Date date) {
        String formatDate = format(date, datePattern);
        return parseDateTime(formatDate + zeroTime);
    }
    public static Date getLastOfDay(Date date) {
        String formatDate = format(date, datePattern);
        return parseDateTime(formatDate + endTime);
    }
    /**
     * 获取指定日期所在月的第一天
     * @param date 日期
     * @return 所在月的第一天
     */
    public static Date getFirstOfMonth(Date date) {
        //获取当前月第一天：
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, 0);
        calendar.set(Calendar.DAY_OF_MONTH, 1);//设置为1号,当前日期既为本月第一天
        return formatDateTimeZero(calendar.getTime());
    }
    /**
     * 获取指定日期所在月的第最后一天
     * @param date 日期
     * @return  最后一天
     */
    public static Date getLastOfMonth(Date date) {
        //获取当前月最后一天
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        return formatDateTimeEnd(calendar.getTime());
    }
    /**
     * 获取当年的第一天
     */
    public static Date getCurrentFirstOfYear() {
        Calendar currCal = Calendar.getInstance();
        int currentYear = currCal.get(Calendar.YEAR);
        return getFirstOfYear(currentYear);
    }
    /**
     * 获取当年的最后一天
     */
    public static Date getCurrentLastOfYear() {
        Calendar currCal = Calendar.getInstance();
        int currentYear = currCal.get(Calendar.YEAR);
        return getLastOfYear(currentYear);
    }
    /**
     * 获取某年第一天日期
     * @param year 年份
     * @return Date
     */
    public static Date getFirstOfYear(int year) {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        return calendar.getTime();
    }


    /**
     * 获取某年第一天日期
     * @param date 日期
     * @return Date
     */
    public static Date getFirstOfYear(Date date) {
        int year = Integer.parseInt(String.format("%tY", date));
        return formatDateTimeZero(getFirstOfYear(year));
    }
    /**
     * 获取某年最后一天日期
     * @param year 年份
     * @return Date
     */
    public static Date getLastOfYear(int year) {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        calendar.roll(Calendar.DAY_OF_YEAR, -1);
        return calendar.getTime();
    }
    /**
     * 获取某年最后一天日期
     * @param date 日期
     * @return Date
     */
    public static Date getLastOfYear(Date date) {
        int year = Integer.parseInt(String.format("%tY", date));
        return formatDateTimeEnd(getLastOfYear(year));
    }
    /**
     * 计算两个日期之间的时间差，到秒
     * @param start  开始日期
     * @param end    结束日期
     * @return Long
     */
    public static Long getDiffDatesToSec(Date start, Date end) {
        long startTime = start.getTime();
        long endTime = end.getTime();
        return (endTime - startTime) / 1000;
    }
    public static Date addDay(Date start, Integer day) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(start);
        calendar.add(Calendar.DATE, day);
        return calendar.getTime();
    }
    public static Date addMonth(Date start, Integer month) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(start);
        calendar.add(Calendar.MONTH, month);
        return calendar.getTime();
    }
    public static Long getRemainMilOneDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        Long seconds = (calendar.getTime().getTime() - date.getTime());
        return seconds;
    }
    public static Long getDiffDays(Date start, Date end) {
        Long day = (parseDate(formatDate(end)).getTime() - parseDate(formatDate(start)).getTime())
                / (1000 * 60 * 60 * 24);
        return day;
    }
    public static String getCurrentTimeSuffix() {
        Date now = new Date();
        return format(now, dateTimeSuffixPattern);
    }
    /**
     * 判断是否是周末
     */
    public static boolean isWeekend(Date date) {
        Calendar cal = Calendar.getInstance();
        assert date != null;
        cal.setTime(date);
        return cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY || cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY;
    } 
    public static void main(String args[]) {
        String format = getCurrentTimeSuffix();
        System.out.println(format);
    }
}

HolidayConfigDTO

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
import java.util.Date;
@Data
@ToString
@ApiModel(value = "节假日配置")
@AllArgsConstructor
public class HolidayConfigDTO {
    @ApiModelProperty(value = "节假日")
    private Date holiday;
    @ApiModelProperty(value = "holiday 节假日， workWeekenDay 周末工作日")
    private String type;
}

数据库配置

DROP TABLE IF EXISTS `holiday_config`;
CREATE TABLE `holiday_config` ( 
  `holiday` date DEFAULT NULL,
  `type` varchar(20) DEFAULT 'holiday' 
    COMMENT 'holiday:法定节假日；workWeekenDay 调休补班' 
) COMMENT='节假日配置表，需要每年根据法定节假日具体时间更新一次';

总结：

        判断n个工作日后，设置一个节假日表。每年维护一次，就很方便了。

天狼1222
关注
专栏目录
Java——获取n个工作日后的日期（这里只除去周末）
Thancks
09-27 1355
我这里是个简单版的，只是去除周末，对于节假日无法自动掌控，需要配置节假日表，因为中国的节假日是每年定一次。 可以参考：获取n个工作后的日期，排除节假日和调休 我的简单版代码如下： public static void main(String[] args) throws ParseException { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date currDay = sdf.parse("2
java获取n个工作日后的日期, 排除周末和节假日(顺延)
weixin_44831283的博客
06-23 1488
从数据库中查询holiday结果集, 遍历结果集将每一天holiday存到holidayList中 调用HolidayUtils中的getScheduleActiveDate传入正确的参数, 返回值即是排除节假日和周末后的指定n个工作日后的日期.(HolidayUtils如下) ......
计算N个工作日后的日期
03-06
计算N个工作日后的日期
JAVA获取N个工作日后的时间的工具类、考虑上班时间、时区
csdn_CZQ的博客
11-17 1688
获取N个工作日后的时间的工具类，跳过周末、节假日，可以用于计算SLA
java 判断是否节假日工具类
最新发布
weixin_41085941的博客
07-15 219
Java判断是否节假日工具类教程 一、流程概述 为了实现“Java判断是否节假日工具类”，我们需要按照以下步骤进行： 获取指定日期的节假日数据 判断指定日期是否为节假日 二、具体步骤及代码示例 步骤表格 步骤 描述 1 引入相关库并初始化工具类 2 获取节假日数据 3 判断指定日期是否为节假日 ...
java 获取n天之后的工作日，不考虑节假日
iSunday的专栏
11-05 1681
 看过网上的相关代码，思路大多数是迭代日期以排除周末，效率不是很高，自己写了一个。仅供参阅 /** * 获取n天之后的工作日 * @param today * @param afterDays * @return */ public static Date getAfterWorkDay(Date today, Integer afte...
java 获取n个工作日后的日期（包含法定节假日、双休日、节后补班）
weixin_30384217的博客
07-03 602
1.说明： 　　获取n个工作日后的日期（包含法定节假日、双休日、节后补班），需要在数据库手动入库当年的法定节假日及节假日调休补班。（也可写在配置文件中读取） 2.工具类代码 import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import jav...
java得到下一个法定工作日期
07-31
NULL 博文链接：https://best-sheng.iteye.com/blog/1000830
java计算当前日期后N个工作日的日期
AnNong
05-27 5385
如图，合同中有很多这种日期计算，故封装一通用工具类，记录于此。需求如下： WorkDayUtils如下： package com.sqds.utils; import org.apache.commons.lang.StringUtils; import java.text.SimpleDateFormat; import java.util.*; /** * 工作日计算工具类 ...
Java之获取指定时间、指定N个工作日后的日期
碎狸~的博客
12-03 2320
环境（SpringBoot+MyBatis+JPA） 需求是需要判断某个节点或者某些有时间的字段是否超时。例如提交某个申请规定的审核时间是5个工作日。那么要判断是否超时，就得获取从开始时间后5个工作日的日期。这个工作日是不包含节假日、周末。或者说工作日是自己定义的时间。 节假日实体类 该实体类主要是记录周末、加班、节假日的日期 import lombok.Getter; import lombok...
判断是否是节假日以及几个工作日后的日期（包含json格式依赖jar包）
03-04
在Java编程中，有时我们需要处理与日期相关的任务，例如判断某个日期是否是节假日，或者计算几个工作日后的新日期。这个工具类就是为了解决这样的问题而设计的。它包含了一个功能丰富的API，允许开发者轻松地进行...
JAVA获取工作日，及设定指示日期为工作日 （新）
12-16
可以获取得到工作的MAP，并可以指定日期为工作日，将工作日设为非工作日. 之前提交的有问题
HolidayUtil.java
09-17
节假日获取
java计算整年工作日(包含特殊的工作日)排除法定节假日和周末能运行
01-17
java计算整年工作日(包含特殊的工作日)排除法定节假日和周末能运行
java计算5个工作日后的日期
qq_43805205的博客
10-19 372
【代码】java计算5个工作日后的日期。
获取N个工作日后的日期
Just_do_it_HZF的博客
12-23 323
package com.nstc.wst.util; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.List; import java.lang.*; public class HolidayUtil { private .
Java 获取 n个 工作日【前】或【后】的日期
qq_36473199的博客
02-13 4133
Java 通过当前日期【时间值自定义】，获取n个工作日【前】或【后】的日期 注：节假日要自己存储到数据库，存储形式自选 import org.apache.commons.lang.StringUtils; /** * 一个非常好用的工具类 * &lt;dependency&gt; * &lt;groupId&gt;org.apache.commons&lt;/group...
【Java开发-工作日计算】使用Java中的LocalDateTime对象计算工作日
筱星
06-25 1102
计算给定开始时间、结束时间以及节假日列表之间的工作小时数（不包括周末、节假日以及非工作时间，例如每天的晚上和凌晨） 早上如果不到9点，按9点开始算；下午如果超过17点，按17点结束算
Java 获取每年调休后的节假日
wang18057的博客
10-17 343
Java获取每年的休息日
Java进行T+n工作日判断
01-16
您可以创建一个Calendar对象并设置它的日期，然后使用`add`方法将日期加上所需的天数，并检查这一天是否是工作日。 例如： ``` import java.util.Calendar; public class Main { public static void main(String...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天狼1222

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值