Java中，计算天数两个日期

Question

之间可能重复：
Calculating the Difference Between Two Java Date InstancesJava中，计算天数两个日期

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

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

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

Answer 1

好，开始时，你应该只交易与他们的字符串时，你必须。大多数情况下，您应该使用实际描述您正在使用的数据的数据类型与他们一起工作。

我会建议您使用Joda Time，这是一个比Date/Calendar更好的API。听起来你应该在这种情况下使用LocalDate类型。然后，您可以使用：

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

Answer 2

这里是一个小程序，它可以帮助你：

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)); 
    } 
} 

Answer 3

试试这个代码

 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)); 
    } 

Answer 4

如果”你可以选择与java搞混了将它作为查询的一部分发送到db2：

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

将返回date1，date2和两者之间的天数差。

Answer 5

// 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); 
} 

Answer 6

我的最佳解决方案（到目前为止），用于计算天差数：

// 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); 

但是请注意，这个假设不到一年的区别！

Answer 7

此功能是为我好：

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)); 
} 

Answer 8

在Java 8.您可以使用Enum ChronoUnit实例来计算的不同单位（日，月，秒）的时间量。

例如：

ChronoUnit.DAYS.between(startDate,endDate) 

Answer 9

我知道这个线程现在两岁，我还没有看到一个正确的答案在这里。

除非你想使用乔达或具备Java 8，如果你需要subract由夏令影响日期。

所以我写了我自己的解决方案。最重要的方面是，它只有在你真正关心的日期，因为这是要丢弃的时间信息工作，所以如果你想要像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()应该有助于忽略缺失的60000毫秒（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) 

Answer 10

我真的真的真的在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()) + "."); 



    } 

在这种情况下，输出将是（记住，我使用的日期格式DD/MM/YYYY）：

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