【Java获取国家法定节假日三种工具类其一】

最新推荐文章于 2024-03-19 11:01:03 发布
最新推荐文章于 2024-03-19 11:01:03 发布
阅读量4.1k 收藏 13
点赞数 2
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46475664/article/details/124149865
版权

最全的时间工具类

开箱即用

public abstract class MyDateUtil {
    /**
     * 时区误差
     */
    private static long timeZoneError = 0;
    /**
     * 添加更多支持日期字符串格式
     * 默认支持：yyyyMMdd[ HHmmss]、yyyy-MM-dd[ HH:mm:ss]、yyyy/MM/dd[ HH:mm:ss]
     */
    private static List<String> patternList = new ArrayList<>();

    /**
     * 全局工作日配置
     */
    private static WorkdayConfig workdayConfig;

    static {
        timeZoneError = new DateTime("1970-01-01").getTime();
        initHolidat();
        //添加更多日期格式
//		patternList.add("dd-MM-yyyy");
    }

    /**
     * 工作日设置
     * @return WorkdayConfig
     */
    public static WorkdayConfig workdayConfig() {
        if (workdayConfig == null) {
            workdayConfig = new WorkdayConfig();
        }
        return workdayConfig;
    }

    /**
     * 获取一个当前的工作日配置
     * @return WorkdayConfig
     */
    public static WorkdayConfig getWorkdayConfig() {
        try {
            return (WorkdayConfig) workdayConfig().clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return new WorkdayConfig();
    }

    /**
     * 日期格式化成字符串
     *
     * @param date
     * @param pattern
     * @return String
     */
    public static String format(Date date, String pattern) {
        if (date == null) {
            return null;
        }
        SimpleDateFormat fmt = new SimpleDateFormat(pattern);
        return fmt.format(date);
    }

    /**
     * 根据语言和格式，格式化日期成字符串
     *
     * @param date
     * @param pattern
     * @param locale
     * @return String
     */
    public static String format(Date date, String pattern, Locale locale) {
        DateFormatSymbols symbols = new DateFormatSymbols(locale);
        SimpleDateFormat fmt = new SimpleDateFormat(pattern, symbols);
        return fmt.format(date);
    }

    /**
     * 日期字符串转换成日期
     *
     * @param date
     * @param pattern
     * @return DateTime
     */
    public static DateTime parseDate(String date, String pattern) {
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        try {
            return new DateTime(format.parse(date));
        } catch (ParseException e) {
            throw new IllegalArgumentException("字符串转日期失败，日期'" + date + "'与格式'" + pattern + "'不对应");
        }
    }

    /**
     * <p>日期字符串转换成日期，自动识别格式</p>
     * 默认支持yyyyMMdd[ HHmmss]、yyyy-MM-dd[ HH:mm:ss]、yyyy/MM/dd[ HH:mm:ss]<br>
     * 如果频繁使用该方法转换日期，又需要效率，那尽量使用 {@link #parseDate(String, String)} 方法
     *
     * @param date
     * @return DateTime
     * @see DateUtil# 自定义支持列表
     */
    public static DateTime parseDate(String date) {
        if (patternList != null && !patternList.isEmpty()) {
            for (String pattern : patternList) {
                try {
                    DateTime dateTime = parseDate(date, pattern);
                    if (dateTime != null) {
                        return dateTime;
                    }
                } finally {
                }
            }
        }
        String d = date.replaceAll("[^\\d]", "");
        String pattern = "yyyyMMdd";
        if (d.length() > pattern.length()) {
            pattern += "HH";
        }
        if (d.length() > pattern.length()) {
            pattern += "mm";
        }
        if (d.length() > pattern.length()) {
            pattern += "ss";
        }
        if (d.length() > pattern.length()) {
            pattern += "SSS";
        }
        try {
            return parseDate(d, pattern);
        } catch (Exception e) {
            throw new IllegalArgumentException("无法识别日期：" + date);
        }
    }

    /**
     * 判断字符串是否是日期
     *
     * @param date
     * @return boolean
     */
    public static boolean isDate(String date) {
        try {
            parseDate(date);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public static DateTime date() {
        return new DateTime();
    }

    public static DateTime date(Date date) {
        return new DateTime(date);
    }

    public static DateTime date(int year, int month, int date,
                                int hour, int minute, int second) {
        return new DateTime()
                .year(year).month(month).day(date)
                .hour(hour).minute(minute).second(second);
    }

    public static DateTime date(int year, int month, int date) {
        return date(year, month, date, 0, 0, 0);
    }

    public static class DateTime extends Date {
        private Calendar calendar = Calendar.getInstance();
        private String pattern;
        private WorkdayConfig workdayConfig;

        private DateTime() {
            super();
            calendar.setTime(this);
            workdayConfig = MyDateUtil.workdayConfig();
        }

        private DateTime(long time) {
            super(time);
            calendar.setTime(this);
            workdayConfig = MyDateUtil.workdayConfig();
        }

        private DateTime(Date date) {
            this(date.getTime());
        }

        private DateTime(String date) {
            this(MyDateUtil.parseDate(date));
        }

        @Override
        public String toString() {
            return toString(StringUtils.defaultString(pattern, "yyyy-MM-dd HH:mm:ss"));
        }

        public String toString(String pattern) {
            return format(this, pattern);
        }

        public String toString(String pattern, Locale locale) {
            return format(this, pattern, locale);
        }

        public Calendar toCalendar() {
            return calendar;
        }

        public DateTime workdayConfig(WorkdayConfig workdayConfig) {
            this.workdayConfig = workdayConfig;
            return this;
        }

        /**
         * 获取日期格式
         */
        public String getPattern() {
            return pattern;
        }

        /**
         * 设置日期格式
         *
         * @param pattern
         */
        public DateTime pattern(String pattern) {
            if (pattern != null && pattern.trim().equals("")) {
                throw new IllegalArgumentException("日期格式不能设置为空字符串");
            }
            this.pattern = pattern;
            return this;
        }

        /**
         * 设置时间
         *
         * @param field 精确度
         * @param value 值
         *              <br/>{@link Calendar#SECOND}
         *              <br/>{@link Calendar#MINUTE}
         *              <br/>{@link Calendar#HOUR}
         *              <br/>{@link Calendar#DATE}
         *              <br/>{@link Calendar#MONTH}
         *              <br/>{@link Calendar#YEAR}
         * @return DateTime
         */
        public DateTime set(int field, int value) {
            if (field == Calendar.MONTH) {
                value -= 1;
            }

            calendar.set(field, value);
            setTime(calendar.getTimeInMillis());
            return this;
        }

        /**
         * 设置秒
         *
         * @param value
         * @return DateTime
         */
        public DateTime second(int value) {
            return set(Calendar.SECOND, value);
        }

        /**
         * 设置分
         *
         * @param value
         * @return DateTime
         */
        public DateTime minute(int value) {
            return set(Calendar.MINUTE, value);
        }

        /**
         * 设置时
         *
         * @param value
         * @return DateTime
         */
        public DateTime hour(int value) {
            return set(Calendar.HOUR, value);
        }

        /**
         * 设置天
         *
         * @param value
         * @return DateTime
         */
        public DateTime day(int value) {
            return set(Calendar.DATE, value);
        }

        /**
         * 设置月
         *
         * @param value
         * @return DateTime
         */
        public DateTime month(int value) {
            return set(Calendar.MONTH, value);
        }

        /**
         * 设置年
         *
         * @param value
         * @return DateTime
         */
        public DateTime year(int value) {
            return set(Calendar.YEAR, value);
        }

        /**
         * 添加时间
         *
         * @param field  精确度
         *               <br/>{@link Calendar#SECOND}
         *               <br/>{@link Calendar#MINUTE}
         *               <br/>{@link Calendar#HOUR}
         *               <br/>{@link Calendar#DATE}
         *               <br/>{@link Calendar#MONTH}
         *               <br/>{@link Calendar#YEAR}
         * @param amount 添加数
         * @return 添加后的时间
         */
        public DateTime add(int field, int amount) {
            calendar.add(field, amount);
            setTime(calendar.getTimeInMillis());
            return this;
        }

        /**
         * 添加秒
         *
         * @param minute
         * @return DateTime
         */
        public DateTime addSecond(int minute) {
            return add(Calendar.SECOND, minute);
        }

        /**
         * 添加分钟
         *
         * @param minute
         * @return DateTime
         */
        public DateTime addMinute(int minute) {
            return add(Calendar.MINUTE, minute);
        }

        /**
         * 添加小时
         *
         * @param hours
         * @return DateTime
         */
        public DateTime addHours(int hours) {
            return add(Calendar.HOUR, hours);
        }

        /**
         * 添加天数
         *
         * @param days
         * @return DateTime
         */
        public DateTime addDays(int days) {
            return add(Calendar.DATE, days);
        }

        /**
         * 添加月份
         *
         * @param months
         * @return DateTime
         */
        public DateTime addMonths(int months) {
            return add(Calendar.MONTH, months);
        }

        /**
         * 添加年份
         *
         * @param years
         * @return DateTime
         */
        public DateTime addYears(int years) {
            return add(Calendar.YEAR, years);
        }

        /**
         * 比较两个时间
         *
         * @param time
         * @param field 精确度
         *              <br/>{@link Calendar#SECOND}
         *              <br/>{@link Calendar#MINUTE}
         *              <br/>{@link Calendar#HOUR}
         *              <br/>{@link Calendar#DATE}
         *              <br/>{@link Calendar#MONTH}
         *              <br/>{@link Calendar#YEAR}
         * @return 两时间相差的值，结果=0:time1=time2，结果<0:time1&gt;time2，结果>0:time1>time2
         */
        public int compare(Date time, int field) {
            if (time == null) {
                throw new IllegalArgumentException();
            }

            Calendar c = new DateTime(time).toCalendar();

            int accuracy = 1000;
            switch (field) {
                case Calendar.SECOND:
                    accuracy = 1000;
                    break;
                case Calendar.MINUTE:
                    accuracy = 60 * 1000;
                    break;
                case Calendar.HOUR:
                    accuracy = 60 * 60 * 1000;
                    break;
                case Calendar.DATE:
                    accuracy = 24 * 60 * 60 * 1000;
                    break;
                case Calendar.MONTH:
                    int month = calendar.get(Calendar.MONTH) - c.get(Calendar.MONTH);
                    int year = calendar.get(Calendar.YEAR) - c.get(Calendar.YEAR);
                    return month + year * 12;
                case Calendar.YEAR:
                    year = calendar.get(Calendar.YEAR) - c.get(Calendar.YEAR);
                    return year;
            }
            int t1 = (int) ((calendar.getTimeInMillis() - timeZoneError) / accuracy);
            int t2 = (int) ((c.getTimeInMillis() - timeZoneError) / accuracy);
            return t1 - t2;
        }

        /**
         * 比较两个时间，精确到秒
         *
         * @param time
         * @return 两时间相差的秒数
         */
        public int compareSeconds(Date time) {
            return compare(time, Calendar.SECOND);
        }

        /**
         * 比较两个时间，精确到分钟
         *
         * @param time
         * @return 两时间相差的分钟数
         */
        public int compareMinutes(Date time) {
            return compare(time, Calendar.MINUTE);
        }

        /**
         * 比较两个时间，精确到小时
         *
         * @param time
         * @return 两时间相差的小时数
         */
        public int compareHours(Date time) {
            return compare(time, Calendar.HOUR);
        }

        /**
         * 比较两个日期，精确到天
         *
         * @param date
         * @return 两日期相差的天数
         */
        public int compareDays(Date date) {
            return compare(date, Calendar.DATE);
        }

        /**
         * 判断时间在指定时间之前
         *
         * @param field 精确度
         *              <br/>{@link Calendar#SECOND}
         *              <br/>{@link Calendar#MINUTE}
         *              <br/>{@link Calendar#HOUR}
         *              <br/>{@link Calendar#DATE}
         *              <br/>{@link Calendar#MONTH}
         *              <br/>{@link Calendar#YEAR}
         * @return boolean
         */
        public boolean before(Date date, int field) {
            return (compare(date, field) < 0);
        }

        /**
         * 判断时间在指定时间之前（精确到毫秒）
         *
         * @return boolean
         */
        @Override
        public boolean before(Date date) {
            return this.before(date, Calendar.MILLISECOND);
        }

        /**
         * 判断时间在指定时间之前（精确到秒）
         *
         * @return boolean
         */
        public boolean beforeOfSecond(Date date) {
            return this.before(date, Calendar.SECOND);
        }

        /**
         * 判断时间在指定时间之前（精确到分）
         *
         * @return boolean
         */
        public boolean beforeOfMinute(Date date) {
            return this.before(date, Calendar.MINUTE);
        }

        /**
         * 判断时间在指定时间之前（精确到小时）
         *
         * @return boolean
         */
        public boolean beforeOfHour(Date date) {
            return this.before(date, Calendar.HOUR);
        }

        /**
         * 判断时间在指定时间之前（精确到天）
         *
         * @return boolean
         */
        public boolean beforeOfDay(Date date) {
            return this.before(date, Calendar.DATE);
        }

        /**
         * 判断时间在指定时间之后
         *
         * @param field 精确度
         *              <br/>{@link Calendar#SECOND}
         *              <br/>{@link Calendar#MINUTE}
         *              <br/>{@link Calendar#HOUR}
         *              <br/>{@link Calendar#DATE}
         *              <br/>{@link Calendar#MONTH}
         *              <br/>{@link Calendar#YEAR}
         * @return boolean
         */
        public boolean after(Date date, int field) {
            return (compare(date, field) > 0);
        }

        /**
         * 判断时间在指定时间之后（精确到毫秒）
         *
         * @return boolean
         */
        @Override
        public boolean after(Date date) {
            return this.after(date, Calendar.MILLISECOND);
        }

        /**
         * 判断时间在指定时间之后（精确到秒）
         *
         * @return boolean
         */
        public boolean afterOfSecond(Date date) {
            return this.after(date, Calendar.SECOND);
        }

        /**
         * 判断时间在指定时间之后（精确到分）
         *
         * @return boolean
         */
        public boolean afterOfMinute(Date date) {
            return this.after(date, Calendar.MINUTE);
        }

        /**
         * 判断时间在指定时间之后（精确到小时）
         *
         * @return boolean
         */
        public boolean afterOfHour(Date date) {
            return this.after(date, Calendar.HOUR);
        }

        /**
         * 判断时间在指定时间之后（精确到天）
         *
         * @return boolean
         */
        public boolean afterOfDay(Date date) {
            return this.after(date, Calendar.DATE);
        }

        /**
         * 判断时间和指定时间是否是同一个时间
         *
         * @param field 精确度
         *              <br/>{@link Calendar#SECOND}
         *              <br/>{@link Calendar#MINUTE}
         *              <br/>{@link Calendar#HOUR}
         *              <br/>{@link Calendar#DATE}
         *              <br/>{@link Calendar#MONTH}
         *              <br/>{@link Calendar#YEAR}
         * @return boolean
         */
        public boolean same(Date date, int field) {
            return (compare(date, field) == 0);
        }

        /**
         * 判断时间和指定时间是否是一个分钟（包含年月日时）
         *
         * @return boolean
         */
        public boolean sameMinute(Date date) {
            return this.same(date, Calendar.MINUTE);
        }

        /**
         * 判断时间和指定时间是否是一个小时（包含年月日）
         *
         * @return boolean
         */
        public boolean sameHour(Date date) {
            return this.same(date, Calendar.HOUR);
        }

        /**
         * 判断时间和指定时间是否是一天
         *
         * @return boolean
         */
        public boolean sameDay(Date date) {
            return this.same(date, Calendar.DATE);
        }

        /**
         * 判断时间是否在开始时间和结束时间之间
         *
         * @param startTime
         * @param endTime
         * @param field     精确度
         *                  <br/>{@link Calendar#SECOND}
         *                  <br/>{@link Calendar#MINUTE}
         *                  <br/>{@link Calendar#HOUR}
         *                  <br/>{@link Calendar#DATE}
         *                  <br/>{@link Calendar#MONTH}
         *                  <br/>{@link Calendar#YEAR}
         * @return boolean
         */
        public boolean isBetween(Date startTime, Date endTime, int field) {
            return compare(startTime, field) >= 0 && compare(endTime, field) <= 0;
        }

        /**
         * 判断时间是否在开始时间和结束时间之间，精确到秒
         *
         * @param startTime
         * @param endTime
         * @return boolean
         */
        public boolean isBetweenOfSecond(Date startTime, Date endTime) {
            return isBetween(startTime, endTime, Calendar.SECOND);
        }

        /**
         * 判断日期是否在开始日期和结束时间日期之间，精确到分
         *
         * @param startTime
         * @param endTime
         * @return boolean
         */
        public boolean isBetweenOfMinute(Date startTime, Date endTime) {
            return isBetween(startTime, endTime, Calendar.MINUTE);
        }

        /**
         * 判断今天是否在开始日期和结束时间日期之间，精确到小时
         *
         * @param startDate
         * @param endDate
         * @return boolean
         */
        public boolean isBetweenOfHour(Date startDate, Date endDate) {
            return isBetween(startDate, endDate, Calendar.HOUR);
        }

        /**
         * 判断今天是否在开始日期和结束时间日期之间，精确到天
         *
         * @param startDate
         * @param endDate
         * @return boolean
         */
        public boolean isBetweenOfDay(Date startDate, Date endDate) {
            return isBetween(startDate, endDate, Calendar.DATE);
        }

        /**
         * 转到月份最后一天日期
         *
         * @return DateTime
         */
        public DateTime monthLastDate() {
            addMonths(1).set(Calendar.DAY_OF_MONTH, 0);
            return this;
        }

        /**
         * 转到所在星期的第一天
         *
         * @return DateTime
         */
        public DateTime weekStart() {
            return set(Calendar.DAY_OF_WEEK, 2);
        }

        /**
         * 转到所在星期的最后一天
         *
         * @return DateTime
         */
        public DateTime weekEnd() {
            return set(Calendar.DAY_OF_WEEK, 1).addDays(7);
        }

        /**
         * @see Calendar#get(int)
         */
        public int get(int field) {
            return calendar.get(field);
        }

        /**
         * 获取年
         */
        public int year() {
            return calendar.get(Calendar.YEAR);
        }

        /**
         * 获取月
         */
        public int month() {
            return calendar.get(Calendar.MONTH) + 1;
        }

        /**
         * 获取日
         */
        public int day() {
            return calendar.get(Calendar.DATE);
        }

        /**
         * 获取时
         */
        public int hour() {
            return calendar.get(Calendar.HOUR);
        }

        /**
         * 获取分
         */
        public int minute() {
            return calendar.get(Calendar.MINUTE);
        }

        /**
         * 获取秒
         */
        public int second() {
            return calendar.get(Calendar.SECOND);
        }

        /**
         * 获取毫秒
         */
        public int millisecond() {
            return calendar.get(Calendar.MILLISECOND);
        }

        /**
         * 获取日期是星期几
         *
         * @return 1-7对应星期天到星期六
         */
        public int getWeek() {
            return calendar.get(Calendar.DAY_OF_WEEK);
        }

        /**
         * 获取中文星期几
         *
         * @return String
         */
        public String getZhWeek() {
            return format(this, "EEE", Locale.SIMPLIFIED_CHINESE);
        }


        /**
         * 是否是工作日
         *
         * @return boolean
         */
        public boolean isWorkday() {
            return workdayConfig.isWorkday(this);
        }

        /**
         * 是否是节假日
         *
         * @return boolean
         */
        public boolean isHoliday() {
            return workdayConfig.isHoliday(this);
        }

        /**
         * 是否是休息日，包含节假日
         *
         * @return boolean
         */
        public boolean isDayOff() {
            return workdayConfig.isDayOff(this);
        }

        /**
         * 计算多少个工作日之后的日期
         *
         * @param days
         * @return  DateTime
         */
        public DateTime addWorkdays(int days) {
            DateTime date = MyDateUtil.date(this);
            if (days > 0) {
                for (int i = days; i > 0; i--) {
                    if (!date.addDays(1).isWorkday()) {
                        i++;
                    }
                }
            } else if (days < 0) {
                for (int i = days; i < 0; i++) {
                    if (!date.addDays(-1).isWorkday()) {
                        i--;
                    }
                }
            }
            return date;
        }

        /**
         * 计算两个日期之间有多少个工作日
         *
         * @param date
         * @return int
         */
        public int compareWorkdays(Date date) {
            int days = compareDays(date);
            if (days == 0) {
                return 0;
            }
            Date start = days > 0 ? date : this;
            days = Math.abs(days);
            int count = 0;
            for (int i = 1; i <= days; i++) {
                if (MyDateUtil.date(start).addDays(i).isWorkday()) {
                    count++;
                }
            }
            return count;
        }
    }

    public static class WorkdayConfig implements Cloneable {
        /**
         * 补班日期
         */
        private HashSet<String> workdays = new HashSet<>();
        /**
         * 节假日日期
         */
        private HashSet<String> holidays = new HashSet<>();
        /**
         * 周休息日
         */
        private ArrayList<Integer[]> weekDayOff = new ArrayList<>();
        /**
         * 月休息日
         */
        private HashMap<Integer, Integer[]> monthDayOff = new HashMap<>();

        private WorkdayConfig() {
            weekDayOff.add(new Integer[]{Calendar.SATURDAY, Calendar.SUNDAY});
        }

        /**
         * 设置补班/调班日期
         *
         * @param dates
         * @return WorkdayConfig
         */
        public WorkdayConfig setWorkdays(List<Date> dates) {
            List<String> list = dates.stream().map(date -> {
                return MyDateUtil.date(date).toString("yyyy-MM-dd");
            }).collect(Collectors.toList());
            workdays.addAll(list);
            return this;
        }

        /**
         * 设置节假日日期
         *
         * @param dates
         * @return WorkdayConfig
         */
        public WorkdayConfig setHolidays(List<Date> dates) {
            List<String> list = dates.stream().map(date -> {
                return MyDateUtil.date(date).toString("yyyy-MM-dd");
            }).collect(Collectors.toList());
            holidays.addAll(list);
            return this;
        }

        /**
         * 设置周休息日，默认周六周日休息，可设置单双周
         *
         * @param dayOffArray
         * @return WorkdayConfig
         */
        public WorkdayConfig setWeekDayOff(Integer[]... dayOffArray) {
            if (dayOffArray.length > 4) {
                throw new IllegalArgumentException("最多设置四周的休息日");
            }
            Arrays.stream(dayOffArray).forEach(dayOffs -> {
                Arrays.stream(dayOffs).forEach(week -> {
                    if (week < 1 || week > 7) {
                        throw new IllegalArgumentException("休息日的设置范围1-7，对应星期天到星期六");
                    }
                });
            });
            weekDayOff.clear();
            weekDayOff.addAll(Arrays.asList(dayOffArray));
            return this;
        }

        /**
         * 添加月休息日
         *
         * @param month
         * @param days
         * @return WorkdayConfig
         */
        public WorkdayConfig addMonthDayOff(int month, Integer... days) {
            if (month < 0 || month > 12) {
                throw new IllegalArgumentException("月份请设置1-12月");
            }
            DateTime date = MyDateUtil.date();
            date.month(month);
            Arrays.stream(days).forEach(day -> {
                if (date.day(day).month() != month) {
                    System.out.println(date.toString());
                    throw new IllegalArgumentException(month + "月不存在" + day + "号");
                }
            });
            monthDayOff.put(month, days);
            return this;
        }

        /**
         * 删除指定月休息日
         *
         * @param month
         * @return WorkdayConfig
         */
        public WorkdayConfig removeMonthDayOff(int month) {
            monthDayOff.remove(month);
            return this;
        }

        /**
         * 是否是工作日
         *
         * @param date
         * @return boolean
         */
        public boolean isWorkday(Date date) {
            DateTime dateTime = MyDateUtil.date(date);
            String d = dateTime.toString("yyyy-MM-dd");
            //是否是补班
            if (workdays.contains(d)) {
                return true;
            }
            //是否是放假
            if (holidays.contains(d)) {
                return false;
            }
            //是否是月调休
            if (!monthDayOff.isEmpty()) {
                Integer[] days = monthDayOff.get(dateTime.month());
                if (days != null && ArrayUtils.contains(days, dateTime.day())) {
                    return false;
                }
            }
            //是否是每周的休息日
            if (!weekDayOff.isEmpty()) {
                int size = weekDayOff.size();
                int i = dateTime.get(Calendar.WEEK_OF_YEAR);
                int mo = i % size;
                Integer[] dayOff = weekDayOff.get(mo);
                return !ArrayUtils.contains(dayOff, dateTime.getWeek());
            }
            return true;
        }

        /**
         * 是否是节假日
         *
         * @param date
         * @return boolean
         */
        public boolean isHoliday(Date date) {
            String d = MyDateUtil.date(date).toString("yyyy-MM-dd");
            return holidays.contains(d);
        }

        /**
         * 是否是休息日，包含节假日
         *
         * @param date
         * @return boolean
         */
        public boolean isDayOff(Date date) {
            return !isWorkday(date);
        }

        @Override
        public Object clone() throws CloneNotSupportedException {
            WorkdayConfig workdayConfig = (WorkdayConfig) super.clone();
            workdayConfig.workdays = (HashSet<String>) this.workdays.clone();
            workdayConfig.holidays = (HashSet<String>) this.holidays.clone();
            workdayConfig.weekDayOff = (ArrayList<Integer[]>) this.weekDayOff.clone();
            workdayConfig.monthDayOff = (HashMap<Integer, Integer[]>) this.monthDayOff.clone();
            return workdayConfig;
        }
    }

    private static void initHolidat(){
        List<Date> workdays= new ArrayList<>();
        List<Date> holidays = new ArrayList<>();
        holidays.add(MyDateUtil.parseDate("2022-01-01"));
        holidays.add(MyDateUtil.parseDate("2022-01-02"));
        holidays.add(MyDateUtil.parseDate("2022-01-03"));
        holidays.add(MyDateUtil.parseDate("2022-01-31"));
        holidays.add(MyDateUtil.parseDate("2022-02-01"));
        holidays.add(MyDateUtil.parseDate("2022-02-02"));
        holidays.add(MyDateUtil.parseDate("2022-02-03"));
        holidays.add(MyDateUtil.parseDate("2022-02-04"));
        holidays.add(MyDateUtil.parseDate("2022-02-05"));
        holidays.add(MyDateUtil.parseDate("2022-02-06"));
        workdays.add(MyDateUtil.parseDate("2022-01-29"));
        workdays.add(MyDateUtil.parseDate("2022-01-30"));
        holidays.add(MyDateUtil.parseDate("2022-04-03"));
        holidays.add(MyDateUtil.parseDate("2022-04-04"));
        holidays.add(MyDateUtil.parseDate("2022-04-05"));
        workdays.add(MyDateUtil.parseDate("2022-04-02"));
        holidays.add(MyDateUtil.parseDate("2022-04-30"));
        holidays.add(MyDateUtil.parseDate("2022-05-01"));
        holidays.add(MyDateUtil.parseDate("2022-05-02"));
        holidays.add(MyDateUtil.parseDate("2022-05-03"));
        holidays.add(MyDateUtil.parseDate("2022-05-04"));
        workdays.add(MyDateUtil.parseDate("2022-04-24"));
        workdays.add(MyDateUtil.parseDate("2022-05-07"));
        holidays.add(MyDateUtil.parseDate("2022-06-03"));
        holidays.add(MyDateUtil.parseDate("2022-06-04"));
        holidays.add(MyDateUtil.parseDate("2022-06-05"));
        holidays.add(MyDateUtil.parseDate("2022-09-10"));
        holidays.add(MyDateUtil.parseDate("2022-09-11"));
        holidays.add(MyDateUtil.parseDate("2022-09-12"));
        holidays.add(MyDateUtil.parseDate("2022-10-01"));
        holidays.add(MyDateUtil.parseDate("2022-10-02"));
        holidays.add(MyDateUtil.parseDate("2022-10-03"));
        holidays.add(MyDateUtil.parseDate("2022-10-04"));
        holidays.add(MyDateUtil.parseDate("2022-10-05"));
        holidays.add(MyDateUtil.parseDate("2022-10-06"));
        holidays.add(MyDateUtil.parseDate("2022-10-07"));
        workdays.add(MyDateUtil.parseDate("2022-10-08"));
        workdays.add(MyDateUtil.parseDate("2022-10-09"));

        holidays.add(MyDateUtil.parseDate("2021-01-01"));
        holidays.add(MyDateUtil.parseDate("2021-01-02"));
        holidays.add(MyDateUtil.parseDate("2021-01-03"));
        holidays.add(MyDateUtil.parseDate("2021-02-11"));
        holidays.add(MyDateUtil.parseDate("2021-02-12"));
        holidays.add(MyDateUtil.parseDate("2021-02-13"));
        holidays.add(MyDateUtil.parseDate("2021-02-14"));
        holidays.add(MyDateUtil.parseDate("2021-02-15"));
        holidays.add(MyDateUtil.parseDate("2021-02-16"));
        holidays.add(MyDateUtil.parseDate("2021-02-17"));
        holidays.add(MyDateUtil.parseDate("2021-04-03"));
        holidays.add(MyDateUtil.parseDate("2021-04-04"));
        holidays.add(MyDateUtil.parseDate("2021-04-05"));
        holidays.add(MyDateUtil.parseDate("2021-05-01"));
        holidays.add(MyDateUtil.parseDate("2021-05-02"));
        holidays.add(MyDateUtil.parseDate("2021-05-03"));
        holidays.add(MyDateUtil.parseDate("2021-05-04"));
        holidays.add(MyDateUtil.parseDate("2021-05-05"));
        holidays.add(MyDateUtil.parseDate("2021-06-12"));
        holidays.add(MyDateUtil.parseDate("2021-06-13"));
        holidays.add(MyDateUtil.parseDate("2021-06-14"));
        holidays.add(MyDateUtil.parseDate("2021-09-19"));
        holidays.add(MyDateUtil.parseDate("2021-09-21"));
        holidays.add(MyDateUtil.parseDate("2021-09-20"));
        holidays.add(MyDateUtil.parseDate("2021-10-01"));
        holidays.add(MyDateUtil.parseDate("2021-10-02"));
        holidays.add(MyDateUtil.parseDate("2021-10-03"));
        holidays.add(MyDateUtil.parseDate("2021-10-04"));
        holidays.add(MyDateUtil.parseDate("2021-10-05"));
        holidays.add(MyDateUtil.parseDate("2021-10-06"));
        holidays.add(MyDateUtil.parseDate("2021-10-07"));
        workdays.add(MyDateUtil.parseDate("2021-02-07"));
        workdays.add(MyDateUtil.parseDate("2021-02-20"));
        workdays.add(MyDateUtil.parseDate("2021-04-25"));
        workdays.add(MyDateUtil.parseDate("2021-05-08"));
        workdays.add(MyDateUtil.parseDate("2021-09-18"));
        workdays.add(MyDateUtil.parseDate("2021-09-26"));
        workdays.add(MyDateUtil.parseDate("2021-10-09"));

        holidays.add(MyDateUtil.parseDate("2020-01-01"));
        holidays.add(MyDateUtil.parseDate("2020-01-24"));
        holidays.add(MyDateUtil.parseDate("2020-01-25"));
        holidays.add(MyDateUtil.parseDate("2020-01-26"));
        holidays.add(MyDateUtil.parseDate("2020-01-27"));
        holidays.add(MyDateUtil.parseDate("2020-01-28"));
        holidays.add(MyDateUtil.parseDate("2020-01-29"));
        holidays.add(MyDateUtil.parseDate("2020-01-30"));
        holidays.add(MyDateUtil.parseDate("2020-01-31"));
        holidays.add(MyDateUtil.parseDate("2020-02-01"));
        holidays.add(MyDateUtil.parseDate("2020-02-02"));
        holidays.add(MyDateUtil.parseDate("2020-04-04"));
        holidays.add(MyDateUtil.parseDate("2020-04-05"));
        holidays.add(MyDateUtil.parseDate("2020-04-06"));
        holidays.add(MyDateUtil.parseDate("2020-05-01"));
        holidays.add(MyDateUtil.parseDate("2020-05-02"));
        holidays.add(MyDateUtil.parseDate("2020-05-03"));
        holidays.add(MyDateUtil.parseDate("2020-05-04"));
        holidays.add(MyDateUtil.parseDate("2020-05-05"));
        holidays.add(MyDateUtil.parseDate("2020-06-25"));
        holidays.add(MyDateUtil.parseDate("2020-06-26"));
        holidays.add(MyDateUtil.parseDate("2020-06-27"));
        holidays.add(MyDateUtil.parseDate("2020-10-01"));
        holidays.add(MyDateUtil.parseDate("2020-10-02"));
        holidays.add(MyDateUtil.parseDate("2020-10-03"));
        holidays.add(MyDateUtil.parseDate("2020-10-04"));
        holidays.add(MyDateUtil.parseDate("2020-10-05"));
        holidays.add(MyDateUtil.parseDate("2020-10-06"));
        holidays.add(MyDateUtil.parseDate("2020-10-07"));
        holidays.add(MyDateUtil.parseDate("2020-10-08"));
        workdays.add(MyDateUtil.parseDate("2020-01-19"));
        workdays.add(MyDateUtil.parseDate("2020-04-26"));
        workdays.add(MyDateUtil.parseDate("2020-05-09"));
        workdays.add(MyDateUtil.parseDate("2020-06-28"));
        workdays.add(MyDateUtil.parseDate("2020-09-27"));
        workdays.add(MyDateUtil.parseDate("2020-10-10"));

        holidays.add(MyDateUtil.parseDate("2019-01-01"));
        holidays.add(MyDateUtil.parseDate("2019-02-04"));
        holidays.add(MyDateUtil.parseDate("2019-02-05"));
        holidays.add(MyDateUtil.parseDate("2019-02-06"));
        holidays.add(MyDateUtil.parseDate("2019-02-07"));
        holidays.add(MyDateUtil.parseDate("2019-02-08"));
        holidays.add(MyDateUtil.parseDate("2019-02-09"));
        holidays.add(MyDateUtil.parseDate("2019-02-10"));
        holidays.add(MyDateUtil.parseDate("2019-04-05"));
        holidays.add(MyDateUtil.parseDate("2019-04-06"));
        holidays.add(MyDateUtil.parseDate("2019-04-07"));
        holidays.add(MyDateUtil.parseDate("2019-05-01"));
        holidays.add(MyDateUtil.parseDate("2019-05-02"));
        holidays.add(MyDateUtil.parseDate("2019-05-03"));
        holidays.add(MyDateUtil.parseDate("2019-05-04"));
        holidays.add(MyDateUtil.parseDate("2019-06-07"));
        holidays.add(MyDateUtil.parseDate("2019-06-08"));
        holidays.add(MyDateUtil.parseDate("2019-06-09"));
        holidays.add(MyDateUtil.parseDate("2019-09-13"));
        holidays.add(MyDateUtil.parseDate("2019-09-14"));
        holidays.add(MyDateUtil.parseDate("2019-09-15"));
        holidays.add(MyDateUtil.parseDate("2019-10-01"));
        holidays.add(MyDateUtil.parseDate("2019-10-02"));
        holidays.add(MyDateUtil.parseDate("2019-10-03"));
        holidays.add(MyDateUtil.parseDate("2019-10-04"));
        holidays.add(MyDateUtil.parseDate("2019-10-05"));
        holidays.add(MyDateUtil.parseDate("2019-10-06"));
        holidays.add(MyDateUtil.parseDate("2019-10-07"));
        workdays.add(MyDateUtil.parseDate("2019-02-02"));
        workdays.add(MyDateUtil.parseDate("2019-02-03"));
        workdays.add(MyDateUtil.parseDate("2019-04-28"));
        workdays.add(MyDateUtil.parseDate("2019-05-05"));
        workdays.add(MyDateUtil.parseDate("2019-09-29"));
        workdays.add(MyDateUtil.parseDate("2019-10-12"));

        holidays.add(MyDateUtil.parseDate("2018-01-01"));
        holidays.add(MyDateUtil.parseDate("2018-02-15"));
        holidays.add(MyDateUtil.parseDate("2018-02-16"));
        holidays.add(MyDateUtil.parseDate("2018-02-17"));
        holidays.add(MyDateUtil.parseDate("2018-02-18"));
        holidays.add(MyDateUtil.parseDate("2018-02-19"));
        holidays.add(MyDateUtil.parseDate("2018-02-20"));
        holidays.add(MyDateUtil.parseDate("2018-02-21"));
        holidays.add(MyDateUtil.parseDate("2018-04-05"));
        holidays.add(MyDateUtil.parseDate("2018-04-06"));
        holidays.add(MyDateUtil.parseDate("2018-04-07"));
        holidays.add(MyDateUtil.parseDate("2018-04-29"));
        holidays.add(MyDateUtil.parseDate("2018-04-30"));
        holidays.add(MyDateUtil.parseDate("2018-05-01"));
        holidays.add(MyDateUtil.parseDate("2018-06-16"));
        holidays.add(MyDateUtil.parseDate("2018-06-17"));
        holidays.add(MyDateUtil.parseDate("2018-06-18"));
        holidays.add(MyDateUtil.parseDate("2018-09-22"));
        holidays.add(MyDateUtil.parseDate("2018-09-23"));
        holidays.add(MyDateUtil.parseDate("2018-09-24"));
        holidays.add(MyDateUtil.parseDate("2018-10-01"));
        holidays.add(MyDateUtil.parseDate("2018-10-02"));
        holidays.add(MyDateUtil.parseDate("2018-10-03"));
        holidays.add(MyDateUtil.parseDate("2018-10-04"));
        holidays.add(MyDateUtil.parseDate("2018-10-05"));
        holidays.add(MyDateUtil.parseDate("2018-10-06"));
        holidays.add(MyDateUtil.parseDate("2018-10-07"));
        workdays.add(MyDateUtil.parseDate("2018-02-11"));
        workdays.add(MyDateUtil.parseDate("2018-02-24"));
        workdays.add(MyDateUtil.parseDate("2018-04-08"));
        workdays.add(MyDateUtil.parseDate("2018-04-28"));
        workdays.add(MyDateUtil.parseDate("2018-09-29"));
        workdays.add(MyDateUtil.parseDate("2018-09-30"));

        holidays.add(MyDateUtil.parseDate("2017-01-01"));
        holidays.add(MyDateUtil.parseDate("2017-01-02"));
        holidays.add(MyDateUtil.parseDate("2017-01-27"));
        holidays.add(MyDateUtil.parseDate("2017-01-28"));
        holidays.add(MyDateUtil.parseDate("2017-01-29"));
        holidays.add(MyDateUtil.parseDate("2017-01-30"));
        holidays.add(MyDateUtil.parseDate("2017-01-31"));
        holidays.add(MyDateUtil.parseDate("2017-02-01"));
        holidays.add(MyDateUtil.parseDate("2017-02-02"));
        holidays.add(MyDateUtil.parseDate("2017-04-02"));
        holidays.add(MyDateUtil.parseDate("2017-04-03"));
        holidays.add(MyDateUtil.parseDate("2017-04-04"));
        holidays.add(MyDateUtil.parseDate("2017-04-29"));
        holidays.add(MyDateUtil.parseDate("2017-04-30"));
        holidays.add(MyDateUtil.parseDate("2017-05-01"));
        holidays.add(MyDateUtil.parseDate("2017-05-28"));
        holidays.add(MyDateUtil.parseDate("2017-05-29"));
        holidays.add(MyDateUtil.parseDate("2017-05-30"));
        holidays.add(MyDateUtil.parseDate("2017-10-01"));
        holidays.add(MyDateUtil.parseDate("2017-10-02"));
        holidays.add(MyDateUtil.parseDate("2017-10-03"));
        holidays.add(MyDateUtil.parseDate("2017-10-04"));
        holidays.add(MyDateUtil.parseDate("2017-10-05"));
        holidays.add(MyDateUtil.parseDate("2017-10-06"));
        holidays.add(MyDateUtil.parseDate("2017-10-07"));
        holidays.add(MyDateUtil.parseDate("2017-10-08"));
        workdays.add(MyDateUtil.parseDate("2017-01-22"));
        workdays.add(MyDateUtil.parseDate("2017-02-04"));
        workdays.add(MyDateUtil.parseDate("2017-04-01"));
        workdays.add(MyDateUtil.parseDate("2017-05-27"));
        workdays.add(MyDateUtil.parseDate("2017-09-30"));

        holidays.add(MyDateUtil.parseDate("2016-01-01"));
        holidays.add(MyDateUtil.parseDate("2016-01-02"));
        holidays.add(MyDateUtil.parseDate("2016-01-03"));
        holidays.add(MyDateUtil.parseDate("2016-02-07"));
        holidays.add(MyDateUtil.parseDate("2016-02-08"));
        holidays.add(MyDateUtil.parseDate("2016-02-09"));
        holidays.add(MyDateUtil.parseDate("2016-02-10"));
        holidays.add(MyDateUtil.parseDate("2016-02-11"));
        holidays.add(MyDateUtil.parseDate("2016-02-12"));
        holidays.add(MyDateUtil.parseDate("2016-02-13"));
        holidays.add(MyDateUtil.parseDate("2016-04-02"));
        holidays.add(MyDateUtil.parseDate("2016-04-03"));
        holidays.add(MyDateUtil.parseDate("2016-04-04"));
        holidays.add(MyDateUtil.parseDate("2016-04-30"));
        holidays.add(MyDateUtil.parseDate("2016-05-01"));
        holidays.add(MyDateUtil.parseDate("2016-05-02"));
        holidays.add(MyDateUtil.parseDate("2016-06-09"));
        holidays.add(MyDateUtil.parseDate("2016-06-10"));
        holidays.add(MyDateUtil.parseDate("2016-06-11"));
        holidays.add(MyDateUtil.parseDate("2016-09-15"));
        holidays.add(MyDateUtil.parseDate("2016-09-16"));
        holidays.add(MyDateUtil.parseDate("2016-09-17"));
        holidays.add(MyDateUtil.parseDate("2016-10-01"));
        holidays.add(MyDateUtil.parseDate("2016-10-02"));
        holidays.add(MyDateUtil.parseDate("2016-10-03"));
        holidays.add(MyDateUtil.parseDate("2016-10-04"));
        holidays.add(MyDateUtil.parseDate("2016-10-05"));
        holidays.add(MyDateUtil.parseDate("2016-10-06"));
        holidays.add(MyDateUtil.parseDate("2016-10-07"));
        workdays.add(MyDateUtil.parseDate("2016-02-06"));
        workdays.add(MyDateUtil.parseDate("2016-02-14"));
        workdays.add(MyDateUtil.parseDate("2016-02-28"));
        workdays.add(MyDateUtil.parseDate("2016-06-12"));
        workdays.add(MyDateUtil.parseDate("2016-09-18"));
        workdays.add(MyDateUtil.parseDate("2016-10-08"));
        workdays.add(MyDateUtil.parseDate("2016-10-09"));

        holidays.add(MyDateUtil.parseDate("2015-01-01"));
        holidays.add(MyDateUtil.parseDate("2015-01-02"));
        holidays.add(MyDateUtil.parseDate("2015-01-03"));
        holidays.add(MyDateUtil.parseDate("2015-02-18"));
        holidays.add(MyDateUtil.parseDate("2015-02-19"));
        holidays.add(MyDateUtil.parseDate("2015-02-20"));
        holidays.add(MyDateUtil.parseDate("2015-02-21"));
        holidays.add(MyDateUtil.parseDate("2015-02-22"));
        holidays.add(MyDateUtil.parseDate("2015-02-23"));
        holidays.add(MyDateUtil.parseDate("2015-02-24"));
        holidays.add(MyDateUtil.parseDate("2015-04-04"));
        holidays.add(MyDateUtil.parseDate("2015-04-05"));
        holidays.add(MyDateUtil.parseDate("2015-04-06"));
        holidays.add(MyDateUtil.parseDate("2015-05-01"));
        holidays.add(MyDateUtil.parseDate("2015-05-02"));
        holidays.add(MyDateUtil.parseDate("2015-05-03"));
        holidays.add(MyDateUtil.parseDate("2015-06-20"));
        holidays.add(MyDateUtil.parseDate("2015-06-21"));
        holidays.add(MyDateUtil.parseDate("2015-06-22"));
        holidays.add(MyDateUtil.parseDate("2015-09-03"));
        holidays.add(MyDateUtil.parseDate("2015-09-04"));
        holidays.add(MyDateUtil.parseDate("2015-09-05"));
        holidays.add(MyDateUtil.parseDate("2015-09-26"));
        holidays.add(MyDateUtil.parseDate("2015-09-27"));
        holidays.add(MyDateUtil.parseDate("2015-10-01"));
        holidays.add(MyDateUtil.parseDate("2015-10-02"));
        holidays.add(MyDateUtil.parseDate("2015-10-03"));
        holidays.add(MyDateUtil.parseDate("2015-10-04"));
        holidays.add(MyDateUtil.parseDate("2015-10-05"));
        holidays.add(MyDateUtil.parseDate("2015-10-06"));
        holidays.add(MyDateUtil.parseDate("2015-10-07"));
        workdays.add(MyDateUtil.parseDate("2015-01-04"));
        workdays.add(MyDateUtil.parseDate("2015-02-15"));
        workdays.add(MyDateUtil.parseDate("2015-02-28"));
        workdays.add(MyDateUtil.parseDate("2015-09-06"));
        workdays.add(MyDateUtil.parseDate("2015-10-10"));

        MyDateUtil.workdayConfig().setWorkdays(workdays);
        MyDateUtil.workdayConfig().setHolidays(holidays);
    }
}
荪慕彰
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java 实现将每年的节假日，周末，工作日详情记录至数据库表中
01-18
Java 实现将每年的节假日，周末，工作日详情记录至数据库表中 包括每年每天是否为工作日，充分考虑周末，节假日情况，亲测可用
获取今年的所有法定节假日
猪头泽兜兜的
07-11 1265
基于HuTool工具类时间工具类，获取今年的所有法定节假日。
节假日判断工具（Java）
Kanen001的博客
05-20 7649
由来 节假日判断工具类：大厂接口要收费，小长接口怕不稳定，索性自己写一个吧。 软件架构 spring boot,jdk1.8 原理：通过文本文件，维护每一年的假节日和调休日期。示例见/years/2022.txt当国务院发布新一年的节假日规划后维护到该目录下。维护还是比较简单的，三五分钟即可完成。 核心代码逻辑 判断某一天是否为工作日： 1、如果为法定节假日：false 2、如果为法定调休日：true 3、如果为周末：false，否则true 代码 package com.hanmanyi.util; i
Java判断节假日（包含周末）工具类
最新发布
qq_38258824的博客
03-19 767
{year}）写一个工具类。这里的{year}传一个年份进去即可查询本年度所有的法定节假日，如：https://timor.tech/api/holiday/year/2024就是查询2024年度所有法定节假日。判断是否周末很简单，但是法定节假日怎么办呢？最后调用这个工具类，只需判断是否为"0"，这里借助一个开源的网站（可以在浏览器上访问试一下。
【Java获取国家法定节假日三种工具类其三】
m0_46475664的博客
04-13 3885
通过调用第三方接口维护国家法定节假日库，这样维护方便，三种方法相互补充，当然也可以再次整合成一个更加便捷的方法。
【Java获取国家法定节假日三种工具类其二】
m0_46475664的博客
04-13 1260
第二种方法对于国家法定节假日维护更加方便便捷，与上一篇相比缺点还是节假日靠自己维护，后期实用稍微有点麻烦
java方法 判断今天是工作日/周末/节假日
weixin_46871290的博客
10-24 5348
判断今天是工作日/周末/节假日
Java获取节假日信息工具类
weixin_39093006的博客
07-04 1278
package *; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set;
Java节假日工具类-配置中心维护数据
不吃肥肉的傲寒
01-28 676
【代码】Java节假日工具类-配置中心维护数据。
节假日工具类
万里顾一程的博客
03-15 1265
节假日工具类 当前项目有个需求：合作伙伴下采购订单，我们把货品放入仓库，如果伙伴选择的提货方式是自提，经过5工作日后，如果合作伙伴没有自提，我们需要提醒合作伙伴来仓库提货，如果七个工作日后，合作伙伴还没有自提，就把伙伴下单的货品状态变更为报废。 原来项目中有判断节假日的方法，但节假日API已经过期，因此重新在网上找了个API。 但找到的API不稳定，有时会需要六七秒钟，所以把节假日存到数据库中，由自己维护，下次需要查询只要从数据库查就行。 添加节假日的定时任务一年执行一次即可。 判断是否是节假日及获取指定几
工作日工具类.java
06-13
使用Java语言进行计算除去周六周日日期、节日假期的应该工作的工作日日数！项目实战中写的，里面有很详细的注释，不用担心看不懂！
java自动生成节假日对照表
05-21
中国的节假日不是按照阳历就能够计算,在没有调接口的情况下,最好的办法就是在数据库里面维护相对应的对照表.这里就提供了一个工具类自动生成指定年份的节假日对照表
Java节假日算法(免费)
03-16
Java节假日算法(免费)
java计算全年周日 及过滤法定节假日
02-23
java代码先获取全年的周末周日，定义全年的法定节假日，然后根据输入的日期计算，当前日期后的工作日，也可以用于计算工作日
java计算整年工作日(包含特殊的工作日)排除法定节假日和周末能运行
01-17
java计算整年工作日(包含特殊的工作日)排除法定节假日和周末能运行
Java实现的获取和判断文件头信息工具类用法示例
08-28
主要介绍了Java实现的获取和判断文件头信息工具类,结合实例形式分析了Java针对文件读取及头信息判断相关操作技巧,需要的朋友可以参考下
Java service层获取HttpServletRequest工具类的方法
08-26
今天小编就为大家分享一篇关于Java service层获取HttpServletRequest工具类的方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
java util ：获取国家省份城市工具类-附件资源
03-05
java util ：获取国家省份城市工具类-附件资源
java工具类之实现java获取文件行数
09-04
主要介绍了一个java工具类,可以取得当前项目中所有java文件总行数，代码行数，注释行数，空白行数,需要的朋友可以参考下
java获取工作日工具类
05-12
Java获取工作日工具类主要用于计算给定时间段内的有效工作日天数，排除掉周末和节假日等非工作日。这对于企业的工作日管理、考勤统计等方面具有重要意义。 要实现这个工具类，首先需要定义一个日期计算方法，该方法可以根据具体的日期范围，计算包含的有效工作日数量。具体实现可以采用Java 8 Stream API，利用LocalDate的方法，筛选掉非工作日，并统计工作日数量。 其次，需要定义一个节假日管理方法，该方法需要记录各种法定节假日和公司内部的假日安排。例如，在中国，法定节假日包括春节、清明节、劳动节等，而公司内部可能会安排年会、团建等假期。该管理方法可以利用Map等数据结构实现，将节假日的日期和类型以键值对的形式存储。 最后，根据以上两个方法，构建主工具类，该类的主要功能是根据指定的日期范围和节假日管理信息，计算出其中的有效工作日数量。由于不同国家和地区可能有不同的法定节假日和假日安排，因此，在编写工具类时需要考虑到相关的地域因素，以满足不同用户的需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值