java工作日计算算法_有关java中工作日算法的问题

① java 编程的问题。如何计算某年某月的工作日

import java.util.Calendar;

import java.util.Scanner;

public class replacenbsp {

/**

* @param args

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("请输入日期，格式为yyyy-MM: ");

String s = scanner.nextLine();

if(!s.matches("\d{4}-\d{2}")){

System.out.println("日期格式输入错误");

System.exit(0);

}

int count = 0;

int month = Integer.parseInt(s.substring(5, 7));

Calendar cal = Calendar.getInstance();

cal.set(Calendar.YEAR, Integer.parseInt(s.substring(0, 4)));

cal.set(Calendar.MONTH, month - 1);

cal.set(Calendar.DATE, 1);

while(cal.get(Calendar.MONTH) < month){

int day = cal.get(Calendar.DAY_OF_WEEK);

if(!(day == Calendar.SUNDAY || day == Calendar.SATURDAY)){

count++;

}

cal.add(Calendar.DATE, 1);

}

System.out.println(count);

}

② java如何计算工作日之间的时间差

packagecom.wednesday.tools.timetools;
importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Calendar;
importjava.util.Date;
{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
GetWorkDayTimeMilliseconda=newGetWorkDayTimeMillisecond();
Longb=a.getWorkdayTimeInMillis("2010-05-178-00-00","2010-05-189-00-00","yyyy-MM-ddHH-mm-ss");
System.out.println(b);
}
/**
*获取两个时间之内的工作日时间（只去掉两个日期之间的周末时间，法定节假日未去掉）
*@paramstart-起始时间，共有3个重载方法，可以传入long型，Long型，与Date型
*@paramend-结束时间，共有3个重载方法，可以传入long型，Long型，与Date型
*@returnLong型时间差对象
*/
(longstart,longend){
//如果起始时间大于结束时间，将二者交换
if(start>end){
longtemp=start;
start=end;
end=temp;
}
//根据参数获取起始时间与结束时间的日历类型对象
Calendarsdate=Calendar.getInstance();
Calendaredate=Calendar.getInstance();
sdate.setTimeInMillis(start);
edate.setTimeInMillis(end);
//如果两个时间在同一周并且都不是周末日期，则直接返回时间差，增加执行效率
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){
returnnewLong(end-start);
}
//首先取得起始日期与结束日期的下个周一的日期
CalendarsnextM=getNextMonday(sdate);
CalendarenextM=getNextMonday(edate);
//获取这两个周一之间的实际天数
intdays=getDaysBetween(snextM,enextM);
//获取这两个周一之间的工作日数(两个周一之间的天数肯定能被7整除，并且工作日数量占其中的5/7)
intworkdays=days/7*5;
//获取开始时间的偏移量
longscharge=0;
if(sdate.get(Calendar.DAY_OF_WEEK)!=1&&sdate.get(Calendar.DAY_OF_WEEK)!=7){
//只有在开始时间为非周末的时候才计算偏移量
scharge+=(7-sdate.get(Calendar.DAY_OF_WEEK))*24*3600000;
scharge-=sdate.get(Calendar.HOUR_OF_DAY)*3600000;
scharge-=sdate.get(Calendar.MINUTE)*60000;
scharge-=sdate.get(Calendar.SECOND)*1000;
scharge-=sdate.get(Calendar.MILLISECOND);
}
//获取结束时间的偏移量
longecharge=0;
if(edate.get(Calendar.DAY_OF_WEEK)!=1&&edate.get(Calendar.DAY_OF_WEEK)!=7){
//只有在结束时间为非周末的时候才计算偏移量
echarge+=(7-edate.get(Calendar.DAY_OF_WEEK))*24*3600000;
echarge-=edate.get(Calendar.HOUR_OF_DAY)*3600000;
echarge-=edate.get(Calendar.MINUTE)*60000;
echarge-=edate.get(Calendar.SECOND)*1000;
echarge-=edate.get(Calendar.MILLISECOND);
}
//计算最终结果，具体为：workdays加上开始时间的时间偏移量，减去结束时间的时间偏移量
returnworkdays*24*3600000+scharge-echarge;
}
(Longstart,Longend){
returngetWorkdayTimeInMillis(start.longValue(),end.longValue());
}
(Datestart,Dateend){
returngetWorkdayTimeInMillis(start.getTime(),end.getTime());
}
(Stringstart,Stringend,Stringformat){
SimpleDateFormatsdf=newSimpleDateFormat(format);
Datesdate;
Dateedate;
try{
sdate=sdf.parse(start);
edate=sdf.parse(end);
returngetWorkdayTimeInMillis(sdate,edate);
}catch(ParseExceptione){
e.printStackTrace();
returnnewLong(0);
}
}
privateCalendargetNextMonday(Calendarcal){
intaddnum=9-cal.get(Calendar.DAY_OF_WEEK);
if(addnum==8)addnum=1;//周日的情况
cal.add(Calendar.DATE,addnum);
returncal;
}
/**
*获取两个日期之间的实际天数，支持跨年
*/
publicintgetDaysBetween(Calendarstart,Calendarend){
if(start.after(end)){
Calendarswap=start;
start=end;
end=swap;
}
intdays=end.get(Calendar.DAY_OF_YEAR)-start.get(Calendar.DAY_OF_YEAR);
inty2=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);
}
returndays;
}
}

③ java根据年月获取对应的月份工作日天数

importjava.util.Calendar;

publicclassMain{

publicstaticvoidmain(String[]args){

System.out.println(countWorkDay(2018,6));
}

/**
*获取指定年月有多少个工作日）
*
*@paramyear
*@parammonth
*@return
*/
publicstaticintcountWorkDay(intyear,intmonth){
Calendarc=Calendar.getInstance();
c.set(Calendar.YEAR,year);
//月份是从0开始计算，所以需要减1
c.set(Calendar.MONTH,month-1);

//当月最后一天的日期
intmax=c.getActualMaximum(Calendar.DAY_OF_MONTH);
//开始日期为1号
intstart=1;
//计数
intcount=0;
while(start<=max){
c.set(Calendar.DAY_OF_MONTH,start);
if(isWorkDay(c)){
count++;
}
start++;
}
returncount;
}

//判断是否工作日（未排除法定节假日，由于涉及到农历节日，处理很麻烦）
publicstaticbooleanisWorkDay(Calendarc){
//获取星期,1~7,其中1代表星期日，2代表星期一...7代表星期六
intweek=c.get(Calendar.DAY_OF_WEEK);
//不是周六和周日的都认为是工作日
returnweek!=Calendar.SUNDAY&&week!=Calendar.SATURDAY;
}
}

④ java 计算 2个日期间隔多少个工作日

importjava.text.SimpleDateFormat;
importjava.util.Calendar;
importjava.util.Date;

publicclassTest{

	publicstaticvoidmain(String[]args)throwsException{
		SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-dd");
		DatebegDate=sdf.parse("2014-01-04");
		DateendDate=sdf.parse("2014-01-04");
		if(begDate.after(endDate))
			thrownewException("日期范围非法");
		//总天数
		intdays=(int)((endDate.getTime()-begDate.getTime())/(24*60*60*1000))+1;
		//总周数，
		intweeks=days/7;
		intrs=0;
		//整数周
		if(days%7==0){
			rs=days-2*weeks;
		}
		else{
			CalendarbegCalendar=Calendar.getInstance();
			CalendarendCalendar=Calendar.getInstance();
			begCalendar.setTime(begDate);
			endCalendar.setTime(endDate);
			//周日为1，周六为7
			intbeg=begCalendar.get(Calendar.DAY_OF_WEEK);
			intend=endCalendar.get(Calendar.DAY_OF_WEEK);
			if(beg>end){
				rs=days-2*(weeks+1);
			}elseif(beg<end){
				if(end==7){
					rs=days-2*weeks-1;
				}else{
					rs=days-2*weeks;
				}
			}else{
				if(beg==1||beg==7){
					rs=days-2*weeks-1;
				}else{
					rs=days-2*weeks;
				}
			}
		}
		System.out.println(sdf.format(begDate)+"到"+sdf.format(endDate)+"中间有"+rs+"个工作日");
	}
}

如果只算双休的话

⑤ Java编写求某天之后的多少个工作日是哪天

我从自己的工具类中使用了几个方法，一并贴出来供楼主参考：
/**
* 判断当前日期为星期几
* @param date
* @return
*/
public static int dayOfWeek(Date date){
Calendar aCalendar = Calendar.getInstance();
aCalendar.setTime(date);
int weekDay = aCalendar.get(Calendar.DAY_OF_WEEK);
return weekDay;
}
/**
* 获取指定日期指定天数后的日期
* @param date 指定日期
* @param index 指定天数
* @param flag 是否将时分秒归0
* @return
*/
public static Date getNextDate(Date date, int index, boolean flag){
Calendar cal = Calendar.getInstance();
cal.setTime(date);// 获得当前时间
if(flag){
// 日期不变，把时间设定为00：00：00
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 00);
cal.set(Calendar.SECOND, 00);
}
cal.set(Calendar.DATE, cal.get(Calendar.DATE) + index);
return cal.getTime();
}

public static Date getDate(Date currentDate,int days){
/*
* 1，根据传入日期获取下一天日期
* 2，判断下一天日期是否为工作日，如果是则设置下一次循环日期为此日期
* 如果不为工作日，为周6，日期前进2天，为周天前进1天
* 3, 获取指定天数后的工作日
*/
Date date = currentDate;
/* 设置循环次数
* 如果含最后一天则循环 days + 1 天，不需要含最后一天，则循环 days次
* */
for(int i = 0; i < days + 1; i++){

Date nextDate = getNextDate(date,1,false); //获取下一天的日期
int weekDay = dayOfWeek(nextDate); //下一天日期为星期几
if(weekDay == 1){ //为星期六
date = getNextDate(date,2,false);
}else if(weekDay == 6){ //为星期天
date = getNextDate(date,3,false);
}else{
date = nextDate;
}
}
return date;
}

虽然这个满足楼主的需求，但是肯定有更简单的算法，现在要出门，来不及想了，先用用。

这个问题的思路我现在想到的就是判断下一日期是否为工作日，为周6怎样处理，为周日怎样处理。希望回来的时候能看到更好的计算方法(good luck)。

楼主应该建立自己的常用工具类库，如日期，图片，字符串等等的常用处理（注意方法的复用），这样开发的效率会很高。

⑥ 求java实现工作日方法

import java.text.DateFormat;

import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class Test9 {

/**
* 第9题：编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，程序计算这一天是星期几，并且计算出是一年中的第几天。
*
* @param args
* @throws ParseException
*/
public static void main(String[] args) throws ParseException {

Scanner scan = new Scanner(System.in);
System.out.println("请输入日期（格式为yyyy-mm-dd）：");
String input = scan.next();
DateFormat format = DateFormat.getDateInstance();
Date date = format.parse(input);
Calendar ca = Calendar.getInstance();
ca.setTime(date); //设置输入时间
int xingqi = ca.get(Calendar.DAY_OF_WEEK);//获得输入日期是星期几？
System.out.println("您输入的日期是："+input);
System.out.println("这一天是"+ GetWeek(xingqi));
System.out.println("这一天是这年的第"+ ca.get(Calendar.DAY_OF_YEAR)+"天");

}
public static String GetWeek(int i)
{
if(i<0||i>7){
System.out.println(i+"没有对应的星期");
}
String[] weeks={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return weeks[i];

}

}

⑦ 有关java中工作日算法的问题

Calendar c = new GregorianCalendar();
int i=0;
while(i<3){
c.add(Calendar.DATE, 1);
if (isHoliday(c.getTime())) continue;
if (isWeekEnd(c.getTime()) && !isTransferAsWorkDay(c.getTime())) continue;

i++;
}
return c.getTime();
isHoliday() :是否为节假日
isWeekEnd()是否为周末
isTransferAsWorkDay()是否周末转为工作日
这3个需要自己写

⑧ java 获取一周内工作日的天数

日期可以使用Calendar，法定假期只能自己预先在程序里面定义好。

参考代码：http://blog.csdn.net/u011789653/article/details/41444023

⑨ 如何用java代码判断工作日

可以用Calendar类，但只能判断是周末还是工作日。
公假和补假是不可能有现成的方法给你写出来的，java是老外发明的，人家老外那可没什么国庆，中秋的，所以这些只能你自己来判断，你自己写算法，
而且这肯定不是一个简单的问题，需要很多数据和工作量，因为你这个需求实现了，都可以做一个“中国工作日及假修列表”系统了。

⑩ Java计算工作日和法定节日的一个需求，怎样设计求救

我的思路：
给用户一个界面定义节日(holiday，需要每年定义)和调休工作日(是指原本应该休息的周末因为假日连休而调整为工作日)，然后存入数据库。
在计算某日期date是否为假日的时候，按下面的伪代码判断：
//循环数据库取出的假日List
if (date=假日List.get(i)){
// 是假日
return 假日;
}
//循环数据库取出的调休工作日List
if(date=调休工作日List.get(i)){
// 是工作日
return 工作日;
}

if(date 是否为周末假日){
// 是假日
return 假日;
}else{
// 是工作日
return 工作日;
}

导航:首页 > 源码编译 > java工作日计算算法

java工作日计算算法

与java工作日计算算法相关的资料