Java, Рассчитать количество дней между двумя датами

Ответ 1

Ну, для начала, вы должны иметь дело только с ними, как строки, когда вам нужно. В большинстве случаев вы должны работать с ними в типе данных, который фактически описывает данные, с которыми вы работаете.

Я бы рекомендовал вам использовать Joda Time, что намного лучше API, чем Date/Calendar. Похоже, вы должны использовать тип LocalDate в этом случае. Затем вы можете использовать:

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

Ответ 2

попробуйте этот код

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

Ответ 3

В Java 8. Вы можете использовать экземпляры Enum ChronoUnit для вычисления количества времени в разных единицах (дни, месяцы, секунды).

Пример:

ChronoUnit.DAYS.between(startDate,endDate)

Ответ 4

Я знаю, что эта нить уже два года, я до сих пор не вижу здесь правильного ответа.

Если вы не хотите использовать Joda или иметь Java 8, и если вам нужно подождать даты, повлиянные на летнее время.

Итак, я написал свое собственное решение. Важным аспектом является то, что он работает только в том случае, если вы действительно заботитесь только о датах, потому что необходимо отказаться от информации о времени, поэтому, если вы хотите что-то вроде 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, использование double, а затем 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)

Ответ 5

здесь небольшая программа, которая может вам помочь:

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

Ответ 6

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

Ответ 7

Я действительно действительно ДЕЙСТВИТЕЛЬНО новый на 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 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 " + daysBetween + " days between " + f.format(day1.getTime()) + " and " + f.format(day2.getTime()) + ".");



    }

В этом случае вывод будет (помня, что я использую формат даты DD/MM/YYYY):

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

Ответ 8

Эта функция хороша для меня:

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

Ответ 9

Мое лучшее решение (пока) для расчета разницы дней:

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

Обратите внимание, однако, что это предполагает менее чем разницу в году!

Ответ 10

Если вам надоело общаться с java, вы можете просто отправить его на db2 как часть вашего запроса:

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

вернет дату1, дату2 и разницу между днями между ними.