JAVA 获取正常上班工作日-除去节假日,双休日,加上加班
java判断国家法定节假日的方法
java判断国家法定节假日的方法全文共四篇示例，供读者参考第一篇示例：Java是一种流行的编程语言，用于开发各种应用程序和系统。
在许多情况下，我们需要判断一个日期是否是国家法定的节假日。
这在许多应用程序中都是必须要考虑的一个问题，比如日历应用程序、假期提醒应用程序等等。
在本文中，我们将讨论如何使用Java编程语言来判断国家法定的节假日的方法。
一般来说，判断一个日期是否是节假日，需要先明确该国家的法定节假日的具体规定。
不同的国家有不同的法定节假日，可以是固定日期的，也可以是依据农历等进行计算的。
在此，我们以中国的法定节假日为例来说明如何判断一个日期是否是法定节假日。
我们需要定义中国的法定节假日的规定：1. 元旦：1月1日2. 春节：农历正月初一至正月十五3. 清明节：农历四月四日4. 劳动节：5月1日至5月3日5. 端午节：农历五月五日6. 中秋节：农历八月十五日7. 国庆节：10月1日至10月7日接下来，我们可以通过编写一个Java程序来判断一个日期是否是中国的法定节假日。
我们可以定义一个方法来判断一个日期是否是一个法定节假日，如下所示：```javapublic static boolean isHoliday(int year, int month, int day) {// 判断元旦if (month == 1 && day == 1) {return true;}// 判断春节// 农历春节的日期需要特殊计算，略...// 判断清明节if (month == 4 && day == 4) {return true;}// 判断劳动节if (month == 5 && day >= 1 && day <= 3) { return true;}// 判断端午节// 农历端午节的日期需要特殊计算，略...// 判断中秋节// 农历中秋节的日期需要特殊计算，略...// 判断国庆节if (month == 10 && day >= 1 && day <= 7) { return true;}return false;}```在上述代码中，我们定义了一个`isHoliday`方法，接收年、月、日三个参数，然后根据中国的法定节假日规定，判断该日期是否是法定节假日。
java 工作日休息日表结构
java 工作日休息日表结构Java 工作日休息日表结构Java 是一门广泛应用于计算机领域的高级编程语言。
在日常的开发过程中，我们常常需要对时间进行计算和处理。
而对于工作日和休息日的处理更是不可避免的问题。
为此，我们需要一个好的表结构来处理工作日和休息日，以便更好地管理时间和提高工作效率。
表结构设计如下是我们设计的工作日休息日表结构：day_id | day_date | day_type-------|----------|----------1 | 2022-01-01 | HOLIDAY2 | 2022-01-02 | HOLIDAY3 | 2022-01-03 | HOLIDAY4 | 2022-01-04 | WORKDAY5 | 2022-01-05 | WORKDAY6 | 2022-01-06 | WORKDAY7 | 2022-01-07 | WORKDAY8 | 2022-01-08 | WORKDAY9 | 2022-01-09 | HOLIDAY表中有三个字段，分别是 day_id、day_date 和 day_type。
其中，day_id 是自增长的索引，用于避免日期的主键冲突；day_date 代表日期字段，使用标准的日期格式，如2022-01-01；day_type 字段则代表该日期是工作日还是休息日，取值为 WORKDAY 或 HOLIDAY。
使用数据库我们可以通过数据库来存储和管理工作日休息日的信息。
数据库可以支持我们进行方便的数据查询和实时更新。
我们将表中的数据存储在数据库中，使用 SQL 语句进行数据查询和统计。
表结构使用在实际应用中，我们可以根据需求自定义工作日和休息日。
比如，在一些国家和地区，周六周日是休息日，而在一些行业，周六仍然是工作日。
因此，我们可以针对不同的国家和地区以及行业来设定不同的工作日和休息日。
在代码中，我们可以通过读取数据库中的表结构来得到工作日和休息日的信息，从而方便地进行时间的计算和处理。
考勤规则实现 java
考勤规则实现 java我们需要明确考勤规则的基本要求。
考勤系统通常会记录员工的上下班时间、请假情况、加班情况等信息，以便对员工的出勤情况进行统计和分析。
因此，考勤规则需要包括以下几个方面的内容：考勤时间、请假规定、加班规定、迟到早退规定等。
在考勤时间方面，我们可以定义一个时间段，比如每天上午8点到下午17点为正常上班时间。
在这个时间段内，员工需要签到和签退，系统会记录员工的上班时间和下班时间。
如果员工没有在规定时间内签到或签退，系统会自动记录迟到或早退的情况。
请假规定是考勤系统中比较重要的一部分。
不同公司对于请假的规定可能有所不同，可以根据公司的实际情况来定义请假规则。
比如，员工可以根据自己的情况请假，但需要提前一定的时间通知主管，并填写请假申请表。
系统会记录员工的请假时间和请假原因，并在考勤统计中进行相应的处理。
加班规定是考勤规则中另一个重要的方面。
有些公司需要员工加班，为此可以定义加班时间段和加班补偿规定。
员工在加班时，需要在系统中进行加班申请，并填写加班原因。
系统会记录员工的加班时间，并根据加班补偿规定进行相应的处理。
考勤规则还需要考虑迟到和早退的情况。
可以定义一个容许范围，比如员工可以在规定的时间范围内迟到或早退一定时间，超过这个时间就算迟到或早退。
系统会记录员工的迟到和早退情况，并在考勤统计中进行相应的处理。
除了以上的基本要求外，考勤规则还可以根据实际情况进行扩展。
比如，可以定义特殊情况下的考勤规定，比如员工因为病假、事假等原因不能正常上班，需要进行相应的处理。
另外，还可以定义考勤统计的规则，比如每月末生成考勤报表，统计员工的出勤情况等。
在 Java中实现考勤规则可以使用面向对象的思想来设计和实现。
可以定义一个员工类，包含员工的基本信息和考勤记录等属性。
可以定义一个考勤系统类，包含考勤规则和考勤统计等方法。
可以使用集合类来保存员工的考勤记录，并实现相应的查询和统计功能。
总结起来，考勤规则是一个非常重要的管理工具，在企业中起到了至关重要的作用。
java获取法定节假日信息的方法
一、介绍法定节假日信息获取的重要性在进行日常工作、生活安排时，了解法定假日的具体情况是非常重要的。
这不仅有助于合理安排个人时间，还能更好地预防因节假日放假时间不清楚而导致的工作错乱或计划冲突。
二、Java获取法定节假日信息的方法1. 使用开源API目前市面上有很多开源的API可以获取法定节假日信息，其中比较知名的有“我国节假日查询API”、“节假日及工作日查询API”等。
这些API通常都提供了相应的接口和文档，可以通过调用其接口来获取法定节假日的信息。
2. 自定义数据源如果没有现成的API可供调用，也可以自行维护一个法定节假日的数据源。
可以将法定节假日的相关信息存储在数据库或者配置文件中，在需要的时候进行查询即可。
这种方法适用于对数据安全有较高要求或者没有网络连接的情况下。
3. 使用第三方工具库除了开源API之外，还可以使用一些第三方的Java工具库来获取法定节假日的信息。
可以使用“JollyHoliday”、“JollyDay”等工具库来获取节假日信息，并且这些工具库通常也提供了各种配置和定制的选项，可以根据实际需要进行调整。
4. 调用政府公开接口一些政府部门或者冠方机构也会提供相应的接口来获取法定节假日的信息。
可以通过调用这些公开接口来获取最权威、最及时的节假日信息，确保获取到的信息是最准确可靠的。
三、应用场景及注意事项1. 应用场景Java获取法定节假日信息的方法可以应用于各种项目中，包括但不限于日程安排管理软件、考勤系统、团队协作工具等。
在这些场景中，了解法定节假日的信息有助于更好地进行排班、调休等工作。
2. 注意事项在使用Java获取法定节假日信息的方法时，需要注意以下几点： a. 数据更新及时性：法定节假日的信息是动态变化的，需要保证获取信息的及时性，避免因信息过期而导致的错误。
b. 数据准确性：所获取的节假日信息需要保证准确性，避免因信息错误而造成不必要的麻烦。
c. 数据安全性：对于涉及用户隐私或敏感数据的项目，需要更加重视数据的安全性，保证所获取的信息不会被恶意篡改或者泄露。
java国家节假日判断代码 -回复
java国家节假日判断代码-回复如何使用Java编写一个国家节假日判断代码。
编写一个可以判断中国国家节假日的Java代码非常有用。
这样的代码可以帮助我们自动判断当前日期是否是一个节假日，从而能够准确地安排工作或者休息时间。
以下是一步一步编写这样的代码的详细过程。
首先，我们需要导入Java中的相关类库和模块，以便能够使用日期和时间的功能。
在Java中，日期和时间相关的类主要在`java.util`和`java.time`包中。
因此，我们需要在代码开头添加以下`import`语句：javaimport java.util.Calendar;import java.util.Date;import java.time.LocalDate;接下来，我们可以创建一个名为`HolidayChecker`的Java类，其中包含一个名为`isHoliday`的方法，用于判断给定日期是否是一个中国国家节假日。
代码片段如下：javapublic class HolidayChecker {public boolean isHoliday(Date date) {Calendar calendar = Calendar.getInstance();calendar.setTime(date);int year = calendar.get(Calendar.YEAR);int month = calendar.get(Calendar.MONTH) + 1; 注意月份需要加1，因为Calendar类的月份是从0开始计数的int day = calendar.get(Calendar.DAY_OF_MONTH);在这里编写具体的判断节假日的逻辑return false;}}在`isHoliday`方法中，我们首先通过`Calendar.getInstance()`方法获取一个`Calendar`对象，并将其设置为给定日期。
js 获得工作日天数,不考虑节假日
var orgTime = from.getTime();
to.setTime(toTime);
to.setHours(0);
to.setMinutes(0);
to.setSeconds(0);
if(from.getTime() > to.getTime()){
days1+=weekDay-1;
}
} catch (ParseException e) {
e.printStackTrace();
}
return days1;
}
{
alert('只能选择一个申请人');
return;
}
var orgId = "2c90803e22c939d00122c93b37090021";
var url="/baseset/LgmDept_treeUser.action?orgId="+orgId;
//
//for(var i=0;i<holidayArray.length;i++){
//
//if(holidayArray[i].getTime()>orgTime && holidayArray[i].getTime()<to.getTime()){
//
//if(holidayArray[i].getDay()>0 && holidayArray[i].getDay()<6){
return 0;
}
// 把起始日都修正到星期六 javascript的星期从0开始，所以+1来处理
java节假日算法_基于Java代码实现判断春节、端午节、中秋节等法定节假日的方法...
java节假⽇算法_基于Java代码实现判断春节、端午节、中秋节等法定节假⽇的⽅法...⼀、前⾔最近⼯作上遇到⼀个问题，后端有⼀个定时任务，需要⽤JAVA每天判断法定节假⽇、周末放假，上班等情况，其实想单独通过逻辑什么的去判断中国法定节假⽇的放假情况，基本不可能，因为国家每⼀年的假期可能不⼀样，是⼈为设定的；所以只能依靠其它⼿段，能想到的⽐较靠谱的如下：1.⽹络接⼝：有些数据服务商会提供，要么是收钱的，要么是次数限制，等等各种问题，效果不理想，可控性差，我也没试过，如：或者2.在线解析⽹页信息，获取节假⽇情况：严重依赖被解析的⽹站⽹页，所以在选取⽹站的时候，要找稍微靠谱点的；3.根据国家规定的法定节假⽇放假情况，每年录⼊系统，这种如果客户不怕⿇烦的话。
还是⽐较靠谱的；本Demo将选择第⼆种来实现；⼆、使⽤htmlunit在线解析⽹页信息，获取节假⽇情况⼀开始是使⽤jsoup去解析⽹页的，效果不理想，如果⽹页是动态⽣成的时候，⽤jsoup遇到了各种问题，所以改成了htmlunit，总得来说htmlunit还是很强⼤的，能够模拟浏览器运⾏，被誉为java浏览器的开源实现；⾸先去官⽹下载相关jar包，以及阅读相关⽂档：我这⾥解析的⽹页是360的万年历：⽇历界⾯如下：被解析的 HTML格式如下：实现步骤：1、加载页⾯；2、循环等待页⾯加载完成(可能会有⼀些动态页⾯，是⽤javascript⽣成)；3、根据⽹页格式解析html内容，并提取关键信息存⼊封装好的对象；注意点：1、难点在于判断是否休假及假期类型，由于原页⾯并没有标明每⼀天的假期类型，所以这⾥的逻辑要⾃⼰去实现，详情参考代码；2、之所以有个静态latestVocationName变量，是防⽌出现以下情况(出现该情况的概率极低；PS:⽅法要每天调⽤⼀次，该变量才⽣效)：代码实现：定义⼀个中国⽇期类：package com.pichen.tools.getDate;import java.util.Date;public class ChinaDate {/*** 公历时间private Date solarDate;/*** 农历⽇*/private String lunar;/*** 公历⽇*/private String solar;/*** 是否是 休*/private boolean isVacation = false;/*** 如果是 休情况下的假期名字*/private String VacationName = "⾮假期";/*** 是否是 班*/private boolean isWorkFlag = false; private boolean isSaturday = false;private boolean isSunday = false;/*** @return the solarDate*/public Date getSolarDate() {return solarDate;}/*** @param solarDate the solarDate to set */public void setSolarDate(Date solarDate) {}/*** @return the lunar*/public String getLunar() {return lunar;}/*** @param lunar the lunar to set*/public void setLunar(String lunar) {this.lunar = lunar;}/*** @return the solar*/public String getSolar() {return solar;}/*** @param solar the solar to set*/public void setSolar(String solar) {this.solar = solar;}/*** @return the isVacation*/public boolean isVacation() {return isVacation;}/*** @param isVacation the isVacation to setpublic void setVacation(boolean isVacation) {this.isVacation = isVacation;}/*** @return the vacationName*/public String getVacationName() {return VacationName;}/*** @param vacationName the vacationName to set*/public void setVacationName(String vacationName) { VacationName = vacationName;}/*** @return the isWorkFlag*/public boolean isWorkFlag() {return isWorkFlag;}/*** @param isWorkFlag the isWorkFlag to set*/public void setWorkFlag(boolean isWorkFlag) {this.isWorkFlag = isWorkFlag;}/*** @return the isSaturday*/public boolean isSaturday() {return isSaturday;}* @param isSaturday the isSaturday to set*/public void setSaturday(boolean isSaturday) {this.isSaturday = isSaturday;}/*** @return the isSunday*/public boolean isSunday() {return isSunday;}/*** @param isSunday the isSunday to set*/public void setSunday(boolean isSunday) {this.isSunday = isSunday;}}解析⽹页，并调⽤demo，打印本⽉详情，和当天详情：package com.pichen.tools.getDate;import java.io.IOException;import .MalformedURLException;import java.text.DateFormat;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Date;import java.util.List;import com.gargoylesoftware.htmlunit.FailingHttpStatusCodeException; import com.gargoylesoftware.htmlunit.WebClient;import com.gargoylesoftware.htmlunit.html.DomNodeList;import com.gargoylesoftware.htmlunit.html.HtmlElement;import com.gargoylesoftware.htmlunit.html.HtmlPage;private static String latestVocationName="";public String getVocationName(DomNodeList htmlElements, String date) throws ParseException{ String rst = "";boolean pastTimeFlag = false;DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");Date paramDate = dateFormat.parse(date);if(new Date().getTime() >= paramDate.getTime()){pastTimeFlag = true;}//first step //jugde if can get vocation name from html pagefor(int i = 0; i < htmlElements.size(); i++){HtmlElement element = htmlElements.get(i);if(element.getAttribute("class").indexOf("vacation")!=-1){boolean hitFlag = false;String voationName = "";for(; i < htmlElements.size(); i++){HtmlElement elementTmp = htmlElements.get(i);String liDate = elementTmp.getAttribute("date");List lunar = elementTmp.getElementsByAttribute("span", "class", "lunar");String lanarText = lunar.get(0).asText();if(lanarText.equals("元旦")){voationName = "元旦";}else if(lanarText.equals("除⼣")||lanarText.equals("春节")){voationName = "春节";}else if(lanarText.equals("清明")){voationName = "清明";}else if(lanarText.equals("国际劳动节")){voationName = "国际劳动节";}else if(lanarText.equals("端午节")){voationName = "端午节";}else if(lanarText.equals("中秋节")){voationName = "中秋节";}else if(lanarText.equals("国庆节")){}if(liDate.equals(date)){hitFlag = true;}if(elementTmp.getAttribute("class").indexOf("vacation")==-1){break;}}if(hitFlag == true && !voationName.equals("")){rst = voationName;break;}}else{continue;}}//if first step fail(rarely), get from the latest Vocation nameif(rst.equals("")){System.out.println("warning: fail to get vocation name from html page."); //you can judge by some simple rule//from the latest Vocation namerst = testVocationName;}else if(pastTimeFlag == true){//更新《当前时间，且最近⼀次的可见的假期名testVocationName = rst;}return rst;}public List getCurrentDateInfo(){WebClient webClient = null;List dateList = null;try{DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");webClient = new WebClient();HtmlPage page = webClient.getPage("/rili/");//最⼤等待60秒for(int k = 0; k < 60; k++){if(!page.getElementById("M-dates").asText().equals("")) break;Thread.sleep(1000);}//睡了8秒，等待页⾯加载完成...，有时候，页⾯可能获取不到，不稳定()//Thread.sleep(8000);DomNodeList htmlElements = page.getElementById("M-dates").getElementsByTagName("li");//System.out.println(htmlElements.size());for(HtmlElement element : htmlElements){ChinaDate chinaDate = new ChinaDate();List lunar = element.getElementsByAttribute("span", "class", "lunar");List solar = element.getElementsByAttribute("div", "class", "solar");chinaDate.setLunar(lunar.get(0).asText());chinaDate.setSolar(solar.get(0).asText());chinaDate.setSolarDate(dateFormat.parse(element.getAttribute("date")));if(element.getAttribute("class").indexOf("vacation")!=-1){chinaDate.setVacation(true);chinaDate.setVacationName(this.getVocationName(htmlElements, element.getAttribute("date"))); }if(element.getAttribute("class").indexOf("weekend")!=-1 &&element.getAttribute("class").indexOf("last")==-1){chinaDate.setSaturday(true);}if(element.getAttribute("class").indexOf("last weekend")!=-1){chinaDate.setSunday(true);}if(element.getAttribute("class").indexOf("work")!=-1){chinaDate.setWorkFlag(true);}else if(chinaDate.isSaturday() == false &&chinaDate.isSunday() == false &&chinaDate.setWorkFlag(true);}else{chinaDate.setWorkFlag(false);}dateList.add(chinaDate);}}catch(Exception e){e.printStackTrace();}finally{webClient.close();}return dateList;}public ChinaDate getTodayInfo(){List dateList = this.getCurrentDateInfo();DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");for(ChinaDate date: dateList){if(dateFormat.format(date.getSolarDate()).equals(dateFormat.format(new Date()))){return date;}}return new ChinaDate();}public static void main(String[] args) throws FailingHttpStatusCodeException, MalformedURLException, IOException, InterruptedException {List dateList = new Main().getCurrentDateInfo();ChinaDate today = new Main().getTodayInfo();DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");System.out.println("本⽉详情：");for(ChinaDate date: dateList){System.out.println(dateFormat.format(date.getSolarDate()) + " " + date.getVacationName());}System.out.println("------------------------------------------------------------------------");System.out.println("⽇期：" + today.getSolarDate());System.out.println("农历："+today.getLunar());System.out.println("公历："+today.getSolar());System.out.println("假期名："+today.getVacationName());System.out.println("是否周六："+today.isSaturday());System.out.println("是否周⽇："+today.isSunday());System.out.println("是否休假："+today.isVacation());System.out.println("是否⼯作⽇："+today.isWorkFlag());System.out.println("已发⽣的最近⼀次假期:" + testVocationName); }}运⾏程序，结果正确：。
Java获取法定节假日并解析
Java获取法定节假日并解析1、接口调用：http://2、具体代码（红色部分为主要解析代码）：/*** 日历导入根工具*/public class CalenderUtils {public static void main(String[] args) throws Exception {Prop p = e("jfinal_club_config_dev.txt");DruidPlugin druidPlugin = new DruidPlugin(p.get("jdbcUrl"), p.get("user"), p.get("password").trim());WallFilter wallFilter = new WallFilter();wallFilter.setDbType("mysql");druidPlugin.addFilter(wallFilter);druidPlugin.addFilter(new StatFilter());//me.add(druidPlugin);druidPlugin.start();ActiveRecordPlugin activeRecordPlugin = new ActiveRecordPlugin("mysql", druidPlugin);activeRecordPlugin.setContainerFactory(new CaseInsensitiveContainerFactory(true));_MappingKit.mapping(activeRecordPlugin);activeRecordPlugin.start();//arp.addMapping("c_workday", "id", Workday.class);List<Date> day2019 = getBetweenDates(new SimpleDateFormat("yyyy-MM-dd").parse("2020-01-01"), new SimpleDateFormat("yyyy-MM-dd").parse("2021-01-01"));for (Date day : day2019) {CloseableHttpClient httpCilent = HttpClients.createDefault();HttpGet httpGet = new HttpGet("/api/holiday/info/" + new SimpleDateFormat("yyyy-MM-dd").format(day));try {HttpResponse response = httpCilent.execute(httpGet);String line;JSONObject resultJsonObject;StringBuilder entityStringBuilder = new StringBuilder();BufferedReader b = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), "UTF-8"), 8 * 1024);while ((line = b.readLine()) != null) {entityStringBuilder.append(line);}//利用从HttpEntity中得到的String生成JsonObjectSystem.out.println(new SimpleDateFormat("yyyy-MM-dd").format(day) + "-->" + entityStringBuilder.toString());resultJsonObject = JSON.parseObject(entityStringBuilder.toString());Workday workday = new Workday();workday.setIsDelete(0);workday.setId(StringHELP.getUUID());workday.setDate(day);workday.setPublisher("1");workday.setPublisherName("admin");workday.setPublishDate(new Date());workday.setSubmitDate(new Date());workday.setStatus(0);workday.setStatuscashbag(1);//判断接口请求是否成功if(resultJsonObject.get("code").toString().equals("0")){//获取日期类型，进行相关逻辑处理//首先判断是否是节假日，是的话JSONObject objtype = JSON.parseObject(resultJsonObject.get("type").toString());System.out.println(objtype.get("type").toString());if(objtype.get("type").toString().equals("0")){workday.setType(1);}elseif(objtype.get("type").toString().equals("1")&&resultJsonObject.g et("holiday")==null){workday.setType(0);}else if(resultJsonObject.get("holiday")!=null){JSONObject objholiday = JSON.parseObject(resultJsonObject.get("holiday").toString());if(objholiday.get("holiday").toString().equals("true")){workday.setType(0);}else{workday.setType(1);}}}System.out.println("最终结果："+workday.getType());//workday.setType(resultJsonObject.getInteger("data") == 0 || resultJsonObject.getInteger("data") == 2 ? 1 : 0);workday.setYear(day.getYear() + 1900);workday.setMonth(day.getMonth() + 1);workday.save();} catch (Exception e) {e.printStackTrace();} finally {try {httpCilent.close();//释放资源} catch (IOException e) {e.printStackTrace();}}}}/*** 获取两个日期之间的日期，包括开始结束日期* @param start 开始日期* @param end 结束日期* @return 日期集合*/private static List<Date> getBetweenDates(Date start, Date end) {List<Date> result = new ArrayList<>();Calendar tempStart = Calendar.getInstance();tempStart.setTime(start);tempStart.add(Calendar.DAY_OF_YEAR, 1);Calendar tempEnd = Calendar.getInstance();tempEnd.setTime(end);result.add(start);while (tempStart.before(tempEnd)) {result.add(tempStart.getTime());tempStart.add(Calendar.DAY_OF_YEAR, 1);}return result;}}。
java中获取工作日时间的方法
java中获取工作日时间的方法（原创实用版4篇）《java中获取工作日时间的方法》篇1在Java 中，你可以通过使用`Calendar` 和`Date` 类来获取工作日时间。
以下是一个示例代码，用于获取当前时间的工作日信息：```javaimport java.util.Calendar;import java.util.Date;public class WorkDayExample {public static void main(String[] args) {// 获取当前时间Date currentDate = new Date();// 创建Calendar 对象并设置当前时间Calendar calendar = Calendar.getInstance();calendar.setTime(currentDate);// 获取当前时间的星期几（0 表示星期日，1 表示星期一，以此类推）int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);// 如果当前时间为工作日，则输出"今天是工作日"if (dayOfWeek == Calendar.MONDAY || dayOfWeek == Calendar.TUESDAY ||dayOfWeek == Calendar.WEDNESDAY || dayOfWeek == Calendar.THURSDAY ||dayOfWeek == Calendar.FRIDAY) {System.out.println("今天是工作日");} else {System.out.println("今天是周末");}}}```请注意，这个示例代码将输出当前时间的工作日信息。
《java中获取工作日时间的方法》篇2在Java 中，可以使用`Calendar` 和`Date` 类来获取工作日时间。
java处理节假日和工作时间的工具类
java处理节假⽇和⼯作时间的⼯具类import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Calendar;import java.util.Date;import java.util.List;/*** 节假⽇⼯作时间处理* 假⽇只处理今年、去年的 1.1、5.1、10.1，和周末*/public class HolidayUtil {private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");private static SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");private static List<String> holidays = new ArrayList<String>();/*** 静态块初始化法定节⽇*/static {Calendar c = Calendar.getInstance();holidays.add(c.get(Calendar.YEAR)-1 + "-01-01");holidays.add(c.get(Calendar.YEAR)-1 + "-05-01");holidays.add(c.get(Calendar.YEAR)-1 + "-10-01");holidays.add(c.get(Calendar.YEAR) + "-01-01");holidays.add(c.get(Calendar.YEAR) + "-05-01");holidays.add(c.get(Calendar.YEAR) + "-10-01");}/*** 判断当天是否是节假⽇节⽇只包含1.1；5.1；10.1** @param date 时间* @return ⾮⼯作时间：true;⼯作时间：false*/public static boolean isHolidayOrFestival(Date date) {boolean result = false;boolean isHolidayTmp = isHoliday(date);if (isHolidayTmp) {result = true;} else {Calendar c = Calendar.getInstance();c.setTime(date);//周末直接为⾮⼯作时间if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY || c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) { result = true;} else {//周内9点到17:30为⼯作时间int hour = c.get(Calendar.HOUR_OF_DAY);int minute = c.get(Calendar.MINUTE);if (hour < 9 || (hour == 17 && minute > 30) || hour >= 18) {result = true;}}}return result;}/*** ⾮⼯作时间获取最近的⼯作时间* @param date 时间* @return 返回处理后时间，格式：yyyy-MM-dd HH:mm:ss*/public static String getPreWorkDay(Date date) {Calendar c = Calendar.getInstance();c.setTime(date);if (!isHolidayOrFestival(date)) {return datechange(date, "yyyy-MM-dd HH:mm:ss");}//如果是周⽇最近的⼯作⽇为周五，⽇期减去2if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {c.add(Calendar.DAY_OF_MONTH, -2);}//如果是周六最近的⼯作⽇为周五，⽇期减去1else if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {c.add(Calendar.DAY_OF_MONTH, -1);}//如果是周⼀，并且为早上9点之前，最近的⼯作⽇为周五，⽇期减去3else if (c.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) {int hour = c.get(Calendar.HOUR_OF_DAY);if (hour < 9) {c.add(Calendar.DAY_OF_MONTH, -3);}}else{int hour = c.get(Calendar.HOUR_OF_DAY);if (hour < 9) {c.add(Calendar.DAY_OF_MONTH, -1);}}c.set(Calendar.HOUR_OF_DAY, 17);c.set(Calendar.MINUTE, 30);c.set(Calendar.SECOND, 0);return datechange(c.getTime(), "yyyy-MM-dd HH:mm:ss"); }public static String datechange(Date date, String pattern) { SimpleDateFormat sdf = new SimpleDateFormat(pattern); String demo = sdf.format(date);return demo;}/*** 根据判断当前时间是否是节⽇** @param date* 时间* @return*/private static boolean isHoliday(Date date) {boolean result = false;String dateStr = sdf.format(date);if (holidays.size() > 0) {for (String holiday : holidays) {if (holiday.equals(dateStr)) {result = true;break;}}}return result;}public static void main(String[] args) throws ParseException { String d = "2017-07-20 18:31:58";System.out.println(getPreWorkDay(sdf1.parse(d)));}}。
教你怎么用Java获取国家法定节假日
教你怎么⽤Java获取国家法定节假⽇前⾔此节假⽇为严格按照国家要求的双休和法定节假⽇并且包含节假⽇的补班信息，⼤家可根据⾃⼰的需求⾃定义处理哦。
以下为Maven配置，是程序⽤到的依赖。
版本的话，可以⽤最新的。
Maven配置<!-- okhttp --><dependency><groupId>com.squareup.okhttp</groupId><artifactId>okhttp</artifactId><version>${okhttp.version}</version></dependency><!-- fastjson --><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>${fastjson.version}</version></dependency>Java程序package com.uiotsoft.daily.task;import com.alibaba.fastjson.JSONObject;import com.squareup.okhttp.OkHttpClient;import com.squareup.okhttp.Request;import com.squareup.okhttp.Response;import java.io.IOException;import java.text.SimpleDateFormat;import java.util.*;/*** <p>TestDate 此类⽤于：</p>* <p>@author：hujm</p>* <p>@date：2021年04⽉22⽇ 17:43</p>* <p>@remark：</p>*/public class TestDate {public static void main(String[] args) {System.out.println(getJjr(2021, 4));System.out.println(getMonthWekDay(2021, 4));System.out.println(JJR(2021, 4));}/*** 获取周末和节假⽇** @param year* @param month* @return*/public static Set<String> JJR(int year, int month) {//获取所有的周末Set<String> monthWekDay = getMonthWekDay(year, month);//http://timor.tech/api/holiday api⽂档地址Map jjr = getJjr(year, month + 1);Integer code = (Integer) jjr.get("code");if (code != 0) {return monthWekDay;}Map<String, Map<String, Object>> holiday = (Map<String, Map<String, Object>>) jjr.get("holiday");Set<String> strings = holiday.keySet();for (String str : strings) {Map<String, Object> stringObjectMap = holiday.get(str);Integer wage = (Integer) stringObjectMap.get("wage");String date = (String) stringObjectMap.get("date");//筛选掉补班if (wage.equals(1)) {monthWekDay.remove(date);} else {monthWekDay.add(date);}}return monthWekDay;}/*** 获取节假⽇不含周末** @param year* @param month* @return*/private static Map getJjr(int year, int month) {String url = "http://timor.tech/api/holiday/year/";OkHttpClient client = new OkHttpClient();Response response;//解密数据String rsa = null;Request request = new Request.Builder().url(url).get().addHeader("Content-Type", "application/x-www-form-urlencoded").build();try {response = client.newCall(request).execute();rsa = response.body().string();} catch (IOException e) {e.printStackTrace();}return JSONObject.parseObject(rsa, Map.class);}/*** 获取周末⽉从0开始** @param year* @param mouth* @return*/public static Set<String> getMonthWekDay(int year, int mouth) {Set<String> dateList = new HashSet<>();SimpleDateFormat simdf = new SimpleDateFormat("yyyy-MM-dd");Calendar calendar = new GregorianCalendar(year, mouth, 1);Calendar endCalendar = new GregorianCalendar(year, mouth, 1);endCalendar.add(Calendar.MONTH, 1);while (true) {int weekday = calendar.get(Calendar.DAY_OF_WEEK);if (weekday == 1 || weekday == 7) {dateList.add(simdf.format(calendar.getTime()));}calendar.add(Calendar.DATE, 1);if (calendar.getTimeInMillis() >= endCalendar.getTimeInMillis()) {break;}}return dateList;}}以上⽅法可以拿来即⽤，当然也可以根据⾃⼰的需求⾃定义。
Java排除法定节假日、周六日以及工作日午休，计算两个Date相差的时间
Java排除法定节假⽇、周六⽇以及⼯作⽇午休，计算两个Date相差的时间系统考勤请假中的⽅法：1、在选中时间区间后，排除掉法定的节假⽇、正常双休和午休的两个⼩时，同时将调休⽇算作正常⼯作时间。
2、最后返回的天数是double类型的，是半天或是整天。
代码部分：1、从页⾯拿到开始时间和结束时间（页⾯⽤的是vue.js），当前是String类型/*** 计算请假天数*/@Login@RequestMapping("/calculationTime")public R calculationTime(@RequestParam Map<String, Object> params){DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");double dayTime = 0;dayTime = wxUserHolidayService.calculationTime(String.valueOf(params.get("stime")), String.valueOf(params.get("etime")));double days = wxUserHolidayService.halfDayMath(dayTime);return R.ok().put("days",days);}2、需要的具体⽅法，根据需要进⾏取舍package com.hnzie.modules.kaoqin.service;import com.baomidou.mybatisplus.service.IService;import com.hnzie.modules.kaoqin.entity.WxUserHolidayEntity;import java.util.*;public interface WxUserHolidayService extends IService<WxUserHolidayEntity> {// 获取假期⽇期String[] holiday1();// 获取调休⼯作⽇期String[] holiday2();// 获取除午休的⼯作时间String[] workTimes();/*** 计算请假天数，去除周末、节假⽇* @param stime* @param etime*/double calculationTime(String stime, String etime);/*** 去重* @param str*/List<String> removal(List<String> str);/*** 获取两个⽇期之间的所有⽇期，去掉周末* @param startDate* @param endDate* @return*/List<String> getDates(String startDate, String endDate);/*** 字符串转时间* @param dateStr* @param index* @return*/Date StringToDate(String dateStr, int index);/*** 时间转字符串* @param date* @param index* @return*/String dateToString(Date date, int index);/*** 获取法定节假⽇或者调休* @param num* @return*/List<String> holiday(int num);/*** 获取不同部门⼯作时间* @return*/String[] workTime();// 计算整天或半天double halfDayMath(double time);}3、实现⽅法package com.hnzie.modules.kaoqin.service.impl;import com.baomidou.mybatisplus.service.impl.ServiceImpl;import com.hnzie.modules.kaoqin.dao.WxUserHolidayDao;import com.hnzie.modules.kaoqin.entity.WxUserHolidayEntity;import com.hnzie.modules.kaoqin.service.WxQingjiaMaintainService;import com.hnzie.modules.kaoqin.service.WxUserHolidayService;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.*;@Service("wxUserHolidayService")@Slf4jpublic class WxUserHolidayServiceImpl extends ServiceImpl<WxUserHolidayDao, WxUserHolidayEntity> implements WxUserHolidayService { /*** 定义常见的时间格式*/private static String[] dateFormat = {"yyyy-MM-dd HH:mm:ss", // 0"yyyy/MM/dd HH:mm:ss", // 1"yyyy年MM⽉dd⽇HH时mm分ss秒", // 2"yyyy-MM-dd", // 3"yyyy/MM/dd", // 4"yy-MM-dd", // 5"yy/MM/dd", // 6"yyyy年MM⽉dd⽇", // 7"HH:mm:ss", // 8"yyyyMMddHHmmss", // 9"yyyyMMdd", // 10"yyyy.MM.dd", // 11"yy.MM.dd", // 12"MM⽉dd⽇HH时mm分", // 13"yyyy年MM⽉dd⽇ HH:mm:ss", // 14"yyyy-MM-dd HH:mm", // 15"yyMMdd" // 16};@Overridepublic String[] holiday1() {return baseMapper.selectLawHolidayDate();}@Overridepublic String[] holiday2() {return baseMapper.selectLawWorkDate();}@Overridepublic String[] workTimes() {String S = baseMapper.selectTimeTable(Const.timeTableKey);Map<String,Object> parse = (Map<String,Object>)JSON.parse(S);String[] times = new String[4];times[0] = String.valueOf(parse.get("SstartTime"));times[1] = String.valueOf(parse.get("SendTime"));times[2] = String.valueOf(parse.get("XstartTime"));times[3] = String.valueOf(parse.get("XendTime"));return times;}@Overridepublic double calculationTime(String startTime, String endTime) {// 获取startTime和endTime之间的所有⽇期，去掉周六周⽇List<String> list = this.getDates(startTime, endTime);// 获取法定节假⽇List<String> fdList = this.holiday(1);// 获取调休List<String> txList = this.holiday(2);// 上班时间String[] workTime = this.workTime();String[] split = workTime[2].split(":");String[] split1 = workTime[1].split(":");//午休时间int wxTime = (Integer.valueOf(split[0]) - Integer.valueOf(split1[0])) * 60;// 删除时间区间中的所有法定节假⽇list.removeAll(fdList);DateFormat df = new SimpleDateFormat(dateFormat[3]);String st =startTime.substring(0, 10);String en =endTime.substring(0, 10);try {Date sts =df.parse(startTime.substring(0, 10));Date ens =df.parse(endTime.substring(0, 10));for (String s : txList) {Date ss =df.parse(s);if ((ss.before(ens) && ss.after(sts)) || ss.equals(sts) || ss.equals(ens)) {// 添加时间区间中的所有调休⽇期list.add(s);}}}catch (Exception e){e.printStackTrace();}// 去重list = this.removal(list);// 开始当天上午上班时间、上午下班时间、下午上班时间、下午下班时间String amWorkYes = startTime.substring(0, 11) + workTime[0];String amWorkNo = startTime.substring(0, 11) + workTime[1];String pmWorkYes = startTime.substring(0, 11) + workTime[2];String pmWorkNo = startTime.substring(0, 11) + workTime[3];// 结束当天上午上班时间、上午下班时间、下午上班时间、下午下班时间String amWorkYesEnd = endTime.substring(0, 11) + workTime[0];String amWorkNoEnd = endTime.substring(0, 11) + workTime[1];String pmWorkYesEnd = endTime.substring(0, 11) + workTime[2];String pmWorkNoEnd = endTime.substring(0, 11) + workTime[3];double time = 0;if (list.size() == 0) {// 申请⽇期是法定节假⽇return time;} else if (list.size() == 1) {// 请假⼀天if (pareTo(pmWorkNo) > 0) {return time;}if (pareTo(amWorkYes) < 0) {return time;}if (pareTo(amWorkNo) >= 0 && pareTo(pmWorkYes) <= 0) {return time;}// 开始时间⼩于上午上班时间，开始时间等于上午上班时间if (pareTo(amWorkYes) < 0) {startTime = amWorkYes;}// 结束时间⼤于下午下班时间，结束时间等于下午下班时间if (pareTo(pmWorkNo) > 0) {endTime = pmWorkNo;}// 开始时间⼤于上午下班时间，⼩于下午上班时间，开始时间等于下午上班时间if (pareTo(amWorkNo) >= 0 && pareTo(pmWorkYes) <= 0) { startTime = pmWorkYes;}// 结束时间⼤于上午下班时间，⼩于下午上班时间，结束时间等于上午下班时间if (pareTo(amWorkNo) >= 0 && pareTo(pmWorkYes) <= 0) {endTime = amWorkNo;}Date start = this.StringToDate(startTime, 15); // 0或者15Date end = this.StringToDate(endTime, 15);// 三种情况，1：请假时间全在上午，2：请假时间全在下午，3：包含午休时间if (pareTo(amWorkYes) >= 0 && pareTo(amWorkNo) <= 0) {double minute = (end.getTime() - start.getTime()) / (1000 * 60);time = minute / (8 * 60);} else if (pareTo(pmWorkYes) >= 0 && pareTo(pmWorkNo) <= 0) { double minute = (end.getTime() - start.getTime()) / (1000 * 60);time = minute / (8 * 60);} else if (pareTo(amWorkNo) < 0 && pareTo(pmWorkYes) > 0) { double minute = (end.getTime() - start.getTime()) / (1000 * 60) - wxTime;time = minute / (8 * 60);}return time;} else {// 处理请假多天的情况// 申请开始时间处理if (list.contains(st)) {if (pareTo(amWorkYes) < 0) {startTime = amWorkYes;}if (pareTo(pmWorkNo) > 0) {startTime = pmWorkNo;}if (pareTo(amWorkNo) >= 0 && pareTo(pmWorkYes) <= 0) {startTime = pmWorkYes;}Date start = this.StringToDate(startTime, 15); // 0或者15Date end = this.StringToDate(pmWorkNo, 15);if (pareTo(amWorkNo) < 0) {// 减去中午⼀⼩时double t = (end.getTime() - start.getTime()) / (1000 * 60) - wxTime;time = time + t / (8 * 60);} else {double t = (end.getTime() - start.getTime()) / (1000 * 60);time = time + t / (8 * 60);}list.remove(st);}// 申请结束时间处理if (list.contains(en)) {if (pareTo(amWorkYesEnd) < 0) {endTime = amWorkYesEnd;}if (pareTo(pmWorkNoEnd) > 0) {endTime = pmWorkNoEnd;}if (pareTo(amWorkNoEnd) >= 0 && pareTo(pmWorkYesEnd) <= 0) { endTime = amWorkNoEnd;}Date end = this.StringToDate(endTime, 15);// 0或者15Date start = this.StringToDate(amWorkYesEnd, 15);if (pareTo(pmWorkYesEnd) > 0) {double t = (end.getTime() - start.getTime()) / (1000 * 60) - wxTime;time = time + t / (8 * 60);} else {double t = (end.getTime() - start.getTime()) / (1000 * 60);time = time + t / (8 * 60);}list.remove(en);}// 天数计算集合中剩下的个数就可以time = time + list.size();return time;}}/*** 去重* @param str*/@Overridepublic List<String> removal(List<String> str) {Set<String> s = new HashSet<String>(str);str.clear();str.addAll(s);}/*** 获取两个⽇期之间的所有⽇期，去掉周末* @param startDate* @param endDate*/@Overridepublic List<String> getDates(String startDate, String endDate) { List<String> result = new ArrayList<String>();Calendar startDay = Calendar.getInstance();Calendar endDay = Calendar.getInstance();startDay.setTime(StringToDate(startDate, 3));endDay.setTime(StringToDate(endDate, 3));while (startDay.before(endDay)) {int week = startDay.get(Calendar.DAY_OF_WEEK);if (7 != week && 1 != week) {result.add(dateToString(startDay.getTime(), 3));}startDay.add(Calendar.DAY_OF_YEAR, 1);}// 验证结束⽇期是否是周六周⽇int week = endDay.get(Calendar.DAY_OF_WEEK);if (7 != week && 1 != week) {result.add(dateToString(endDay.getTime(), 3));}return result;}/*** 字符串转时间* @param dateStr* @param index*/@Overridepublic Date StringToDate(String dateStr, int index) {DateFormat df = null;try {df = new SimpleDateFormat(dateFormat[index]);return df.parse(dateStr);} catch (Exception aioe) {return null;}}/*** 时间转字符串* @param date* @param index*/@Overridepublic String dateToString(Date date, int index) {if (date == null) {return null;}return new SimpleDateFormat(dateFormat[index]).format(date); }/*** 获取法定节假⽇或者调休* @param num*/@Overridepublic List<String> holiday(int num) {if (num == 2) {return Arrays.asList(this.holiday2());} else {return Arrays.asList(this.holiday1());}}/*** 获取不同部门⼯作时间*/@Overridepublic String[] workTime() {return this.workTimes();}public double halfDayMath(double time){String timeStr = time+"";System.out.println("timeStr = [" + timeStr + "]");String[] timeArr = timeStr.split("\\.");int t1 = Integer.valueOf(timeArr[0]);System.out.println("t1 = [" + t1 + "]");int t2 = Integer.valueOf(timeArr[1].substring(0, 1));System.out.println("t2 = [" + t2 + "]");if (t2 < 5){return t1;}else if (t2>5){t1++;return t1;}else {return t1+0.5f;}}}4、dao层的⽅法package com.hnzie.modules.kaoqin.dao;import com.baomidou.mybatisplus.mapper.BaseMapper;import com.hnzie.modules.kaoqin.entity.WxUserHolidayEntity;import org.apache.ibatis.annotations.Param;public interface WxUserHolidayDao extends BaseMapper<WxUserHolidayEntity> {//查询所有节假⽇String[] selectLawHolidayDate();//查询所有调休(上班)⽇String[] selectLawWorkDate();String selectTimeTable(@Param("key") String key);}5、mapper中sql语句<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.hnzie.modules.kaoqin.dao.WxUserHolidayDao"><select id="selectLawHolidayDate" resultType="String">select time from wx_kq_qingjia_maintain where del_flag = 0 and time_type = 2</select><select id="selectLawWorkDate" resultType="String">select time from wx_kq_qingjia_maintain where del_flag = 0 and time_type = 1</select><!-- 配置表中查询的⼯作时间 --><select id="selectTimeTable" resultType="String">select param_value as paramValue from sys_config where status = 1 and param_key = #{key}</select></mapper>节假⽇和调休⽇需要读取放在数据库中的数据只排除节假⽇和周六⽇的。
java 获取当月工作日天数的方法
java 获取当月工作日天数的方法《Java获取当月工作日天数的方法》1. 前言在日常工作和生活中，我们经常需要计算当月工作日的天数，以便有效地安排工作和生活计划。
而在编程领域，特别是在Java开发中，如何获取当月工作日天数的方法成为了一个常见的需求。
本文将针对这一主题展开讨论，从简单的方法到更深入的算法，带你深入理解和掌握Java中获取当月工作日天数的方法。
2. 简单方法在Java中，最简单的方法是利用循环遍历当月的每一天，然后判断每一天是不是工作日。
通常情况下，周六和周日被认为是非工作日，而其他时间则是工作日。
我们可以编写一个简单的程序来统计当月的工作日天数。
```javaimport java.time.DayOfWeek;import java.time.LocalDate;public class WorkdayCounter {public static int countWorkdaysInMonth(int year, int month) { int totalDays = 0;int workdays = 0;LocalDate date = LocalDate.of(year, month, 1);while (date.getMonthValue() == month) {totalDays++;if (date.getDayOfWeek() != DayOfWeek.SATURDAY && date.getDayOfWeek() != DayOfWeek.SUNDAY) {workdays++;}date = date.plusDays(1);}return workdays;}public static void main(String[] args) {int year = 2022;int month = 10;int workdays = countWorkdaysInMonth(year, month);System.out.println("The number of workdays in " + year + "/" + month + " is: " + workdays);}}```以上代码中，我们使用了Java 8中的`LocalDate`类来表示日期，并利用`DayOfWeek`枚举类型来判断工作日。
java 判断5个工作日的方法
java 判断5个工作日的方法以Java判断5个工作日的方法在日常的工作中，我们经常需要判断某个日期的前后是否包含了5个工作日。
在这篇文章中，我们将介绍如何使用Java来实现这个功能。
我们需要明确什么是工作日。
通常情况下，工作日是指周一至周五，不包括周末（周六和周日）。
因此，我们需要考虑周末对日期计算的影响。
接下来，我们就可以开始编写代码了。
我们可以使用Java中的Calendar类来进行日期计算。
下面是一个示例代码：```javaimport java.util.Calendar;public class WorkdayCalculator {public static void main(String[] args) {// 获取当前日期Calendar calendar = Calendar.getInstance();// 计算5个工作日后的日期int count = 0;while (count < 5) {calendar.add(Calendar.DAY_OF_MONTH, 1);// 判断是否是周末if (calendar.get(Calendar.DAY_OF_WEEK) != Calendar.SATURDAY&& calendar.get(Calendar.DAY_OF_WEEK) != Calendar.SUNDAY) {count++;}}// 输出计算结果System.out.println("5个工作日后的日期是：" + calendar.getTime());}}```上面的代码中，我们首先获取了当前日期，然后使用一个循环来计算5个工作日后的日期。
在每次循环中，我们通过`add`方法将日期增加1天，并使用`get`方法获取当前日期是周几。
如果不是周末（即不是周六和周日），则将计数器`count`加1。
当计数器`count`达到5时，循环结束，我们就得到了5个工作日后的日期。
java 加班规则表设计
java 加班规则表设计
设计Java加班规则表涉及到对加班管理的需求分析、数据库表
设计和业务逻辑的实现。
首先，我们需要确定加班规则表的字段，
一般包括员工ID、加班日期、加班开始时间、加班结束时间、加班
时长、加班原因等。
接下来，我们需要设计数据库表结构，可以创
建一个名为overtime_rule的表来存储加班规则信息。
表中的字段
可以包括employee_id、overtime_date、start_time、end_time、overtime_hours、reason等字段。
在设计表结构时，需要考虑到数
据的准确性和完整性，可以设置一些字段为必填项，比如加班日期、加班时长和加班原因。
此外，还可以考虑添加一些约束条件，比如
加班时长不能超过一定的小时数，加班日期不能超出当前日期等。
在实际业务中，加班规则表的设计还需要考虑到加班申请流程、加班审批流程等业务逻辑。
可以设计一个加班申请表和加班审批表，与加班规则表进行关联，实现加班申请的提交、审批和记录功能。
此外，还可以考虑加入加班补偿的计算规则，根据加班时长和员工
级别等因素计算加班工资或补偿假期等。
总的来说，设计Java加班规则表需要综合考虑业务需求、数据
库表设计和业务逻辑的实现，确保加班管理系统能够满足企业的实
际需求，并且具有良好的扩展性和灵活性。
希望以上回答能够全面地解答你的问题。
计算两个日期之间的工作日（去掉周末和节假日）
计算两个⽇期之间的⼯作⽇（去掉周末和节假⽇）公司要写售后的⼀个功能，⽤到这个功能，在⼀个贴吧上找到的，整理⼀下，package mons;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Calendar;import java.util.Date;import java.util.Iterator;import java.util.List;import ponent;/*** 获取⼯作⽇* <br>创建⽇期：2016年7⽉21⽇* <br><b>Copyright 2016 UTOUU All Rights Reserved</b>* @author zhushuangshuang* @since 1.0* @version 1.0*/@Componentpublic class GetWorkDay {/*** 获取两个时间之内的⼯作⽇时间（只去掉两个⽇期之间的周末时间，法定节假⽇未去掉）** @param start* -起始时间，共有3个重载⽅法，可以传⼊long型，Long型，与Date型* @param end* -结束时间，共有3个重载⽅法，可以传⼊long型，Long型，与Date型* @return Long型时间差对象*//*public static void main(String[] args) {GetWorkDay g=new GetWorkDay();List<Date> initHoliday;try {initHoliday = g.initHoliday();double days = g.getWorkdayTimeInMillisExcWeekendHolidays("2016-06-30 17-12-53","2016-08-30 11-27-50","yyyy-MM-dd HH-mm-ss",initHoliday); double formateToDay = g.formateToDay(days);String formatDuring = g.formatDuring(days);System.out.println(formateToDay);System.out.println(formatDuring);} catch (ParseException e) {// TODO Auto-generated catch blocke.printStackTrace();}} */private double getWorkdayTimeInMillis(long start, long end,List<Date> listHolidays) {// 如果起始时间⼤于结束时间，将⼆者交换if (start > end) {long temp = start;start = end;end = temp;}// 根据参数获取起始时间与结束时间的⽇历类型对象Calendar sdate = Calendar.getInstance();Calendar edate = Calendar.getInstance();sdate.setTimeInMillis(start);edate.setTimeInMillis(end);// 计算指定时间段内法定节假⽇天数的毫秒数long holidays = 0;if (listHolidays != null) {holidays = getHolidaysInMillis(start, end, listHolidays);listHolidays.clear();}// 如果两个时间在同⼀周并且都不是周末⽇期，则直接返回时间差，增加执⾏效率if ((sdate.get(Calendar.YEAR) == edate.get(Calendar.YEAR))&& (sdate.get(Calendar.WEEK_OF_YEAR) == edate.get(Calendar.WEEK_OF_YEAR))&& (sdate.get(Calendar.DAY_OF_WEEK) != 1 && sdate.get(Calendar.DAY_OF_WEEK) != 7)&& (edate.get(Calendar.DAY_OF_WEEK) != 1 && edate.get(Calendar.DAY_OF_WEEK) != 7)) {return new Long(end - start - holidays);}// 如果两个时间在同⼀周并且都是周末⽇期，则直接返回0if ((sdate.get(Calendar.YEAR) == edate.get(Calendar.YEAR))&& (sdate.get(Calendar.WEEK_OF_YEAR) == edate.get(Calendar.WEEK_OF_YEAR)-1)&& (sdate.get(Calendar.DAY_OF_WEEK) == 1|| sdate.get(Calendar.DAY_OF_WEEK) == 7)&&(edate.get(Calendar.DAY_OF_WEEK) == 1|| edate.get(Calendar.DAY_OF_WEEK) == 7)) {start=validateStartTime(sdate);end=validateEndTime(edate);long result=end - start - holidays;return new Long(result>0?result:0);}start=validateStartTime(sdate);end=validateEndTime(edate);// ⾸先取得起始⽇期与结束⽇期的下个周⼀的⽇期Calendar snextM = getNextMonday(sdate);Calendar enextM = getNextMonday(edate);// 获取这两个周⼀之间的实际天数int days = getDaysBetween(snextM, enextM);// 获取这两个周⼀之间的⼯作⽇数(两个周⼀之间的天数肯定能被7整除，并且⼯作⽇数量占其中的5/7)int workdays = days / 7 * 5;// 计算最终结果，具体为：workdays加上开始时间的时间偏移量，减去结束时间的时间偏移量double a=(double)workdays*24*3600000;double result = (a + calcWorkdayTimeInMillis(sdate, edate, start, end) - holidays);return result > 0 ? result : 0;}/**** 验证开始⽇期是否合法,如果不合法,并返回修复后的正确⽇期毫秒数* @param sdate* @return*/private long validateStartTime(Calendar sdate){if(sdate.get(Calendar.DAY_OF_WEEK) == 1)//开始⽇期从周⽇开始,如果开始时间为周末，⾃动修复为下周的9：00开始{sdate.add(Calendar.DATE,1);sdate.setTimeInMillis(sdate.getTime().getTime()- //从9点开始(((sdate.get(Calendar.HOUR_OF_DAY)-9) * 3600000)+ (sdate.get(Calendar.MINUTE) * 60000)+ (sdate.get(Calendar.SECOND) * 1000))); }else if(sdate.get(Calendar.DAY_OF_WEEK) == 7){//开始⽇期从周六开始sdate.add(Calendar.DATE,2);sdate.setTimeInMillis(sdate.getTime().getTime()- //从9点开始,如果开始时间为周末，⾃动修复为下周的9：00开始(((sdate.get(Calendar.HOUR_OF_DAY)-9) * 3600000)+ (sdate.get(Calendar.MINUTE) * 60000)+ (sdate.get(Calendar.SECOND) * 1000)));}return sdate.getTimeInMillis();}/**** 验证结束⽇期是否合法,如果不合法,并返回修复后的正确⽇期毫秒数* @param sdate* @return*/private long validateEndTime(Calendar edate){if(edate.get(Calendar.DAY_OF_WEEK) == 1)//结束⽇期是周⽇,如果结束⽇期是周六、周末⾃动修复为这周五18:00{edate.add(Calendar.DATE,-2);edate.setTimeInMillis(edate.getTime().getTime()+(18*3600000-((edate.get(Calendar.HOUR_OF_DAY) * 3600000)+ (edate.get(Calendar.MINUTE) * 60000)+ (edate.get(Calendar.SECOND) * 1000))));}else if(edate.get(Calendar.DAY_OF_WEEK) == 7){//结束⽇期是周六,如果结束⽇期是周六、周末⾃动修复为这周五18:00edate.add(Calendar.DATE,-1);edate.setTimeInMillis(edate.getTime().getTime()+(18*3600000-((edate.get(Calendar.HOUR_OF_DAY) * 3600000)+ (edate.get(Calendar.MINUTE) * 60000)+ (edate.get(Calendar.SECOND) * 1000))));}return edate.getTimeInMillis();}/**** 计算两个⽇期间的⼯作⽇天数，除周六⽇** @param sdate* @param edate* @return*/private long calcWorkdayTimeInMillis(Calendar sdate, Calendar edate,long start, long end) {// 获取开始时间的偏移量long scharge = 0;if (sdate.get(Calendar.DAY_OF_WEEK) != 1&& sdate.get(Calendar.DAY_OF_WEEK) != 7) {// 只有在开始时间为⾮周末的时候才计算偏移量scharge += (sdate.get(Calendar.HOUR_OF_DAY) * 3600000);scharge += (sdate.get(Calendar.MINUTE) * 60000);scharge += (sdate.get(Calendar.SECOND) * 1000);scharge = ((24 * 3600000) - scharge);scharge += ((sdate.getTime().getTime() - start) - (3 * 24 * 3600000));}// (24*3600000=86400000)-((9*3600000+1800000)=34200000)+(3*24*3600000=259200000)-(2*24*3600000)=// 86400000-34200000=52200000// 获取结束时间的偏移量long echarge = 0;if (edate.get(Calendar.DAY_OF_WEEK) != 1&& edate.get(Calendar.DAY_OF_WEEK) != (7)) {// 只有在结束时间为⾮周末的时候才计算偏移量echarge += (edate.get(Calendar.HOUR_OF_DAY) * 3600000);echarge += (edate.get(Calendar.MINUTE) * 60000);echarge += (edate.get(Calendar.SECOND) * 1000);echarge = ((24 * 3600000) - echarge);echarge += (edate.getTime().getTime() - end) - (24 * 3600000);echarge -= (2 * 24 * 3600000);}// (24*3600000=86400000)-(18*3600000=64800000)+(24*3=259200000)if (scharge < 0 || echarge < 0)scharge = echarge = 0;return scharge - echarge;}/*** 获取两个时间之内的⼯作⽇时间（只去掉两个⽇期之间的周末时间，法定节假⽇未去掉）** @param start* -起始时间，共有3个重载⽅法，可以传⼊long型，Long型，与Date型* @param end* -结束时间，共有3个重载⽅法，可以传⼊long型，Long型，与Date型* @return Long型时间差对象*/public double getWorkdayTimeInMillisExcWeekend(long start, long end) {return getWorkdayTimeInMillis(start, end);}/**** 获取两个时间之内的⼯作⽇时间（去掉两个⽇期之间的周末时间，法定节假⽇时间）** @param start* @param end* @return*/public double getWorkdayTimeInMillisExcWeekendHolidays(String start,String end, String format, List<Date> listHolidays) { SimpleDateFormat sdf = new SimpleDateFormat(format);Date sdate;Date edate;try {sdate = sdf.parse(start);edate = sdf.parse(end);return getWorkdayTimeInMillis(sdate.getTime(), edate.getTime(),listHolidays);} catch (ParseException e) {e.printStackTrace();return new Long(0);}}public double getWorkdayTimeInMillis(Long start, Long end) {return getWorkdayTimeInMillis(start.longValue(), end.longValue(), null);}public double getWorkdayTimeInMillis(Date start, Date end) {return getWorkdayTimeInMillis(start.getTime(), end.getTime(), null);}public double getWorkdayTimeInMillis(String start, String end, String format) {SimpleDateFormat sdf = new SimpleDateFormat(format);Date sdate;Date edate;try {sdate = sdf.parse(start);edate = sdf.parse(end);return getWorkdayTimeInMillis(sdate, edate);} catch (ParseException e) {e.printStackTrace();return new Long(0);}}private long getHolidaysInMillis(long start, long end,List<Date> listHolidays) {Calendar scalendar = Calendar.getInstance();Calendar ecalendar = Calendar.getInstance();int daysofH = 0;try {scalendar.setTimeInMillis(start);ecalendar.setTimeInMillis(end);if (listHolidays == null)return new Long(0);Iterator<Date> iterator = listHolidays.iterator();while (iterator.hasNext()) {Calendar ca = Calendar.getInstance();Date hdate = iterator.next();ca.setTime(hdate);if (ca.after(scalendar) && ca.before(ecalendar)) {daysofH = daysofH + 1;} else if (ca.getTimeInMillis() == scalendar.getTimeInMillis()) {daysofH = daysofH + 1;} else if (ca.getTimeInMillis() == ecalendar.getTimeInMillis()) {daysofH = daysofH + 1;}}} catch (Exception e) {e.printStackTrace();return new Long(0);}return daysofH * 24 * 3600000;}private Calendar getNextMonday(Calendar cal) {int addnum = 9 - cal.get(Calendar.DAY_OF_WEEK);if (addnum == 8)addnum = 1;// 周⽇的情况cal.add(Calendar.DATE, addnum);return cal;}/**** @param mss* @param要转换的毫秒数* @return该毫秒数转换为 * days * hours * minutes * seconds 后的格式 */public String formatDuring(double mss) {long days = (long) (mss / (1000 * 60 * 60 * 24));long hours = (long) ((mss % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));long minutes = (long) ((mss % (1000 * 60 * 60)) / (1000 * 60));long seconds = (long) ((mss % (1000 * 60)) / 1000);return days + " days " + hours + " hours " + minutes + " minutes "+ seconds + " seconds ";}/*** 获取两个⽇期之间的实际天数，⽀持跨年* @param start* @param end**//*** 获得两个⽇期之间的⼯作⽇* @since 1.0* @param mss* @return* <br><b>作者：@author zhushunagshuang</b>* <br>创建时间：2016年7⽉21⽇下午3:12:23*/public double formateToDay(double mss){double days = mss / (1000 * 60 * 60 * 24);return days;}public int getDaysBetween(Calendar start, Calendar end) {if (start.after(end)) {Calendar swap = start;start = end;end = swap;}int days = end.get(Calendar.DAY_OF_YEAR)- start.get(Calendar.DAY_OF_YEAR);int y2 = end.get(Calendar.YEAR);if (start.get(Calendar.YEAR) != y2) {start = (Calendar) start.clone();do {days += start.getActualMaximum(Calendar.DAY_OF_YEAR);start.add(Calendar.YEAR, 1);} while (start.get(Calendar.YEAR) != y2);}return days;}/*** ⼿动维护2016年的节假⽇* @since 1.0* @return* @throws ParseException* <br><b>作者：@author zhushunagshuang</b>* <br>创建时间：2016年7⽉21⽇下午5:12:08*/public List<Date> initHoliday() throws ParseException{List<Date> holidays = new ArrayList<Date>();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//元旦holidays.add(sdf.parse("2016-01-01"));holidays.add(sdf.parse("2016-01-02"));holidays.add(sdf.parse("2016-01-03"));//春节holidays.add(sdf.parse("2016-02-07"));holidays.add(sdf.parse("2016-02-08"));holidays.add(sdf.parse("2016-02-09"));holidays.add(sdf.parse("2016-02-10"));holidays.add(sdf.parse("2016-02-11"));holidays.add(sdf.parse("2016-02-12"));holidays.add(sdf.parse("2016-02-13"));//清明节holidays.add(sdf.parse("2016-04-02"));holidays.add(sdf.parse("2016-04-03"));holidays.add(sdf.parse("2016-04-04"));//劳动节holidays.add(sdf.parse("2016-04-30"));holidays.add(sdf.parse("2016-05-01"));holidays.add(sdf.parse("2016-05-02"));//端午节holidays.add(sdf.parse("2016-06-09"));holidays.add(sdf.parse("2016-06-10"));holidays.add(sdf.parse("2016-06-11"));//中秋节holidays.add(sdf.parse("2016-09-15"));holidays.add(sdf.parse("2016-09-16"));holidays.add(sdf.parse("2016-09-17"));//国庆节holidays.add(sdf.parse("2016-10-01"));holidays.add(sdf.parse("2016-10-02"));holidays.add(sdf.parse("2016-10-03"));holidays.add(sdf.parse("2016-10-04"));holidays.add(sdf.parse("2016-10-05"));holidays.add(sdf.parse("2016-10-06"));holidays.add(sdf.parse("2016-10-07"));return holidays;}}贴出来。
Java实现根据输入的日期以及天数，获取此日期之后的天数的工作日
public static Date getDate(String str) { try { return new SimpleDateFormat("yyyy-MM-dd").parse(str); } catch (ParseException ex) { Logger.getLogger(T05.class.getName()).log(Level.SEVERE, null, ex); }
Date curDate = getDate("2017-06-23"); int days = 3;
for (int i = 1; i <= days;) { curDate = addDays(curDate);
if(!list.contains(new SimpleDateFormat("yyyy-MM-dd").format(curDate))){ i++;
return null; }
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
Java实 现 根 据 输 入 的 日 期 以 及 天 数 ， 获 取 此 日 期 之 后 的 天 数 的 工作日
public static void main(String[] args) {
List<String> list = new ArrayList<String>();//节假日列表，正式环境中根据日期条件从数据库中获取 list.add("2017-06-24"); list.add("2017-06-25"); list.add("2017-07-01"); list.add("2017-07-02"); list.add("2017-07-08"); list.add("2017-07-09");
java计算两个日期之间的天数，排除节假日和周末
java计算两个⽇期之间的天数，排除节假⽇和周末如题所说，计算两个⽇期之前的天数，排除节假⽇和周末。
这⾥天数的类型为double，因为该功能实现的是请假天数的计算，有请⼀上午假的为0.5天。
严谨的做法是每个⽇期都要查询数据库，但是总体下来很浪费时间。
ps： 1.节假⽇存放在数据库中实现步骤： 1.循环每个⽇期 2.判断每个⽇期是否为节假⽇或者为周末 3.若不是节假⽇和周末，天数+1public double calLeaveDays(Date startTime,Date endTime){double leaveDays = 0;//从startTime开始循环，若该⽇期不是节假⽇或者不是周六⽇则请假天数+1Date flag = startTime;//设置循环开始⽇期Calendar cal = Calendar.getInstance();//从数据库得到节假⽇的起始⽇期和终⽌⽇期List<Map> maps = null;try{maps = getDao().getHolidaysPeriod;//maps⽤于保存符合条件的所有节假⽇的起始⽇期和终⽌⽇期，如startDate:2017-07-13,endDate:2017-07-14}catch (Exception e){e.printStackTrace();} //⽤于格式化⽇期SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");int week;outer:while(pareTo(endTime)!=1){cal.setTime(flag);//判断是否为周六⽇week = cal.get(Calendar.DAY_OF_WEEK) - 1;if(week == 0 || week == 6){//0为周⽇，6为周六//跳出循环进⼊下⼀个⽇期cal.add(Calendar.DAY_OF_MONTH, +1);flag = cal.getTime();continue;}else{//判断是否为节假⽇if(maps != null || !maps.isEmpty()){inner:for (Map map : maps){if(pareTo((Date)map.get("startDay"))>-1&&pareTo((Date)map.get("endDay"))<1){ //跳出循环进⼊下⼀个⽇期 cal.add(Calendar.DAY_OF_MONTH, +1);flag = cal.getTime();continue outer;}}}}leaveDays = leaveDays + 1;//⽇期往后加⼀天cal.add(Calendar.DAY_OF_MONTH, +1);flag = cal.getTime();}return leaveDays;}。
Java计算工作日的工具类
Java计算⼯作⽇的⼯具类 有时候需要根据⼯作⽇计算指定的⽇期，也就是需要排除周六⽇。
1. 初版代码如下：package cn.xm.exam.utils;import java.util.Calendar;import java.util.Date;import ng.time.DateFormatUtils;public class WorkDayCalculateUtils {public static void main(String[] args) {Date date = getDate(new Date(), -7);System.out.println(DateFormatUtils.format(date, "yyyy-MM-dd"));}public static Date getDate(Date currentDate, int days) {if (days == 0) {return currentDate;}Calendar calendar = Calendar.getInstance();calendar.setTime(currentDate);int step = days < 0 ? -1 : 1;int i = 0;int daysAbs = Math.abs(days);while (i < daysAbs) {calendar.add(Calendar.DATE, step);i++;if (calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY|| calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {i--;}}return calendar.getTime();}}结果：2019-08-14⽇历如下：2. 排除特殊⼯作⽇和休息⽇ 上⾯是按照所有的周⼀到周五休息、周六到周⽇⼯作来计算的，但是遇到国家法定节假⽇也需要进⾏特殊对待。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
//指定的 月份和日期
String date="10-12"; // 这里可以自定义
if (isHoliday.contains(date)) {
{
e.printStackTrace();
}
}
public void isHodliDays(){ // 判断是否滴节假日，是否有节假日加班
//中国法定节假日期
String isHoliday="01-01,01-02,01-03,02-09,02-10,02-11,02-12,02-13,02-14," +
System.out.println("是节假日...");
}if (overDay.contains(date)) {
System.out.println("节假前后加班日期...");
}
}
System.out.println("日期:[" + dates + "] 是双休日");
}else{
System.out.println("日期:[" + dates + (Exception e)
/*
*实现思路
*1. 判断指定日期是否掉是双休日
*2. 在通过获取指定日期的 月和日 判断是否是节假
*3. 判断是否有节假日 双休加班情况
*4. 如果上面的你已经了解，那么得到工作日就简单了，不写了，自己通过需求加上
*/
public void isOverDay(){ // 指定时间判断是否是双休日
"02-15,04-04,04-05,04-06,04-29,04-30,05-01,06-10,06-11," +
"06-12,09-19,09-20,09-21,10-01,10-02,10-03,10-04,10-05,10-06,10-07";
//节假前后加班日期
String dates = "2013-05-13"; // 这里可以自定义
DateFormat df = new SimpleDateFormat("yy-MM-dd");
Date d;
try {
d= df.parse("");
if (d.getDay() == 0 || d.getDay() == 6){