计算两个日期之间的天数

可能的复制品:
计算两个 Java 日期实例之间的差异

在 Java 中，我想计算两个日期之间的天数。

在我的数据库中，它们被存储为 DATE数据类型，但在我的代码中，它们是字符串。

我要计算这两个字符串之间的无数天。

343517 次浏览
小开
最佳答案

注意: 这个答案是在2011年写的。我建议现在使用 java.time代替 Joda Time。

首先，你应该在必要的时候把 只有作为字符串来处理它们。大多数情况下，您应该使用实际描述您正在处理的数据的数据类型来处理它们。

我建议您使用 乔达时间，这是一个比 Date/Calendar好得多的 API。在这种情况下，您似乎应该使用 LocalDate类型。然后你可以使用:

int days = Days.daysBetween(date1, date2).getDays();
小开

这里有一个小程序可以帮助你:

import java.util.*;


public class DateDifference {
public static void main(String args[]){
DateDifference difference = new DateDifference();
}


DateDifference() {
Calendar cal1 = new GregorianCalendar();
Calendar cal2 = new GregorianCalendar();


cal1.set(2010, 12, 1);
cal2.set(2011, 9, 31);
System.out.println("Days= "+daysBetween(cal1.getTime(),cal2.getTime()));
}


public int daysBetween(Date d1, Date d2) {
return (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
}
}
小开

试试这个代码

     Calendar cal1 = new GregorianCalendar();
Calendar cal2 = new GregorianCalendar();


SimpleDateFormat sdf = new SimpleDateFormat("ddMMyyyy");


Date date = sdf.parse("your first date");
cal1.setTime(date)
date = sdf.parse("your second date");
cal2.setTime(date);


//cal1.set(2008, 8, 1);
//cal2.set(2008, 9, 31);
System.out.println("Days= "+daysBetween(cal1.getTime(),cal2.getTime()));

这个函数

     public int daysBetween(Date d1, Date d2){
return (int)( (d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
}
小开

如果你已经厌倦了和 java 纠缠不清，你可以把它作为查询的一部分发送给 db2:

select date1, date2, days(date1) - days(date2) from table

将返回 date1、 date2以及两者之间的天数差。

小开 
// http://en.wikipedia.org/wiki/Julian_day
public static int julianDay(int year, int month, int day) {
int a = (14 - month) / 12;
int y = year + 4800 - a;
int m = month + 12 * a - 3;
int jdn = day + (153 * m + 2)/5 + 365*y + y/4 - y/100 + y/400 - 32045;
return jdn;
}


public static int diff(int y1, int m1, int d1, int y2, int m2, int d2) {
return julianDay(y1, m1, d1) - julianDay(y2, m2, d2);
}
小开

我(到目前为止)计算天数差异的最佳解决方案:

//  This assumes that you already have two Date objects: startDate, endDate
//  Also, that you want to ignore any time portions


Calendar startCale=new GregorianCalendar();
Calendar endCal=new GregorianCalendar();


startCal.setTime(startDate);
endCal.setTime(endDate);


endCal.add(Calendar.YEAR,-startCal.get(Calendar.YEAR));
endCal.add(Calendar.MONTH,-startCal.get(Calendar.MONTH));
endCal.add(Calendar.DATE,-startCal.get(Calendar.DATE));


int daysDifference=endCal.get(Calendar.DAY_OF_YEAR);

然而，请注意，这个假设的差异不到一年！

小开

这个功能对我有好处:

public static int getDaysCount(Date begin, Date end) {
Calendar start = org.apache.commons.lang.time.DateUtils.toCalendar(begin);
start.set(Calendar.MILLISECOND, 0);
start.set(Calendar.SECOND, 0);
start.set(Calendar.MINUTE, 0);
start.set(Calendar.HOUR_OF_DAY, 0);


Calendar finish = org.apache.commons.lang.time.DateUtils.toCalendar(end);
finish.set(Calendar.MILLISECOND, 999);
finish.set(Calendar.SECOND, 59);
finish.set(Calendar.MINUTE, 59);
finish.set(Calendar.HOUR_OF_DAY, 23);


long delta = finish.getTimeInMillis() - start.getTimeInMillis();
return (int) Math.ceil(delta / (1000.0 * 60 * 60 * 24));
}
小开

Java8及更高版本: ChronoUnit.between

使用 ChronoUnit的实例计算不同单位(天、月、秒)的时间量。

例如:

ChronoUnit.DAYS.between(startDate,endDate)
小开

我知道这个帖子已经有两年了，但我还是没有看到正确的答案。

除非您想使用 Joda 或 Java8，并且需要减去受夏时制影响的日期。

所以我写了我自己的解决方案。重要的一点是，它只在你真正只关心日期的情况下起作用，因为它必须丢弃时间信息，所以如果你想要像 25.06.2014 - 01.01.2010 = 1636这样的东西，不管 DST 是什么，它都应该起作用:

private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd.MM.yyyy");


public static long getDayCount(String start, String end) {
long diff = -1;
try {
Date dateStart = simpleDateFormat.parse(start);
Date dateEnd = simpleDateFormat.parse(end);


//time is always 00:00:00, so rounding should help to ignore the missing hour when going from winter to summer time, as well as the extra hour in the other direction
diff = Math.round((dateEnd.getTime() - dateStart.getTime()) / (double) 86400000);
} catch (Exception e) {
//handle the exception according to your own situation
}
return diff;
}

由于时间总是 00:00:00，在从冬天到夏天的时候使用双 Math.round()应该有助于忽略丢失的3600000毫秒(1小时) ，以及从夏天到冬天的额外时间。

这是我用来证明它的一个小的 JUnit4测试:

@Test
public void testGetDayCount() {
String startDateStr = "01.01.2010";
GregorianCalendar gc = new GregorianCalendar(locale);
try {
gc.setTime(simpleDateFormat.parse(startDateStr));
} catch (Exception e) {
}


for (long i = 0; i < 10000; i++) {
String dateStr = simpleDateFormat.format(gc.getTime());
long dayCount = getDayCount(startDateStr, dateStr);
assertEquals("dayCount must be equal to the loop index i: ", i, dayCount);
gc.add(GregorianCalendar.DAY_OF_YEAR, 1);
}
}

... 或者如果你想看看它的“生命”是什么样子的，那就用公正来代替这个断言:

System.out.println("i: " + i + " | " + dayCount + " - getDayCount(" + startDateStr + ", " + dateStr + ")");

结果应该是这样的:

  i: 0 | 0  - getDayCount(01.01.2010, 01.01.2010)
i: 1 | 1  - getDayCount(01.01.2010, 02.01.2010)
i: 2 | 2  - getDayCount(01.01.2010, 03.01.2010)
i: 3 | 3  - getDayCount(01.01.2010, 04.01.2010)
...
i: 1636 | 1636  - getDayCount(01.01.2010, 25.06.2014)
...
i: 9997 | 9997  - getDayCount(01.01.2010, 16.05.2037)
i: 9998 | 9998  - getDayCount(01.01.2010, 17.05.2037)
i: 9999 | 9999  - getDayCount(01.01.2010, 18.05.2037)
小开

我在 Java 方面真的真的很新，所以我确信有一个更好的方法来实现我的提议。

我有同样的要求，我做到了这一点，使用的差异之间的 DAYOFYear 的两个日期。 这似乎是个更简单的方法。

我不能真正评估这个解决方案的性能和稳定性，但我认为这是好的。

这里:

public static void main(String[] args) throws ParseException {






//Made this part of the code just to create the variables i'll use.
//I'm in Brazil and the date format here is DD/MM/YYYY, but wont be an issue to you guys.
//It will work anyway with your format.


String s1 = "18/09/2014";
String s2 = "01/01/2014";
DateFormat f = DateFormat.getDateInstance();
Date date1 = f.parse(s1);
Date date2 = f.parse(s2);








//Here's the part where we get the days between two dates.


Calendar day1 = Calendar.getInstance();
Calendar day2 = Calendar.getInstance();
day1.setTime(date1);
day2.setTime(date2);


int daysBetween = day1.get(Calendar.DAY_OF_YEAR) - day2.get(Calendar.DAY_OF_YEAR);








//Some code just to show the result...
f = DateFormat.getDateInstance(DateFormat.MEDIUM);
System.out.println("There's " + daysBetween + " days between " + f.format(day1.getTime()) + " and " + f.format(day2.getTime()) + ".");






}

在这种情况下，输出将是(记住我使用的是 Date Format DD/MM/YYYY) :

There's 260 days between 18/09/2014 and 01/01/2014.

提交答案