java查询某个日期后的7个工作日

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量1k 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35908944/article/details/109329462
版权

直接上代码

 public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            //传入的日期+7
            int dayStart=1;
            int dayNum=7;
            Date date = sdf.parse("2020-9-30");
            while(dayStart<=dayNum){
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(date);
                calendar.add(Calendar.DAY_OF_MONTH, +1);
                date = calendar.getTime();
                String url = "http://timor.tech/api/holiday/info/"+sdf.format(date);
                String result = HttpClientUtil.doGet(url);
                WorkDateEntity parse = JsonUtils.parse(result, WorkDateEntity.class);
                if(parse.getType().getType()==0||parse.getType().getType()==3){
                    dayStart++;
                    System.out.println(sdf.format(date));
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        }

HttpClientUtil 发送请求工具类

import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpClientUtil {
    /**
     * 带参数的get请求
     * @param url
     * @param param
     * @return String
     */
    public static String doGet(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();
            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);
            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    /**
     * 不带参数的get请求
     * @param url
     * @return String
     */
    public static String doGet(String url) {
        return doGet(url, null);
    }

    /**
     * 带参数的post请求
     * @param url
     * @param param
     * @return String
     */
    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    /**
     * 不带参数的post请求
     * @param url
     * @return String
     */
    public static String doPost(String url) {
        return doPost(url, null);
    }

    /**
     * 传送json类型的post请求
     * @param url
     * @param json
     * @return String
     */
    public static String doPostJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

}

JsonUtils json转换工具类

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.PropertyFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;

import java.util.List;
import java.util.Map;

/**
 * 在系统中统一使用这个，以方便将来切换不同的JSON生成工具
 *
 * @author KelvinZ
 *
 */
public class JsonUtils {
    /**
     * <pre>
     * 对象转化为json字符串
     *
     * @param obj 待转化对象
     * @return 代表该对象的Json字符串
     */
    public static final String toJson(final Object obj) {
        return JSON.toJSONString(obj);
        // return gson.toJson(obj);
    }

    /**
     * <pre>
     * 对象转化为json字符串
     *
     * @param obj 待转化对象
     * @return 代表该对象的Json字符串
     */
    public static final String toJson(final Object obj, SerializerFeature... features) {
        return JSON.toJSONString(obj, features);
        // return gson.toJson(obj);
    }

    /**
     * 对象转化为json字符串并格式化
     *
     * @param obj
     * @param format 是否要格式化
     * @return
     */
    public static final String toJson(final Object obj, final boolean format) {
        return JSON.toJSONString(obj, format);
    }

    /**
     * 对象对指定字段进行过滤处理，生成json字符串
     *
     * @param obj
     * @param fields 过滤处理字段
     * @param ignore true做忽略处理，false做包含处理
     * @param features json特征，为null忽略
     * @return
     */
    public static final String toJson(final Object obj, final String[] fields, final boolean ignore,
                                      SerializerFeature... features) {
        if (fields == null || fields.length < 1) {
            return toJson(obj);
        }
        if (features == null)
            features = new SerializerFeature[] { SerializerFeature.QuoteFieldNames };
        return JSON.toJSONString(obj, new PropertyFilter() {
            @Override
            public boolean apply(Object object, String name, Object value) {
                for (int i = 0; i < fields.length; i++) {
                    if (name.equals(fields[i])) {
                        return !ignore;
                    }
                }
                return ignore;
            }
        }, features);
    }

    /**
     * <pre>
     * 解析json字符串中某路径的值
     *
     * @param json
     * @param path
     * @return
     */
    @SuppressWarnings("unchecked")
    public static final <E> E parse(final String json, final String path) {
        String[] keys = path.split(",");
        JSONObject obj = JSON.parseObject(json);
        for (int i = 0; i < keys.length - 1; i++) {
            obj = obj.getJSONObject(keys[i]);
        }
        return (E) obj.get(keys[keys.length - 1]);
    }

    /**
     * <pre>
     * json字符串解析为对象
     *
     * @param json 代表一个对象的Json字符串
     * @param clazz 指定目标对象的类型，即返回对象的类型
     * @return 从json字符串解析出来的对象
     */
    public static final <T> T parse(final String json, final Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }

    /**
     * <pre>
     * json字符串解析为对象
     *
     * @param json json字符串
     * @param path 逗号分隔的json层次结构
     * @param clazz 目标类
     */
    public static final <T> T parse(final String json, final String path, final Class<T> clazz) {
        String[] keys = path.split(",");
        JSONObject obj = JSON.parseObject(json);
        for (int i = 0; i < keys.length - 1; i++) {
            obj = obj.getJSONObject(keys[i]);
        }
        String inner = obj.getString(keys[keys.length - 1]);
        return parse(inner, clazz);
    }

    /**
     * 将制定的对象经过字段过滤处理后，解析成为json集合
     *
     * @param obj
     * @param fields
     * @param ignore
     * @param clazz
     * @param features
     * @return
     */
    public static final <T> List<T> parseArray(final Object obj, final String[] fields, boolean ignore,
                                               final Class<T> clazz, final SerializerFeature... features) {
        String json = toJson(obj, fields, ignore, features);
        return parseArray(json, clazz);
    }

    /**
     * <pre>
     * 从json字符串中解析出一个对象的集合，被解析字符串要求是合法的集合类型
     * （形如:["k1":"v1","k2":"v2",..."kn":"vn"]）
     *
     * @param json - [key-value-pair...]
     * @param clazz
     * @return
     */
    public static final <T> List<T> parseArray(final String json, final Class<T> clazz) {
        return JSON.parseArray(json, clazz);
    }

    /**
     * <pre>
     * 从json字符串中按照路径寻找，并解析出一个对象的集合，例如：
     * 类Person有一个属性name，要从以下json中解析出其集合：
     * {
     * 	"page_info":{
     * 		"items":{
     * 			"item":[{"name":"KelvinZ"},{"name":"Jobs"},...{"name":"Gates"}]
     * 	}
     * }
     * 使用方法：parseArray(json, "page_info,items,item", Person.class)，
     * 将根据指定路径，正确的解析出所需集合，排除外层干扰
     *
     * @param json json字符串
     * @param path 逗号分隔的json层次结构
     * @param clazz 目标类
     * @return
     */
    public static final <T> List<T> parseArray(final String json, final String path, final Class<T> clazz) {
        String[] keys = path.split(",");
        JSONObject obj = JSON.parseObject(json);
        for (int i = 0; i < keys.length - 1; i++) {
            obj = obj.getJSONObject(keys[i]);
        }
        String inner = obj.getString(keys[keys.length - 1]);
        List<T> ret = parseArray(inner, clazz);
        return ret;
    }

    /**
     * <pre>
     * 有些json的常见格式错误这里可以处理，以便给后续的方法处理
     * 常见错误：使用了\" 或者 "{ 或者 }"，腾讯的页面中常见这种格式
     *
     * @param invalidJson 包含非法格式的json字符串
     * @return
     */
    public static final String correctJson(final String invalidJson) {
        String content = invalidJson.replace("\\\"", "\"").replace("\"{", "{").replace("}\"", "}");
        return content;
    }

    /**
     * 格式化Json
     *
     * @param json
     * @return
     */
    public static final String formatJson(String json) {
        Map<?, ?> map = (Map<?, ?>) JSON.parse(json);
        return JSON.toJSONString(map, true);
    }

    /**
     * 获取json串中的子json
     *
     * @param json
     * @param path
     * @return
     */
    public static final String getSubJson(String json, String path) {
        String[] keys = path.split(",");
        JSONObject obj = JSON.parseObject(json);
        for (int i = 0; i < keys.length - 1; i++) {
            obj = obj.getJSONObject(keys[i]);
            System.out.println(obj.toJSONString());
        }
        return obj != null ? obj.getString(keys[keys.length - 1]) : null;
    }

}

实体类

public class WorkDateEntity {
    private Integer code;
    private WorkType type;
    private WorkHoliday holiday;
}

public class WorkType {
    private Integer type;
    private String name;
    private Integer week;
}

public class WorkHoliday {
    private Boolean holiday;
    private String name;
    private Integer wage;
    private Date date;
    private Integer rest;
}
写代码的小清新
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java 时间间隔 工作日_计算Java中两个日期之间的工作日数
weixin_34091081的博客
02-13 1542
5行代码无循环的解决方案定义之间的天数的方式与ChronoUnit.DAYS.between(start, end)表示4星期一至星期五之间存在天数的方式相同。由于我们只对工作日感兴趣，因此我们必须减去周末，因此从星期五到星期二会有2工作日(只需计算endDay - startDay并减去2周末)。1如果要包含结果，则添加到结果中，即不要间隔几天。我提出两种解决方案。第一个解决方案(5线，简短和隐...
Java之获取指定时间、指定N个工作日后的日期
碎狸~的博客
12-03 2262
环境（SpringBoot+MyBatis+JPA） 需求是需要判断某个节点或者某些有时间的字段是否超时。例如提交某个申请规定的审核时间是5个工作日。那么要判断是否超时，就得获取从开始时间后5个工作日的日期。这个工作日是不包含节假日、周末。或者说工作日是自己定义的时间。 节假日实体类 该实体类主要是记录周末、加班、节假日的日期 import lombok.Getter; import lombok...
几个好用的节假日、调休时间和工作日的网站
梦想起飞的地方.........
07-01 232
3.程序世界：提供免费节假日Api开放接口，可以查询指定日期范围内工作日天数、今天是工作日吗、下一个节假日、距离下一个节假日还有多少天、获取一整年节假日等信息。原文链接：https://blog.csdn.net/Meggie35/article/details/138352022。可以查询特定日期是否为节假日。2.APIHubs：提供节假日查询接口，可以查询工作日、周末、法定节假日、节假日调休补班数据。接口地址为 https://api.apihubs.cn/holiday/get。
Java实现一段时间内的工作日天数(除去节假日、双休日)
sll714827的博客
08-26 5788
Java实现一段时间内的工作日天数(除去节假日、双休日) 通过调用工具类getworkDays()方法传入时间区间返回该区间内的工作日天数(除去节假日、双休日) 注:工具类中的SPECIAL_WORK_DAYS(特殊的工作日)、SPECIAL_REST_DAYS(特殊的休息日)需要进行动态赋值,我们可以通过爬虫获取指定年份的holiday和workday来对这两的集合进行赋值 一、爬虫爬取百度日历中所需信息 pom.xml <dependency> &lt
【Java开发-工作日计算】使用Java中的LocalDateTime对象计算工作日
筱星
06-25 632
计算给定开始时间、结束时间以及节假日列表之间的工作小时数（不包括周末、节假日以及非工作时间，例如每天的晚上和凌晨） 早上如果不到9点，按9点开始算；下午如果超过17点，按17点结束算
java计算当前日期后N个工作日的日期
AnNong
05-27 5289
如图，合同中有很多这种日期计算，故封装一通用工具类，记录于此。需求如下： WorkDayUtils如下： package com.sqds.utils; import org.apache.commons.lang.StringUtils; import java.text.SimpleDateFormat; import java.util.*; /** * 工作日计算工具类 ...
java计算5个工作日后的日期
qq_43805205的博客
10-19 321
【代码】java计算5个工作日后的日期。
Java获取当前时间后几天工作日日期
aa503709643的博客
10-14 3126
package test.date; import com.google.common.collect.Lists; import org.apache.http.client.utils.DateUtils; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; /** * Created by tianxiang on 2020/10/14 */ public class.
JAVA 判断某个日期是否为工作日
weixin_44526722的博客
11-04 3403
java判断某个日期是否为工作日
java 算出下一个工作日,Java:计算一个日期加下指定工作日数(排除周六周日和一系列节日)...
weixin_39738152的博客
03-14 690
Java:计算一个日期加上指定工作日数(排除周六周日和一系列节日)工作时遇到的,随便写了个,欢迎高手点评:核心代码:package www.sjjjob.com.date;import java.util.ArrayList;import java.util.Calendar;import java.util.List;/*** 日期公共函数* @author shenjunjie* @vers...
判断是否是节假日以及几个工作日后的日期（包含json格式依赖jar包）
03-04
在Java编程中，有时我们需要处理与日期相关的任务，例如判断某个日期是否是节假日，或者计算几个工作日后的新日期。这个工具类就是为了解决这样的问题而设计的。它包含了一个功能丰富的API，允许开发者轻松地进行...
java计算工作时间除去节假日以及双休日
08-27
最后，我们调整结束时间，使得开始时间和结束时间在同一天，或者相邻的工作日内，并计算出开始时间和结束时间之间的工作日天数。 Java 计算工作时间除去节假日以及双休日的方法可以通过上述代码实现。这种方法可以...
java中计算某个月的工作日总共几天
06-03
根据提供的文件信息，我们可以总结出以下关于Java中计算某个月工作日的相关知识点： ### Java中计算某个月的工作日总数及具体工作日 #### 概述 在Java中，要计算一个月内有多少个工作日（通常指周一至周五），以及...
JAVA时间工具类（计算法定工作日工时等）
08-08
JAVA时间工具类（计算法定工作日工时）：计算某个日期加上几个工作日后的一个工作日期(除周末和法定节假日)，计算某个日期后一天的工作日期(除周末和法定节假日)，计算两个日期的真实工作日(除周末和法定节假日)，...
java工作日计算（去除法定假日）
01-18
通过以上步骤，我们可以构建一个功能完善的工作日计算系统，能够精确地计算出两个日期之间的工作日数量，同时考虑到了法定节假日的影响。这个过程涉及了文件读取、日期时间处理和自定义逻辑的实现，是Java开发中的一...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 515
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 310
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 293
1.导入hutool的maven依赖。2.直接复制一下代码运行。
java中怎么判断某个日期是否是工作日的代码
08-18
Java中可以使用Java 8中的java.time包中的类来判断某个日期是否是工作日。具体实现可以使用以下代码： ```java import java.time.DayOfWeek; import java.time.LocalDate; public class CheckWorkday { public ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值