public static int getDaysBetween (String beginDate, String endDate) throws ParseException
 
{
 
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
 
Date bDate = format.parse(beginDate);
 
Date eDate = format.parse(endDate);
 
Calendar d1 = new GregorianCalendar();
 
d1.setTime(bDate);
 
Calendar d2 = new GregorianCalendar();
 
d2.setTime(eDate);
 
int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
 
int y2 = d2.get(Calendar.YEAR);
 
if (d1.get(Calendar.YEAR) != y2)
 
{
 
d1 = (Calendar) d1.clone();
 
do   {
 
days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);//得到当年的实际天数
 
d1.add(Calendar.YEAR, 1);
 
}    while (d1.get(Calendar.YEAR) != y2);
 
}
 
return days;
 
}

Java计算时间差、日期差总结
 
最近工作中遇到需要计算时间差，搜索了几种计算时间差的方法，这里总结一下
 
1、java 7中的日历类Calendar
 
Calendar类使用其静态的getInstance()方法获取一个日历实例，该实例为当前的时间；如果想改变时间，可以通过其setTime方法传入一个Date对象，即可获得Date对象所表示时间的Calendar对象
 
/**
 *使用Calendar对象计算时间差，可以按照需求定制自己的计算逻辑
 * @param strDate
 * @throws ParseException
 */
public static void calculateTimeDifferenceByCalendar(String strDate) throws ParseException {
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
    Date date = formatter.parse(strDate);

    Calendar c1 = Calendar.getInstance();   //当前日期
    Calendar c2 = Calendar.getInstance();
    c2.setTime(date);   //设置为另一个时间

    int year = c1.get(Calendar.YEAR);
    int oldYear = c2.get(Calendar.YEAR);

    //这里只是简单的对两个年份数字进行相减，而没有考虑月份的情况
    System.out.println("传入的日期与今年的年份差为：" + (year - oldYear));
}
 
输出为：
 
传入的日期与今年的年份差为：12
 
2、java 8中的周期类Period
 
通过调用Period类的静态方法between，传入两个待比较的LocalDate对象today与oldDate，得到的Period的对象p中就包含了today与oldDate两个日期相差的年、月、日信息，可以通过p.getYears()等方法取出
 
/**
 * 使用java 8的Period的对象计算两个LocalDate对象的时间差，严格按照年、月、日计算，如：2018-03-12 与 2014-05-23 相差 3 年 9 个月 17 天
 * @param year
 * @param month
 * @param dayOfMonth
 */
public static void calculateTimeDifferenceByPeriod(int year, Month month, int dayOfMonth) {
    LocalDate today = LocalDate.now();
    System.out.println("Today：" + today);
    LocalDate oldDate = LocalDate.of(year, month, dayOfMonth);
    System.out.println("OldDate：" + oldDate);

    Period p = Period.between(oldDate, today);
    System.out.printf("目标日期距离今天的时间差：%d 年 %d 个月 %d 天\n", p.getYears(), p.getMonths(), p.getDays());
}
 
输出为：
 
Today：2018-03-13
OldDate：2014-05-23
目标日期距离今天的时间差：3 年 9 个月 18 天
 
3、java 8中的Duration类
 
Duration与Period相对应，Period用于处理日期，而Duration计算时间差还可以处理具体的时间，也是通过调用其静态的between方法，该方法的签名是between(Temporal startInclusive, Temporal endExclusive)，因此可以传入两个Instant的实例（Instant实现了Temporal接口），并可以以毫秒（toMillis）、秒（getSeconds）等多种形式表示得到的时间差
 
public static void calculateTimeDifferenceByDuration() {
    Instant inst1 = Instant.now();  //当前的时间
    System.out.println("Inst1：" + inst1);
    Instant inst2 = inst1.plus(Duration.ofSeconds(10));     //当前时间+10秒后的时间
    System.out.println("Inst2：" + inst2);
    Instant inst3 = inst1.plus(Duration.ofDays(125));       //当前时间+125天后的时间
    System.out.println("inst3：" + inst3);

    System.out.println("以毫秒计的时间差：" + Duration.between(inst1, inst2).toMillis());

    System.out.println("以秒计的时间差：" + Duration.between(inst1, inst3).getSeconds());
}
 
输出为：
 
Inst1：2018-03-13T09:06:00.691Z
Inst2：2018-03-13T09:06:10.691Z
inst3：2018-07-16T09:06:00.691Z
以毫秒计的时间差：10000
以秒计的时间差：10800000
 
4、java 8中的ChronoUnit类
 
ChronoUnit的between方法签名为，between(Temporal temporal1Inclusive, Temporal temporal2Exclusive)，需要注意的是，如果要以不同的单位展示时间差，between入参中的时间对象必须包含有对应的时间信息，否则会抛出java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit XXX的异常
 
/**
 * 使用java 8的ChronoUnit，ChronoUnit可以以多种单位（基本涵盖了所有的，看源码发现竟然还有“FOREVER”这种单位。。）表示两个时间的时间差
 */
public static void calculateTimeDifferenceByChronoUnit() {
    LocalDate startDate = LocalDate.of(2003, Month.MAY, 9);
    System.out.println("开始时间：" + startDate);

    LocalDate endDate = LocalDate.of(2015, Month.JANUARY, 26);
    System.out.println("结束时间：" + endDate);

    long daysDiff = ChronoUnit.DAYS.between(startDate, endDate);
    System.out.println("两个时间之间的天数差为：" + daysDiff);
//  long hoursDiff = ChronoUnit.HOURS.between(startDate, endDate);  //这句会抛出异常，因为LocalDate表示的时间中不包含时分秒等信息
}
 
输出为：
 
开始时间：2003-05-09
结束时间：2015-01-26
两个时间之间的天数差为：4280
 
5、传统的SimpleDateFormat类
 
用SimpleDateFormat计算时间差的方法，网上找了一份，自己跑了一遍，可以使用，贴在下面
 
/**
* 用SimpleDateFormat计算时间差
* @throws ParseException 
*/
public static void calculateTimeDifferenceBySimpleDateFormat() throws ParseException {
    SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");
    /*天数差*/
    Date fromDate1 = simpleFormat.parse("2018-03-01 12:00");  
    Date toDate1 = simpleFormat.parse("2018-03-12 12:00");  
    long from1 = fromDate1.getTime();  
    long to1 = toDate1.getTime();  
    int days = (int) ((to1 - from1) / (1000 * 60 * 60 * 24));  
    System.out.println("两个时间之间的天数差为：" + days);

    /*小时差*/
    Date fromDate2 = simpleFormat.parse("2018-03-01 12:00");  
    Date toDate2 = simpleFormat.parse("2018-03-12 12:00");  
    long from2 = fromDate2.getTime();  
    long to2 = toDate2.getTime();  
    int hours = (int) ((to2 - from2) / (1000 * 60 * 60));
    System.out.println("两个时间之间的小时差为：" + hours);

    /*分钟差*/
    Date fromDate3 = simpleFormat.parse("2018-03-01 12:00");  
    Date toDate3 = simpleFormat.parse("2018-03-12 12:00");  
    long from3 = fromDate3.getTime();  
    long to3 = toDate3.getTime();  
    int minutes = (int) ((to3 - from3) / (1000 * 60));  
    System.out.println("两个时间之间的分钟差为：" + minutes);
}
 
输出为：
 
两个时间之间的天数差为：11
两个时间之间的小时差为：264
两个时间之间的分钟差为：15840
 
总结
 
传统的SimpleDateFormat和Java 7中的Calendar在使用的时候需要自己写一个计算时间差的逻辑，比较麻烦，但是却比较灵活，方便根据自己具体的需求来定制（比如，我想两个日期的天数差15天就算满一个月，不满15天不算一个月，如2018-01-04到2018-02-20，算2个月的时间差）；而Java 8中的几个计算时间差的类更加方便、精确，可以以不同的单位表示得到的时间差，但要注意几个类所包含的时间信息的区别：
 
System.out.println(LocalDate.now());        //只包含日期信息
System.out.println(LocalTime.now());        //只包含时间信息
System.out.println(LocalDateTime.now());        //包含日期、时间信息
 
输出为：
 
2018-03-13
17:13:26.134
2018-03-13T17:13:26.135
 
以上总结的几个方法只是个例子，具体使用的时候可能需要传入一个或者两个时间进行比较，可能会涉及到这些时间对象的相互转换，Instant、Date、LocalDate等等。。。我就不列举了。。。 
 另外在使用SimpleDateFormat对String类型的日期进行parse的时候，如果传入的日期为：2017-08-60，这种错误的日期，Java默认会按照日期的信息对其进行转换，formatter.parse("2017-08-60");，得到的日期为2017-09-29，而如果不想进行这种转换，而直接将其判定为输入错误，则可以设置formatter.setLenient(false);，这时就会抛出java.text.ParseException异常了
 
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
formatter.setLenient(false);
try {
    Date date = formatter.parse("2017-08-60");  //抛出转换异常
    System.out.println(date);
} catch (ParseException e) {
    e.printStackTrace();
}

 

 
慕村9548890
 
在Java 8中使用Joda-Time或新的java.time包。这两个框架都使用Half-Open方法，其中开始是包含在内的，而结尾是排斥的。有时标注为[)。通常，这是定义时间跨度的最佳方法。java.timeJava 8及更高版本中内置的java.time框架具有一个Period类，用于表示时间跨度，以年，月，日为单位。但是此类仅限于整天，不能表示小时，分钟和秒。请注意，我们指定了时区，这对于确定日期至关重要。例如，巴黎的新天要比蒙特利尔早。ZoneId zoneId = ZoneId.of( "America/Montreal" );LocalDate now = LocalDate.now( zoneId );LocalDate then = LocalDate.of( 2001, 1, 1 );Period period = Period.between( then, now );然后：2001-01-01。现在：2015-09-07。期间：P14Y8M6D。天数：5362对于整天，则夏令时(DST)无关紧要。如果要计算总天数，请使用ChronoUnit包含一些计算方法的枚举。注意，计算返回很长的时间。long days = ChronoUnit.DAYS.between( then, now );  // "5362" seen above.我曾问过要在java.time中进行一整段时间，包括小时，分钟，秒。不可能的，因为Java的8使用捆绑的库令人惊讶的解决办法的建议由梅诺尔德：使用Duration中发现了类javax.xml.datatype中的包。乔达时代这是Joda-Time 2.3中的一些示例代码。DateTimeZone timeZone = DateTimeZone.forID( "Europe/Paris" );DateTime start = new DateTime( 2014, 1, 2, 3, 4, 5, timeZone );DateTime stop = new DateTime( 2014, 5, 2, 3, 4, 5, timeZone );Period period = new Period( start, stop );调用toString将获得ISO 8601标准定义的形式的字符串表示形式PnYnMnDTnHnMnS。

 
long days = mss / ( 60 * 60 * 24);
 
long hours = (3601 % ( 60 * 60 * 24)) / (60 * 60);
 
long minutes = (3601 % ( 60 * 60)) /60;
 
long seconds = 3601 % 60;
 
System.out.println(hours+"\t"+minutes+"\t"+seconds);1 0 1
 
SimpleDateFormat
 
dateUtil
 
localdatetime
 
calendar
 
LocalDate
 
LocalDate dateSimple = LocalDate.parse("20180729", DateTimeFormatter.BASIC_ISO_DATE);
 
System.out.println("dateSimple="+dateSimple.toString()+"=2018-07-29");
 
LocalDate localDate = LocalDate.parse("19570323", DateTimeFormatter.ofPattern("yyyyMMdd"));
 
System.out.println(localDate);
 

 
public static double dateDiffDays(String startTime, String endTime,
 
String format, String str) {
 
// 按照传入的格式生成一个simpledateformate对象
 
SimpleDateFormat sd = new SimpleDateFormat(format);
 
long nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
 
long nh = 1000 * 60 * 60;// 一小时的毫秒数
 
long nm = 1000 * 60;// 一分钟的毫秒数
 
long ns = 1000;// 一秒钟的毫秒数
 
long diff;
 
long day = 0;
 
long hour = 0;
 
long min = 0;
 
long sec = 0;
 
// 获得两个时间的毫秒时间差异
 
try {
 
diff = sd.parse(endTime).getTime() - sd.parse(startTime).getTime();
 
day = diff / nd;// 计算差多少天
 
hour = diff % nd / nh + day * 24;// 计算差多少小时
 
min = diff % nd % nh / nm + day * 24 * 60;// 计算差多少分钟
 
sec = diff % nd % nh % nm / ns;// 计算差多少秒
 
// 输出结果
 
System.out.println("时间相差：" + day + "天" + (hour - day * 24) + "小时"
 
+ (min - day * 24 * 60) + "分钟" + sec + "秒。");
 
System.out.println("hour=" + hour + ",min=" + min);
 
if((hour - day * 24)<5){
 
// 半天
 
return day+0.5;
 
}else{
 
// 整天
 
return day+1;
 
}
 
} catch (ParseException e) {
 
// TODO Auto-generated catch block
 
e.printStackTrace();
 
}
 
return 0;
 
}
 
//获取时间差把判断换成这部分
 
double h= Double.valueOf((hour - day * 24)+"."+(min - day * 24 * 60));
 
return new DecimalFormat("0.00").format(h);
 
/**/计算一天的时间差 只能是一天的不然错
 
public static String getHours(String end1,String begin1)throws ParseException {
 
SimpleDateFormat sim=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
String end="2019-06-21 8:30:00";//sim.format(dd);
 
//2.定义一个比较的时间
 
String begin="2019-06-21 8:36:00";
 
//把string类型转换为long类型的
 
long st=sim.parse(end1).getTime();
 
long en=sim.parse(begin1).getTime();
 
//1秒：1000 1分钟：60000;1小时:3600000；1天为86400000
 
//计算天数
 
int day=(int) ((en-st)/86400000);
 
//计算小时
 
int h=(int) (((en-st)%86400000)/3600000);
 
//计算分钟
 
int m=(int)(((en-st)%86400000)%3600000)/60000;
 
//计算秒
 
int s=(int)((((en-st)%86400000)%3600000)%60000)/1000;
 
String hour = String.valueOf(h);
 
boolean hou = hour.contains("-");
 
if(hou==true){
 
hour=hour.replace("-", "");
 
}
 
String min = String.valueOf(m);
 
boolean mi = min.contains("-");
 
if(mi==true){
 
min=min.replace("-", "");
 
}
 
String result=new DecimalFormat("0.00").format(Double.valueOf(hour+"."+min));
 
return result;
 
}
 

 
——------------------------------------js
 
function getRemainderTime (startdate,enddate){
 
//console.log("startdate is "+ startdate+";enddate is "+ enddate);
 
var s1 = new Date(startdate);
 
var s2 = new Date(enddate);
 
runTime = parseInt((s2.getTime() - s1.getTime()) / 1000);
 
var year = Math.floor(runTime / 86400 / 365);
 
runTime = runTime % (86400 * 365);
 
var month = Math.floor(runTime / 86400 / 30);
 
runTime = runTime % (86400 * 30);
 
var day = Math.floor(runTime / 86400);
 
runTime = runTime % 86400;
 
var hour = Math.floor(runTime / 3600);
 
runTime = runTime % 3600;
 
var minute = Math.floor(runTime / 60);
 
runTime = runTime % 60;
 
var second = runTime;
 
console.log(year,month,day,hour,minute,second);
 
// return year+','+month+','+day+','+hour+','+minute+','+second;
 
if(hour<5){
 
// 半天
 
return day+0.5;
 
}else{
 
// 整天
 
return day+1;
 
}
 
}
 
public static void main(String[] args) {
 
try {
 
String strDateStart = "2019-08-01";
 
String strDateEnd = "2019-08-31";
 
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 
Date date_start = sdf.parse(strDateStart);
 
Date date_end = sdf.parse(strDateEnd);
 
WorkDayUtils app = new WorkDayUtils();
 
Calendar cal_start = Calendar.getInstance();
 
Calendar cal_end = Calendar.getInstance();
 
cal_start.setTime(date_start);
 
cal_end.setTime(date_end);
 
System.out.println("开始日：" + cal_start.get(Calendar.YEAR) + "-" + (cal_start.get(Calendar.MONTH) + 1)
 
+ "-" + cal_start.get(Calendar.DAY_OF_MONTH) + " " + app.getChineseWeek(cal_start));
 
System.out.println("结束日：" + cal_end.get(Calendar.YEAR) + "-" + (cal_end.get(Calendar.MONTH) + 1)
 
+ "-" + cal_end.get(Calendar.DAY_OF_MONTH) + " " + app.getChineseWeek(cal_end));
 
System.out.println("工作日：" + app.getWorkingDay(cal_start, cal_end));
 
System.out.println("休息日：" + app.getHolidays(cal_start, cal_end));
 
} catch (Exception e) {
 
e.printStackTrace();
 
}
 
}
 
/**
 
* 获取日期之间的天数
 
* @param d1
 
* @param d2
 
* @return
 
*/
 
public int getDaysBetween(Calendar d1, Calendar d2) {
 
if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
 
Calendar swap = d1;
 
d1 = d2;
 
d2 = swap;
 
}
 
int days = d2.get(Calendar.DAY_OF_YEAR)
 
- d1.get(Calendar.DAY_OF_YEAR);
 
int y2 = d2.get(Calendar.YEAR);
 
if (d1.get(Calendar.YEAR) != y2) {
 
d1 = (Calendar) d1.clone();
 
do {
 
days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);
 
d1.add(Calendar.YEAR, 1);
 
} while (d1.get(Calendar.YEAR) != y2);
 
}
 
return days;
 
}
 
/**
 
* 获取工作日
 
* @param d1
 
* @param d2
 
* @return
 
*/
 
public int getWorkingDay(Calendar d1, Calendar d2) {
 
int result = -1;
 
if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
 
Calendar swap = d1;
 
d1 = d2;
 
d2 = swap;
 
}
 
// int betweendays = getDaysBetween(d1, d2);
 
// int charge_date = 0;
 
int charge_start_date = 0;// 开始日期的日期偏移量
 
int charge_end_date = 0;// 结束日期的日期偏移量
 
// 日期不在同一个日期内
 
int stmp;
 
int etmp;
 
stmp = 7 - d1.get(Calendar.DAY_OF_WEEK);
 
etmp = 7 - d2.get(Calendar.DAY_OF_WEEK);
 
if (stmp != 0 && stmp != 6) {// 开始日期为星期六和星期日时偏移量为0
 
charge_start_date = stmp - 1;
 
}
 
if (etmp != 0 && etmp != 6) {// 结束日期为星期六和星期日时偏移量为0
 
charge_end_date = etmp - 1;
 
}
 
// }
 
result = (getDaysBetween(this.getNextMonday(d1), this.getNextMonday(d2)) / 7)
 
* 5 + charge_start_date - charge_end_date;
 
// System.out.println("charge_start_date>" + charge_start_date);
 
// System.out.println("charge_end_date>" + charge_end_date);
 
// System.out.println("between day is-->" + betweendays);
 
return result;
 
}
 
/**
 
* 获取中文日期
 
* @param date
 
* @return
 
*/
 
public String getChineseWeek(Calendar date) {
 
final String[] dayNames = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
 
int dayOfWeek = date.get(Calendar.DAY_OF_WEEK);
 
// System.out.println(dayNames[dayOfWeek - 1]);
 
return dayNames[dayOfWeek - 1];
 
}
 
/**
 
* 获得日期的下一个星期一的日期
 
* @param date
 
* @return
 
*/
 
public Calendar getNextMonday(Calendar date) {
 
Calendar result = null;
 
result = date;
 
do {
 
result = (Calendar) result.clone();
 
result.add(Calendar.DATE, 1);
 
} while (result.get(Calendar.DAY_OF_WEEK) != 2);
 
return result;
 
}
 
/**
 
* 获取休息日
 
* @param d1
 
* @param d2
 
* @return
 
*/
 
public int getHolidays(Calendar d1, Calendar d2) {
 
return this.getDaysBetween(d1, d2) - this.getWorkingDay(d1, d2);
 
}