JAVA判断当前时间是否为节假日、周末、工作日，调休日，不报错:IOException！

JAVA判断当前时间是否为节假日、周末、工作日

需求

有这么个需求，需要判断传的这个日期是否为节假日，周末，工作日，然后做剩下的操作。

话不多说，上代码

1.首先需要拿到节假日api

节假日API地址

• 其实这个api里有接口可以直接判断某天是否为周末，节假日，工作日；
• 但是这个接口访问多了会报一个403的错误，也就是请求太多导致的；
• 而我下面的内容是只请求一次全年节假日即可，放到一个集合里，第二次请求判断的时候就可以直接去集合里判断。速度很快！

  2.拿到自己适用接口，如下:

  参数：

  1》year：格式“yyyy”,查询这一年的节假日

  https://timor.tech/api/holiday/year
  

  返回数据示例：

  {
      "code": 0,
      "holiday": {
          "01-01": {
              "holiday": true,
              "name": "元旦",
              "wage": 3,
              "date": "2023-01-01",
              "rest": 1
          },
          "01-02": {
              "holiday": true,
              "name": "元旦",
              "wage": 2,
              "date": "2023-01-02",
              "rest": 1
          },
          "01-21": {
              "holiday": true,
              "name": "除夕",
              "wage": 3,
              "date": "2023-01-21",
              "rest": 2
          },
          ..........
  

  截图如下

  

  3.拿到项目中，编写成一个HolidayUtil 工具类，代码如下：

  /**
   * 判断今天是工作日/周末/节假日 工具类
   * //0 上班 1周末 2节假日
   */
  public class HolidayUtil {
      static Map> holiday =new HashMap<>();//假期
      static Map> extraWorkDay =new HashMap<>();//调休日
      //判断是否为节假日
      /**
       *
       * @param time 日期参数 格式‘yyyy-MM-dd’，不传参则默认当前日期
       * @return
       */
      public static String isWorkingDay(String time) throws ParseException {
          Date parse = null;
          //为空则返回当前时间
          if (StringUtils.isNotBlank(time)){
              SimpleDateFormat getYearFormat = new SimpleDateFormat("yyyy-MM-dd");
              parse = getYearFormat.parse(time);
          }else {
              parse = new Date();
          }
          String newDate  = new SimpleDateFormat("yyyy").format(parse);
          //判断key是否有参数年份
          if(!holiday.containsKey(newDate)){
               String holiday = getYearHoliday(newDate);
              if ("No!".equals(holiday)){
                  return "该年份未分配日期安排！";
              }
          }
          //得到日期是星期几
          Date date = DateUtil.formatStringToDate(time, false);
          Calendar calendar = Calendar.getInstance();
          calendar.setTime(date);
          int weekday = DateUtil.getDayOfWeek(calendar);
          //是否节假日
          if(holiday.get(newDate).contains(time)){
              return "2";
          }else if(extraWorkDay.get(newDate).contains(time)){//是否为调休
              return "0";
          }else if(weekday == Calendar.SATURDAY || weekday == Calendar.FRIDAY){//是否为周末
              return "1";
          }else{
              return "0";
          }
      }
      /**
       *
       * @param date 日期参数 格式‘yyyy’，不传参则默认当前日期
       * @return
       */
      public static String getYearHoliday(String date) throws ParseException {
          //获取免费api地址
          String httpUrl="https://timor.tech/api/holiday/year/"+date;
          BufferedReader reader = null;
          String result = null;
          StringBuffer sbf = new StringBuffer();
          try {
              URL url = new URL(httpUrl);
              URLConnection connection = url.openConnection();
              //connection.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
              connection.setRequestProperty("User-Agent", "Mozilla/4.76");
              //使用Get方式请求数据
              //connection.setRequestMethod("GET");
              //connection.connect();
              InputStream is = connection.getInputStream();
              reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
              String strRead = null;
              while ((strRead = reader.readLine()) != null) {
                  sbf.append(strRead);
                  sbf.append("\r\n");
              }
              reader.close();
              //字符串转json
              JSONObject json = JSON.parseObject(sbf.toString());
              //根据holiday字段获取jsonObject内容
              JSONObject holiday = json.getJSONObject("holiday");
              if (holiday.size() == 0){
                  return "No!";
              }
              List hoList = new ArrayList<>();
              List extraList = new ArrayList<>();
              for (Map.Entry entry : holiday.entrySet()) {
                  String value = entry.getValue().toString();
                  JSONObject jsonObject = JSONObject.parseObject(value);
                  String hoBool = jsonObject.getString("holiday");
                  String extra = jsonObject.getString("date");
                  //判断不是假期后调休的班
                  if(hoBool.equals("true")){
                      hoList.add(extra);
                      HolidayUtil.holiday.put(date,hoList);
                  }else {
                      extraList.add(extra);
                      HolidayUtil.extraWorkDay.put(date,extraList);
                  }
              }
          } catch (Exception e) {
              e.printStackTrace();
          }
          return result;
      }
  }
  

  DateUtil工具类，这里写了很多，可以把不需要的删除掉

  /**
   * 日期工具
   */
  public class DateUtil {
      /**
       * 输出当天的时间，格式如：20151207
       *
       * @return
       */
      public static String today() {
          SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
          return format.format(new Date());
      }
      /**
       * 当前时间
       * @return
       */
      public static String currTime() {
          SimpleDateFormat sdfDetail = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          Date date = new Date();
          return sdfDetail.format(date);
      }
      /**
       * 当前年
       * @return
       */
      public static String currYear() {
          SimpleDateFormat sdfDetail = new SimpleDateFormat("yyyy");
          Date date = new Date();
          return sdfDetail.format(date);
      }
      public static String format(Date date, String tpl) {
          SimpleDateFormat format = new SimpleDateFormat(tpl);
          return format.format(date);
      }
      /**
       * 任意一天的开始时间
       *
       * @return date
       */
      public static Date startOfDay(Date date) {
          Calendar calendar = Calendar.getInstance();
          calendar.setTime(date);
          calendar.set(Calendar.HOUR_OF_DAY, 0);
          calendar.set(Calendar.MINUTE, 0);
          calendar.set(Calendar.SECOND, 0);
          calendar.set(Calendar.MILLISECOND, 0);
          Date returnDate = calendar.getTime();
          return returnDate;
      }
      /**
       * 任意一天的结束时间
       *
       * @return date
       */
      public static Date endOfDay(Date date) {
          Calendar calendar = Calendar.getInstance();
          calendar.setTime(date);
          calendar.set(Calendar.HOUR_OF_DAY, 23);
          calendar.set(Calendar.MINUTE, 59);
          calendar.set(Calendar.SECOND, 59);
          calendar.set(Calendar.MILLISECOND, 999);
          Date returnDate = calendar.getTime();
          return returnDate;
      }
      /**
       * 获取时间戳的开始时间
       * @param timestamp
       */
      public static Long startOfDayByTimestamp(Long timestamp) {
          Date date = new Date(timestamp);
          return startOfDay(date).getTime();
      }
      /**
       * 获取时间戳的结束时间
       * zg
       * @param timestamp
       */
      public static Long endOfDayByTimestamp(Long timestamp) {
          Date date = new Date(timestamp);
          return endOfDay(date).getTime();
      }
      /**
       * 当天的开始时间
       *
       * @return
       */
      public static Date startOfTodDay() {
          Calendar calendar = Calendar.getInstance();
          calendar.set(Calendar.HOUR_OF_DAY, 0);
          calendar.set(Calendar.MINUTE, 0);
          calendar.set(Calendar.SECOND, 0);
          calendar.set(Calendar.MILLISECOND, 0);
          Date date = calendar.getTime();
          return date;
      }
      /**
       * 当天的结束时间
       *
       * @return
       */
      public static Date endOfTodDay() {
          Calendar calendar = Calendar.getInstance();
          calendar.set(Calendar.HOUR_OF_DAY, 23);
          calendar.set(Calendar.MINUTE, 59);
          calendar.set(Calendar.SECOND, 59);
          calendar.set(Calendar.MILLISECOND, 999);
          Date date = calendar.getTime();
          return date;
      }
      /**
       * 昨天的开始时间
       *
       * @return
       */
      public static Date startOfyesterday() {
          Calendar calendar = Calendar.getInstance();
          calendar.set(Calendar.HOUR_OF_DAY, 0);
          calendar.set(Calendar.MINUTE, 0);
          calendar.set(Calendar.SECOND, 0);
          calendar.add(Calendar.DATE, -1);
          calendar.set(Calendar.MILLISECOND, 0);
          Date date = calendar.getTime();
          return date;
      }
      /**
       * 昨天的结束时间
       *
       * @return
       */
      public static Date endOfyesterday() {
          Calendar calendar = Calendar.getInstance();
          calendar.set(Calendar.HOUR_OF_DAY, 23);
          calendar.set(Calendar.MINUTE, 59);
          calendar.set(Calendar.SECOND, 59);
          calendar.set(Calendar.MILLISECOND, 999);
          calendar.add(Calendar.DATE, -1);
          Date date = calendar.getTime();
          return date;
      }
      /**
       * 功能：获取本周的开始时间 示例：2013-05-13 00:00:00
       */
      public static Date startOfThisWeek() {// 当周开始时间
          Calendar currentDate = Calendar.getInstance();
          currentDate.setFirstDayOfWeek(Calendar.MONDAY);
          currentDate.set(Calendar.HOUR_OF_DAY, 0);
          currentDate.set(Calendar.MINUTE, 0);
          currentDate.set(Calendar.SECOND, 0);
          currentDate.set(Calendar.MILLISECOND, 0);
          currentDate.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
          Date date = currentDate.getTime();
          return date;
      }
      /**
       * 功能：获取String日期对应的时间戳
       * format 格式自定
       *
       * @return
       */
      public static Long formatStringToStamp(String base, String format) {
          DateFormat df = new SimpleDateFormat(format);
          Date baseTime;
          Long stamp = null;
          try {
              baseTime = df.parse(base);
              stamp = baseTime.getTime();
          } catch (Exception e) {
              return null;
          }
          return stamp;
      }
      /**
       * 功能：获取String日期对应的时间
       * isTotal = false ;yyyy-MM-dd格式限定
       * isTotal = true ;yyyy-MM-dd hh-mm-ss格式限定
       */
      public static Date formatStringToDate(String base, Boolean isTotal) {
          String format = isTotal ? "yyyy-MM-dd hh-mm-ss" : "yyyy-MM-dd";
          DateFormat df = new SimpleDateFormat(format);
          Date baseTime;
          try {
              baseTime = df.parse(base);
          } catch (Exception e) {
              return null;
          }
          return baseTime;
      }
      /**
       * 功能：获取本周的结束时间 示例：2013-05-19 23:59:59
       */
      public static Date endOfThisWeek() {// 当周结束时间
          Calendar currentDate = Calendar.getInstance();
          currentDate.setFirstDayOfWeek(Calendar.MONDAY);
          currentDate.set(Calendar.HOUR_OF_DAY, 23);
          currentDate.set(Calendar.MINUTE, 59);
          currentDate.set(Calendar.SECOND, 59);
          currentDate.set(Calendar.MILLISECOND, 999);
          currentDate.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
          Date date = currentDate.getTime();
          return date;
      }
      /**
       * 功能：获取本月的开始时间
       */
      public static Date startOfThisMonth() {// 当周开始时间
          Calendar currentDate = Calendar.getInstance();
          currentDate.set(Calendar.HOUR_OF_DAY, 0);
          currentDate.set(Calendar.MINUTE, 0);
          currentDate.set(Calendar.SECOND, 0);
          currentDate.set(Calendar.MILLISECOND, 0);
          currentDate.set(Calendar.DAY_OF_MONTH, 1);
          Date date = currentDate.getTime();
          return date;
      }
      public static Date endOfThisMonth() {
          Calendar cal = Calendar.getInstance();
          cal.set(Calendar.DAY_OF_MONTH, 1);
          cal.set(Calendar.HOUR_OF_DAY, 23);
          cal.set(Calendar.MINUTE, 59);
          cal.set(Calendar.SECOND, 59);
          cal.set(Calendar.MILLISECOND, 999);
          cal.add(Calendar.MONTH, 1);
          cal.add(Calendar.DATE, -1);
          Date date = cal.getTime();
          return date;
      }
      /**
       * 功能：获取上月的开始时间
       */
      public static Date startOfLastMonth() {// 当周开始时间
          Calendar currentDate = Calendar.getInstance();
          currentDate.set(Calendar.HOUR_OF_DAY, 0);
          currentDate.set(Calendar.MINUTE, 0);
          currentDate.set(Calendar.SECOND, 0);
          currentDate.set(Calendar.MILLISECOND, 0);
          currentDate.set(Calendar.DAY_OF_MONTH, 1);
          currentDate.add(Calendar.MONTH, -1);
          Date date = currentDate.getTime();
          return date;
      }
      /**
       * 功能：获取上月的结束时间
       */
      public static Date endOfLastMonth() {
          Calendar cal = Calendar.getInstance();
          cal.set(Calendar.DAY_OF_MONTH, 1);
          cal.set(Calendar.HOUR_OF_DAY, 23);
          cal.set(Calendar.MINUTE, 59);
          cal.set(Calendar.SECOND, 59);
          cal.set(Calendar.MILLISECOND, 999);
          cal.add(Calendar.DATE, -1);
          Date date = cal.getTime();
          return date;
      }
      private static final int[] DAY_OF_MONTH = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
      public static final String[] DATE_FORMATS = new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM-dd",
              "yyyy-MM", "yyyy-MM-dd HH:mm:ss.S", "yyyy年MM月dd日", "yyyy年MM月dd日 HH:mm", "yyyyMMdd", "yyyy年MM月dd日 HH:mm:ss",
              "MM.dd"};
      /**
       * 将传入的日期转化为"yyyy-MM-dd"形式的字符串
       *
       * @param dt 日期
       * @return 指定日期格式的字符串
       */
      public static String formatDate(Date dt) {
          return formatDate("yyyy-MM-dd", dt);
      }
      /**
       * 将传入的日期转化为"yyyy-MM-dd HH:mm:ss"形式的字符串
       *
       * @param dt 日期
       * @return 指定日期格式的字符串
       */
      public static String formatDateYMDHMS(Date dt) {
          return formatDate("yyyy-MM-dd HH:mm:ss", dt);
      }
      /**
       * 将传入的日期转化为"yyyy-MM-dd HH:mm"形式的字符串
       *
       * @param dt 日期
       * @return 指定日期格式的字符串
       */
      public static String formatDateYMDHM(Date dt) {
          return formatDate("yyyy-MM-dd HH:mm", dt);
      }
      /**
       * 将传入的日期以指定格式转成字符串
       *
       * @param format
       * @param dt
       * @return
       */
      public static String formatDate(String format, Date dt) {
          if (dt == null) {
              return "";
          }
          if (format.isEmpty()) {
              format = "yyyy-MM-dd";
          }
          SimpleDateFormat fmt = new SimpleDateFormat(format);
          return fmt.format(dt);
      }
      /**
       * 将日期字符串转为日期
       *
       * @param dateStr 日期字符串
       * @return
       */
      public static Date parseDate(String dateStr) {
          return parseDate(dateStr, DATE_FORMATS);
      }
      /**
       * 将日期字符串转为指定格式的日期
       *
       * @param dateStr 日期字符串
       * @param format  日期格式
       * @return
       */
      public static Date parseDate(String dateStr, String format) {
          return parseDate(dateStr, new String[]{format});
      }
      private static Date parseDate(String dateStr, String[] parsePatterns) {
          try {
              return DateUtils.parseDate(dateStr, parsePatterns);
          } catch (ParseException e) {
              e.printStackTrace();
              return null;
          }
      }
      /**
       * 获取今天的日期
       *
       * @return
       */
      public static Date getToday() {
          Calendar cal = Calendar.getInstance();
          cal.set(Calendar.HOUR_OF_DAY, 0);
          cal.set(Calendar.MINUTE, 0);
          cal.set(Calendar.SECOND, 0);
          cal.set(Calendar.MILLISECOND, 0);
          return cal.getTime();
      }
      /**
       * 得到传入日期n天后的日期,如果传入日期为null，则表示当前日期n天后的日期
       *
       * @param  dt 日期
       * @param days 可以为任何整数，负数表示前days天，正数表示后days天
       * @return Date
       */
      public static Date getAddDayDate(Date dt, int days) {
          Calendar cal = Calendar.getInstance();
          if (dt != null) {
              cal.setTime(dt);
          }
          cal.add(Calendar.DAY_OF_MONTH, days);
          return cal.getTime();
      }
      /**
       * 得到当前日期几天后（plusDays>0）or 几天前（plusDays<0）的指定格式的字符串日期
       *
       * @param dt
       * @param plusDays
       * @param dateFormat
       * @return
       */
      public static String getAddDayDateFromToday(int plusDays, String dateFormat) {
          Calendar cal = Calendar.getInstance();
          cal.add(Calendar.DAY_OF_MONTH, plusDays);
          return formatDate(dateFormat, cal.getTime());
      }
      /**
       * 给定的时间再加上指定小时数,如果传入日期为null，能以当前时间计算
       *
       * @param dt
       * @param hours
       * @return
       * @author Alex Zhang
       */
      public static Date getAddHourDate(Date dt, int hours) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          cal.add(Calendar.HOUR, hours);
          return cal.getTime();
      }
      /**
       * 给定的时间再加上指定分钟数
       *
       * @param dt
       * @param minutes
       * @return
       */
      public static Date getAddMinuteDate(Date dt, int minutes) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          cal.add(Calendar.MINUTE, minutes);
          return cal.getTime();
      }
      /**
       * 给定的时间再加上指定月份数
       *
       * @param dt
       * @param months
       * @return
       */
      public static Date getAddMonthDate(Date dt, int months) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          cal.add(Calendar.MONTH, months);
          return cal.getTime();
      }
      /**
       * 给定的时间再加上指定年
       * @param dt
       * @param year
       * @return
       */
      public static Date getAddYearDate(Date dt, int year) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          cal.add(Calendar.YEAR, year);
          return cal.getTime();
      }
      /**
       * 获得某天的零点时刻0:0:0
       *
       * @param date 日期
       * @return
       */
      public static Date getDayBegin(Date date) {
          if (date == null)
              return null;
          Calendar cal = Calendar.getInstance();
          cal.setTime(date);
          cal.set(Calendar.HOUR_OF_DAY, 0);
          cal.set(Calendar.MINUTE, 0);
          cal.set(Calendar.SECOND, 0);
          cal.set(Calendar.MILLISECOND, 0);
          return cal.getTime();
      }
      /**
       * 获得某天的截至时刻23:59:59
       *
       * @param date
       * @return
       */
      public static Date getDayEnd(Date date) {
          if (date == null)
              return null;
          Calendar cal = Calendar.getInstance();
          cal.setTime(date);
          cal.set(Calendar.HOUR_OF_DAY, 23);
          cal.set(Calendar.MINUTE, 59);
          cal.set(Calendar.SECOND, 59);
          cal.set(Calendar.MILLISECOND, 999);
          return cal.getTime();
      }
      /**
       * 某月的起始时间,eg：param:2011-11-10 12:10:50.999, return：2011-11-1 00:00:00.000
       */
      public static Date getMonthBeginTime(Date dt) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          cal.set(Calendar.DAY_OF_MONTH, 1);
          cal.set(Calendar.HOUR_OF_DAY, 0);
          cal.set(Calendar.MINUTE, 0);
          cal.set(Calendar.SECOND, 0);
          cal.set(Calendar.MILLISECOND, 0);
          return cal.getTime();
      }
      /**
       * 某月的截止时间,eg：param:2011-11-10 12:10:50.999, return：2011-11-30 23:59:59.999
       */
      public static Date getMonthEndTime(Date dt) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
          cal.set(Calendar.DAY_OF_MONTH, 1);
          cal.set(Calendar.HOUR_OF_DAY, 0);
          cal.set(Calendar.MINUTE, 0);
          cal.set(Calendar.SECOND, 0);
          cal.set(Calendar.MILLISECOND, -1);
          return cal.getTime();
      }
      /**
       * 获得传入日期的年\月\日,以整型数组方式返回
       *
       * @param dt
       * @return int[]
       */
      public static int[] getTimeArray(Date dt) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          int[] timeArray = new int[3];
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          timeArray[0] = cal.get(Calendar.YEAR);
          timeArray[1] = cal.get(Calendar.MONTH) + 1;
          timeArray[2] = cal.get(Calendar.DAY_OF_MONTH);
          return timeArray;
      }
      /**
       * 获得传入日期的年\月\日\小时\分,以整型数组方式返回
       *
       * @param dt
       * @return
       */
      public static int[] timeArray(Date dt) {
          if (dt == null)
              dt = new Date(System.currentTimeMillis());
          int[] timeArray = new int[5];
          Calendar cal = Calendar.getInstance();
          cal.setTime(dt);
          timeArray[0] = cal.get(Calendar.YEAR);
          timeArray[1] = cal.get(Calendar.MONTH) + 1;
          timeArray[2] = cal.get(Calendar.DAY_OF_MONTH);
          timeArray[3] = cal.get(Calendar.HOUR_OF_DAY);
          timeArray[4] = cal.get(Calendar.MINUTE);
          return timeArray;
      }
      /**
       * 根据年月日得到Date类型时间
       *
       * @param year
       * @param month
       * @param day
       * @return Date
       */
      public static Date getTime(Integer year, Integer month, Integer day) {
          Calendar cal = Calendar.getInstance();
          if (year != null)
              cal.set(Calendar.YEAR, year);
          if (month != null)
              cal.set(Calendar.MONTH, month - 1);
          if (day != null)
              cal.set(Calendar.DAY_OF_MONTH, day);
          return cal.getTime();
      }
      /**
       * @param parrern 格式化字符串 例如：yyyy-MM-dd
       * @param str     时间字符串 例如：2007-08-01
       * @return 出错返回null
       * 通过格式化字符串得到时间
       */
      public static Date getDateFromPattern(String parrern, String str) {
          SimpleDateFormat fmt = new SimpleDateFormat(parrern);
          try {
              return fmt.parse(str);
          } catch (ParseException e) {
              e.printStackTrace();
          }
          return null;
      }
      /**
       * 计算两个日期间相隔的小时
       *
       * @param d1 日期1
       * @param d2 日期2
       * @return
       */
      public static int getHourBetween(Date d1, Date d2) {
          long m = d1.getTime();
          long n = d2.getTime();
          return (int) ((m - n) / 3600000);
      }
      /**
       * 取得两个时间之间的天数，可能是负数(第二个时间的日期小于第一个时间的日期)。如果两个时间在同一天，则返回0
       *
       * @param d1 第一个时间
       * @param d2 第二个时间
       * @return
       * @author Derek
       * @version 1.0 2009-10-14
       */
      public static int getDayBetween(Date d1, Date d2) {
          Calendar c1 = Calendar.getInstance();
          c1.setTime(d1);
          Calendar c2 = Calendar.getInstance();
          c2.setTime(d2);
          return (int) ((c2.getTimeInMillis() - c1.getTimeInMillis()) / 86400000);
      }
      /**
       * 计算两个日期间相隔的秒数
       *
       * @param d1 日期1
       * @param d2 日期2
       * @return
       */
      public static long getSecondBetweem(Date d1, Date d2) {
          return (d1.getTime() - d2.getTime()) / 1000;
      }
      /**
       * 计算两个日期间相隔的月份数
       *
       * @param d1 日期1
       * @param d2 日期2
       * @return
       */
      public static int getMonthBetween(Date d1, Date d2) {
          Calendar c1 = Calendar.getInstance();
          Calendar c2 = Calendar.getInstance();
          c1.setTime(d1);
          c2.setTime(d2);
          return (c1.get(Calendar.YEAR) - c2.get(Calendar.YEAR)) * 12 + (c1.get(Calendar.MONTH) - c2.get(Calendar.MONTH));
      }
      /**
       * 通过生日得到当前年龄
       *
       * @param birthDay 以字符串表示的生日
       * @return 返回以以字符串表示的年龄, 最小为0
       */
      public static String getAge(String birthDay) {
          if (birthDay.startsWith("0000")) {
              return "未知";
          }
          if (!birthDay.matches("[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}")) {
              return "未知";
          }
          return getAge(parseDate(birthDay, "yyyy-MM-dd"));
      }
      /**
       * 通过生日得到当前年龄
       *
       * @param birthDate 以日期表示的生日
       * @return 返回以以字符串表示的年龄, 最小为0
       */
      public static String getAge(Date birthDate) {
          if (birthDate == null) {
              return "未知";
          }
          Calendar cal = Calendar.getInstance();
          if (cal.before(birthDate)) {
              throw new IllegalArgumentException("The birthDay is before Now. It is unbelievable!");
          }
          int yearNow = cal.get(Calendar.YEAR);
          int monthNow = cal.get(Calendar.MONTH);
          int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH);
          cal.setTime(birthDate);
          int yearBirth = cal.get(Calendar.YEAR);
          int monthBirth = cal.get(Calendar.MONTH);
          int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH);
          int age = yearNow - yearBirth;
          if (monthNow <= monthBirth) {
              if (monthNow == monthBirth) {
                  if (dayOfMonthNow < dayOfMonthBirth) {
                      age--;
                  } else {
                  }
              } else {
                  age--;
              }
          } else {
          }
          return age + "";
      }
      @SuppressWarnings("deprecation")
      public static int getIntAge(Date brithday) {
          if (brithday != null) {
              int dateMiss = Calendar.getInstance().getTime().getDate() - brithday.getDate();// 日差距
              int monthMiss = Calendar.getInstance().getTime().getMonth() - brithday.getMonth();// 月份差距
              int yearMiss = Calendar.getInstance().getTime().getYear() - brithday.getYear();// 年份差距
              if (monthMiss > 0 || (monthMiss == 0 && dateMiss >= 0)) {
                  return yearMiss;
              } else {
                  return yearMiss - 1;// 周岁少两岁，SO在去掉一年
              }
          }
          return 0;
      }
      /**
       * 根据周几的数字标记获得周几的汉字描述
       */
      public static String getCnWeekDesc(int weekNum) {
          String strWeek = "";
          switch (weekNum) {
              case 1:
                  strWeek = "周一";
                  break;
              case 2:
                  strWeek = "周二";
                  break;
              case 3:
                  strWeek = "周三";
                  break;
              case 4:
                  strWeek = "周四";
                  break;
              case 5:
                  strWeek = "周五";
                  break;
              case 6:
                  strWeek = "周六";
                  break;
              case 7:
                  strWeek = "周日";
                  break;
          }
          return strWeek;
      }
      /**
       * 获得"上下午"标识
       *
       * @param date
       * @return
       */
      public static String getCnAMPM(Date date) {
          Calendar cal = Calendar.getInstance();
          cal.setTime(date);
          if (Calendar.AM == cal.get(Calendar.AM_PM))
              return "上午";
          else
              return "下午";
      }
      /**
       * 判断两个日期是否相等
       *
       * @param d1 日期1
       * @param d2 日期2
       * @return
       */
      public static boolean isTimeEquals(Date d1, Date d2) {
          if (d1 == null || d2 == null)
              return false;
          return Math.abs(d1.getTime() - d2.getTime()) < 50;
      }
      /**
       * 获取一个日期的年份
       *
       * @param date 日期
       * @return
       */
      public static int getYear(Date date) {
          Calendar cal = Calendar.getInstance();
          cal.setTime(date);
          return cal.get(Calendar.YEAR);
      }
      /**
       * 获取一个日期的月份
       *
       * @param date 日期
       * @return
       */
      public static int getMonthOfYear(Date date) {
          Calendar cal = Calendar.getInstance();
          cal.setTime(date);
          return cal.get(Calendar.MONTH);
      }
      /**
       * 获取一个日期的天数
       *
       * @param date
       * @return
       */
      public static int getDay(Date date) {
          Calendar calendar = Calendar.getInstance();
          calendar.setTime(date);
          return calendar.get(Calendar.DAY_OF_MONTH);
      }
      /**
       * 获取一个日期的小时数
       *
       * @param date
       * @return
       */
      public static int getHour(Date date) {
          Calendar calendar = Calendar.getInstance();
          calendar.setTime(date);
          return calendar.get(Calendar.HOUR_OF_DAY);
      }
      /**
       * 获取一个日期的分钟
       *
       * @param date 日期
       * @return
       */
      public static int getMinute(Date date) {
          Calendar calendar = Calendar.getInstance();
          calendar.setTime(date);
          return calendar.get(Calendar.MINUTE);
      }
      /**
       * 获取一个日期的秒数
       *
       * @param date 日期
       * @return
       */
      public static int getSecond(Date date) {
          Calendar calendar = Calendar.getInstance();
          calendar.setTime(date);
          return calendar.get(Calendar.SECOND);
      }
      /**
       * 获取一个月的最大天数
       *
       * @param year  年份
       * @param month 月份
       * @return
       */
      public static int getMaxDayOfMonth(int year, int month) {
          if (month == 1 && isLeapYear(year)) {
              return 29;
          }
          return DAY_OF_MONTH[month];
      }
      /**
       * 判断是否是润年
       *
       * @param year 年份
       * @return
       */
      public static boolean isLeapYear(int year) {
          Calendar calendar = Calendar.getInstance();
          return ((GregorianCalendar) calendar).isLeapYear(year);
      }
      /**
       * 得到本周的起始时间
       *
       * @param currentDate
       * @return
       */
      public static Date getBeginDateofThisWeek(Date currentDate) {
          Calendar current = Calendar.getInstance();
          current.setTime(currentDate);
          int dayOfWeek = current.get(Calendar.DAY_OF_WEEK);
          if (dayOfWeek == 1) { // 如果是星期天，星期一则往前退6天
              current.add(Calendar.DAY_OF_MONTH, -6);
          } else {
              current.add(Calendar.DAY_OF_MONTH, 2 - dayOfWeek);
          }
          current.set(Calendar.HOUR_OF_DAY, 0);
          current.set(Calendar.MINUTE, 0);
          current.set(Calendar.SECOND, 0);
          current.set(Calendar.MILLISECOND, 0);
          return current.getTime();
      }
      @SuppressWarnings("deprecation")
      public static void main(String[] args) {
          Date addYearDate = getAddYearDate(new Date(), 2);
          System.out.println(formatDateYMDHMS(addYearDate));
      }
      /**
       * 转化时间从指定格式日期为长整形
       *
       * @param format
       * @param time
       * @return
       */
      public static Long convertDateStringToDateLong(String format, String time) throws ParseException {
          if (time == null || time.trim().equals("")) {
              return null;
          }
          SimpleDateFormat fmt = new SimpleDateFormat(format);
          Date d = fmt.parse(time);
          return d.getTime();
      }
      /**
       * 获得指定格式日期
       *
       * @param date   日期
       * @param format 指定格式
       * @return
       */
      public static Date getFormatDate(Date date, String format) {
          if (null == date) {
              return null;
          }
          if (null == format) {
              return parseDate(formatDate("yyyy-MM-dd", date), "yyyy-MM-dd");
          }
          return parseDate(formatDate(format, date), format);
      }
      public static int getMinuteBetween(Date d1, Date d2) {
          if (d1 == null || d2 == null)
              return 0;
          long m = d1.getTime();
          long n = d2.getTime();
          return (int) ((m - n) / 60000);
      }
      /**
       * 计算创建时间到现在过去多久了
       *
       * @param createTime
       * @return
       */
      public static String getPastTime(Date createTime) {
          String pastTime;
          Date current = new Date();
          int days = getDayBetween(current, createTime);
          int hours = 0;
          int mins = 0;
          if (days > 0) {
              pastTime = "1天前";
          } else if ((hours = getHourBetween(current, createTime)) > 0) {
              pastTime = hours + "小时前";
          } else if ((mins = getMinuteBetween(current, createTime)) > 0) {
              pastTime = mins + "分钟前";
          } else {
              long seconds = getSecondBetweem(current, createTime);
              if (seconds > 5) {
                  pastTime = seconds + "秒前";
              } else {
                  pastTime = "刚刚";
              }
          }
          return pastTime;
      }
      /**
       * 获取从今天开始未来一周的星期和日期的映射表 1-星期一:2014-05-12，2-星期二:2014-05-13.....
       *
       * @return
       */
      public static Map getDateForWeekDay() {
          Map weekDayDateMap = new HashMap();
          Calendar calendar = Calendar.getInstance();
          for (int i = 1; i <= 7; i++) {
              int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
              if (dayOfWeek == 0) {
                  dayOfWeek = 7;
              }
              weekDayDateMap.put(dayOfWeek + "", calendar.getTime());
              calendar.add(Calendar.DAY_OF_MONTH, 1);
          }
          return weekDayDateMap;
      }
      /**
       * 获得本日星期数,星期一:1,星期日:7 如果传入null则默认为本日
       *
       * @return
       */
      public static int getDayOfWeek(Calendar calendar) {
          int today;
          if (calendar != null) {
              today = calendar.get(Calendar.DAY_OF_WEEK);
          } else {
              today = Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
          }
          if (today == 1)
              return 7;
          else
              return today - 1;
      }
      /**
       * 获取日期的中国式星期几（1-7分别代表周一至周日）
       *
       * @param date
       * @return
       */
      public static int getDayOfWeek(Date date) {
          if (date == null) {
              date = new Date();
          }
          Calendar cal = Calendar.getInstance();
          cal.setTime(date);
          return getDayOfWeek(cal);
      }
      /**
       * 判断两个日期是否为同一天
       *
       * @param date1
       * @param date2
       * @return
       */
      public static boolean isSameDate(Date date1, Date date2) {
          if (date1 == null || date2 == null) {
              return false;
          }
          Calendar calendar1 = Calendar.getInstance();
          Calendar calendar2 = Calendar.getInstance();
          calendar1.setTime(date1);
          calendar2.setTime(date2);
          if (calendar1.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR)
                  && calendar1.get(Calendar.MONTH) == calendar2.get(Calendar.MONTH)
                  && calendar1.get(Calendar.DAY_OF_MONTH) == calendar2.get(Calendar.DAY_OF_MONTH)) {
              return true;
          }
          return false;
      }
      public static String formatDuration(long duration) {
          float secondUnit = 1000;
          String formatDuration = "";
          DecimalFormat decimalFormat = new DecimalFormat(".00");
          if (duration < secondUnit) {
              formatDuration = duration + "(毫秒)";
          } else if (duration < secondUnit * 60) {
              formatDuration = decimalFormat.format(duration / secondUnit) + "(秒)";
          } else if (duration < secondUnit * 3600) {
              formatDuration = decimalFormat.format(duration / (secondUnit * 60)) + "(分钟)";
          } else if (duration < secondUnit * 3600 * 60) {
              formatDuration = decimalFormat.format(duration / (secondUnit * 3600)) + "(小时)";
          } else {
              formatDuration = decimalFormat.format(duration / (secondUnit * 3600 * 24)) + "(天)";
          }
          return formatDuration;
      }
      public static long getTodayBeginTime() {
          return getDayBegin(new Date()).getTime();
      }
      public static long getTodayEndTime() {
          return getDayEnd(new Date()).getTime();
      }
      /**
       * 比较两个时间大小
       *
       * @param startTime
       * @param endTime
       * @return int
       * @method compareDate()
       */
      public static int compareDate(String startTime, String endTime) throws ParseException {
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Date d1 = sdf.parse(startTime);
          Date d2 = sdf.parse(endTime);
          return d1.compareTo(d2);
      }
      /**
       * 是否是一个日期格式
       * @param time
       * @param pattern
       * @return
       */
      public static boolean isTime(String time,String pattern) {
          SimpleDateFormat sdf = new SimpleDateFormat(pattern);
          try {
              sdf.setLenient(false);
              sdf.parse(time);
          } catch (ParseException e) {
              return false;
          }
          return true;
      }
      /**
       * 转换时间标准格式 yyyy-MM-dd HH:mm:ss
       */
      public static final ThreadLocal yMdHms = new ThreadLocal() {
          @Override
          protected DateFormat initialValue() {
              return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          }
      };
      /**
       * 转换时间标准格式 yyyy-MM-dd
       */
      public static final ThreadLocal yMd = new ThreadLocal() {
          @Override
          protected DateFormat initialValue() {
              return new SimpleDateFormat("yyyy-MM-dd");
          }
      };
      /**
       * 转换时间标准格式 yyyy-MM-dd HH:mm
       */
      public static final ThreadLocal yMdHm = new ThreadLocal() {
          @Override
          protected DateFormat initialValue() {
              return new SimpleDateFormat("yyyy-MM-dd HH:mm");
          }
      };
      /**
       * 校验时间冲突
       * @param dateA   2021-02-08 13:00~2021-02-08 13:00
       * @param dateB   2021-02-08 13:00~2021-02-08 13:00
       * @return 冲突返回true,不冲突返回false
       */
      public static Boolean checkDateConflict(String dateA, String dateB) {
          List dateAList = new ArrayList<>(Arrays.asList(dateA.split("~")));
          List dateBList = new ArrayList<>(Arrays.asList(dateB.split("~")));
          try {
              Date dateA1 = DateUtil.yMdHm.get().parse(dateAList.get(0));
              Date dateA2 = DateUtil.yMdHm.get().parse(dateAList.get(1));
              Date dateB1 = DateUtil.yMdHm.get().parse(dateBList.get(0));
              Date dateB2 = DateUtil.yMdHm.get().parse(dateBList.get(1));
              //dateA开始时间大于dateB结束时间，不冲突
              if (dateA1.compareTo(dateB2) >= 0) {
                  return false;
              }
              //dateA结束时间小于dateB开始时间，不冲突
              if (dateA2.compareTo(dateB1) <= 0) {
                  return false;
              }
          } catch (ParseException e) {
              throw new MessageException("时间格式异常");
          }
          return true;
      }
      /**
       * 计算一个日期N天后的时间
       * @param date
       * @param n
       * @return
       * @throws ParseException
       */
      public static String afterNDay(Date date,int n){
          Calendar c=Calendar.getInstance();
          SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
          c.setTime(date);
          c.add(Calendar.DATE,n);
          Date d2=c.getTime();
          String s=df.format(d2);
          return s;
      }
      /**
       * 计算两个日期相差了多少天
       * @param date1
       * @param date2
       * @return
       */
      public static int differentDaysByMillisecond(Date date1,Date date2) {
          int days = (int) ((date2.getTime() - date1.getTime()) / (1000*3600*24));
          return days;
      }
      /**
       * 计算两个字符串日期(格式“yyyy-MM-dd”)相差了多少天
       * @param date1
       * @param date2
       * @return
       */
      public static int differentStrDaysByMillisecond(String date1,String date2) {
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Date parse1 = null;
          Date parse2 = null;
          try {
              parse1 = sdf.parse(date1);
              parse2 = sdf.parse(date2);
          } catch (ParseException e) {
              e.printStackTrace();
          }
          int days = (int) ((parse1.getTime() - parse2.getTime()) / (1000*3600*24));
          return days;
      }
      /**
       * 获取本周周一 yyyy-MM-dd
       * @return
       */
      public static String getWeekBegin(){
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Calendar cal = Calendar.getInstance();
          //设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
          cal.setFirstDayOfWeek(Calendar.MONDAY);
          //获得当前日期是一个星期的第几天
          int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
          if(dayWeek==1){
              dayWeek = 8;
          }
          // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
          cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - dayWeek);
          Date mondayDate = cal.getTime();
          String weekBegin = sdf.format(mondayDate);
          return weekBegin;
      }
      /**
       * 获取本周周一 yyyy-MM-dd
       * @return
       */
      public static String getWeekEnd(){
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Calendar cal = Calendar.getInstance();
          //设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
          cal.setFirstDayOfWeek(Calendar.MONDAY);
          //获得当前日期是一个星期的第几天
          int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
          if(dayWeek==1){
              dayWeek = 8;
          }
          cal.add(Calendar.DATE, 4 +cal.getFirstDayOfWeek());
          Date sundayDate = cal.getTime();
          String weekEnd = sdf.format(sundayDate);
          return weekEnd;
      }
  }
  

  4.调用工具类方法

    public static void main(String[] args) {
    		 String date = "2023-07-12";
           String yearHoliday = HolidayUtil.isWorkingDay(date);
           System.out.println(yearHoliday);
      }
  

  打印结果：0

  ---

  搞定收工

  希望可以帮助到您

  ~打工人冲啊~

  .