Мені потрібно знайти кількість днів між двома датами : одна - зі звіту, а друга - поточної дати. Мій фрагмент:

  int age=calculateDifference(agingDate, today);

Ось calculateDifferenceприватний метод, agingDateі todayце Dateоб’єкти, лише для Вашого пояснення. Я переглянув дві статті з форуму Java, тема 1 / тема 2 .

Це прекрасно працює в автономній програмі, хоча, коли я включаю це в свою логіку для читання зі звіту, я отримую незвичну різницю у значеннях.

Чому це відбувається і як я можу це виправити?

РЕДАГУВАТИ:

Я отримую більшу кількість днів порівняно з фактичною кількістю днів.

public static int calculateDifference(Date a, Date b)
{
    int tempDifference = 0;
    int difference = 0;
    Calendar earlier = Calendar.getInstance();
    Calendar later = Calendar.getInstance();

    if (a.compareTo(b) < 0)
    {
        earlier.setTime(a);
        later.setTime(b);
    }
    else
    {
        earlier.setTime(b);
        later.setTime(a);
    }

    while (earlier.get(Calendar.YEAR) != later.get(Calendar.YEAR))
    {
        tempDifference = 365 * (later.get(Calendar.YEAR) - earlier.get(Calendar.YEAR));
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    if (earlier.get(Calendar.DAY_OF_YEAR) != later.get(Calendar.DAY_OF_YEAR))
    {
        tempDifference = later.get(Calendar.DAY_OF_YEAR) - earlier.get(Calendar.DAY_OF_YEAR);
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    return difference;
}

Примітка :

На жаль, жодна з відповідей не допомогла мені вирішити проблему. Я вирішив цю проблему за допомогою бібліотеки Joda-time .

Я б запропонував вам скористатися чудовою бібліотекою Joda Time замість недосконалого java.util.Date та друзів. Можна просто написати

import java.util.Date;
import org.joda.time.DateTime;
import org.joda.time.Days;

Date past = new Date(110, 5, 20); // June 20th, 2010
Date today = new Date(110, 6, 24); // July 24th 
int days = Days.daysBetween(new DateTime(past), new DateTime(today)).getDays(); // => 34

Можливо, я запізнився приєднатися до гри, але що, біса, га? :)

Ви вважаєте, що це проблема ниток? Як ви використовуєте результати цього методу, наприклад? АБО

Чи можемо ми змінити ваш код, щоб зробити щось таке просте, як:

Calendar calendar1 = Calendar.getInstance();
    Calendar calendar2 = Calendar.getInstance();
    calendar1.set(<your earlier date>);
    calendar2.set(<your current date>);
    long milliseconds1 = calendar1.getTimeInMillis();
    long milliseconds2 = calendar2.getTimeInMillis();
    long diff = milliseconds2 - milliseconds1;
    long diffSeconds = diff / 1000;
    long diffMinutes = diff / (60 * 1000);
    long diffHours = diff / (60 * 60 * 1000);
    long diffDays = diff / (24 * 60 * 60 * 1000);
    System.out.println("\nThe Date Different Example");
    System.out.println("Time in milliseconds: " + diff
 + " milliseconds.");
    System.out.println("Time in seconds: " + diffSeconds
 + " seconds.");
    System.out.println("Time in minutes: " + diffMinutes 
+ " minutes.");
    System.out.println("Time in hours: " + diffHours 
+ " hours.");
    System.out.println("Time in days: " + diffDays 
+ " days.");
  }

Diff / (24 * та ін.) Не враховує часовий пояс, тому, якщо у вашому часовому поясі за замовчуванням є літній час, він може відкинути обчислення.

Це посилання має приємну невеличку реалізацію.

Ось джерело вищевказаного посилання на випадок, якщо посилання перейде:

/** Using Calendar - THE CORRECT WAY**/  
public static long daysBetween(Calendar startDate, Calendar endDate) {  
  //assert: startDate must be before endDate  
  Calendar date = (Calendar) startDate.clone();  
  long daysBetween = 0;  
  while (date.before(endDate)) {  
    date.add(Calendar.DAY_OF_MONTH, 1);  
    daysBetween++;  
  }  
  return daysBetween;  
}  

і

/** Using Calendar - THE CORRECT (& Faster) WAY**/  
public static long daysBetween(final Calendar startDate, final Calendar endDate)
{
  //assert: startDate must be before endDate  
  int MILLIS_IN_DAY = 1000 * 60 * 60 * 24;  
  long endInstant = endDate.getTimeInMillis();  
  int presumedDays = 
    (int) ((endInstant - startDate.getTimeInMillis()) / MILLIS_IN_DAY);  
  Calendar cursor = (Calendar) startDate.clone();  
  cursor.add(Calendar.DAY_OF_YEAR, presumedDays);  
  long instant = cursor.getTimeInMillis();  
  if (instant == endInstant)  
    return presumedDays;

  final int step = instant < endInstant ? 1 : -1;  
  do {  
    cursor.add(Calendar.DAY_OF_MONTH, step);  
    presumedDays += step;  
  } while (cursor.getTimeInMillis() != endInstant);  
  return presumedDays;  
}

java.time

У Java 8 і пізніших версіях використовуйте фреймворк java.time ( Підручник ).

Duration

DurationКлас являє собою проміжок часу , як кілька секунд плюс дробової секунду. Він може рахувати дні, години, хвилини та секунди.

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println(duration.toDays());

ChronoUnit

Якщо вам потрібна лише кількість днів, ви можете скористатися переліком . Зверніть увагу, що методи обчислення повертають швидше ніж .ChronoUnit longint

long days = ChronoUnit.DAYS.between( then, now );

import java.util.Calendar;
import java.util.Date;

public class Main {
    public static long calculateDays(String startDate, String endDate)
    {
        Date sDate = new Date(startDate);
        Date eDate = new Date(endDate);
        Calendar cal3 = Calendar.getInstance();
        cal3.setTime(sDate);
        Calendar cal4 = Calendar.getInstance();
        cal4.setTime(eDate);
        return daysBetween(cal3, cal4);
    }

    public static void main(String[] args) {
        System.out.println(calculateDays("2012/03/31", "2012/06/17"));

    }

    /** Using Calendar - THE CORRECT WAY**/
    public static long daysBetween(Calendar startDate, Calendar endDate) {
        Calendar date = (Calendar) startDate.clone();
        long daysBetween = 0;
        while (date.before(endDate)) {
            date.add(Calendar.DAY_OF_MONTH, 1);
            daysBetween++;
        }
        return daysBetween;
    }
}

Це залежить від того, що ви визначаєте як різницю. Порівняти дві дати опівночі можна.

long day1 = ...; // in milliseconds.
long day2 = ...; // in milliseconds.
long days = (day2 - day1) / 86400000;

Рішення з використанням різниці між мілісекундами часу з правильним округленням для літнього часу:

public static long daysDiff(Date from, Date to) {
    return daysDiff(from.getTime(), to.getTime());
}

public static long daysDiff(long from, long to) {
    return Math.round( (to - from) / 86400000D ); // 1000 * 60 * 60 * 24
}

Одна примітка: Звичайно, дати мають бути в якомусь часовому поясі.

Важливий код:

Math.round( (to - from) / 86400000D )

Якщо ви не хочете круглі, ви можете використовувати дати UTC,

Ілюстрація проблеми: (Мій код обчислює дельту за тижні, але така ж проблема стосується дельти за дні)

Ось дуже розумна реалізація:

public static final long MILLIS_PER_WEEK = 7L * 24L * 60L * 60L * 1000L;

static public int getDeltaInWeeks(Date latterDate, Date earlierDate) {
    long deltaInMillis = latterDate.getTime() - earlierDate.getTime();
    int deltaInWeeks = (int)(deltaInMillis / MILLIS_PER_WEEK);
    return deltaInWeeks; 
}

Але цей тест не вдасться:

public void testGetDeltaInWeeks() {
    delta = AggregatedData.getDeltaInWeeks(dateMar09, dateFeb23);
    assertEquals("weeks between Feb23 and Mar09", 2, delta);
}

Причиною є:

Пн. Бер. 09 00:00:00 EDT 2009 = 1236 571 200 000
пн. 23 лютого 00:00:00 EST 2009 = 1 235
365 200 000 MillisPerWeek = 604 800 000
Таким чином,
(березень 09 - лютий 23) / MillisPerWeek = 1
206 000 000/604 800 000 = 1.994 ...

але кожен, хто дивиться на календар, погодиться, що відповідь 2.

Я використовую цю функцію:

DATEDIFF("31/01/2016", "01/03/2016") // me return 30 days

моя функція:

import java.util.Date;

public long DATEDIFF(String date1, String date2) {
        long MILLISECS_PER_DAY = 24 * 60 * 60 * 1000;
        long days = 0l;
        SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy"); // "dd/MM/yyyy HH:mm:ss");

        Date dateIni = null;
        Date dateFin = null;        
        try {       
            dateIni = (Date) format.parse(date1);
            dateFin = (Date) format.parse(date2);
            days = (dateFin.getTime() - dateIni.getTime())/MILLISECS_PER_DAY;                        
        } catch (Exception e) {  e.printStackTrace();  }   

        return days; 
     }

Подивіться на методи getFragmentInDays у цьому класі apache commons-lang DateUtils.

На основі відповіді @ Mad_Troll я розробив цей метод.

Я провів близько 30 тестових випадків проти цього, є єдиним методом, який правильно обробляє фрагменти часу доби.

Приклад: якщо ви пройдете зараз і зараз + 1 мілісекунду, це все той же день. Ведення 1-1-13 23:59:59.098в 1-1-13 23:59:59.099повернення 0 днів, правильно; інші методи, розміщені тут, не будуть робити це правильно.

Варто зазначити, що не має значення, яким способом ви їх ввели. Якщо ваша дата закінчення передує даті початку, вона буде рахуватися назад.

/**
 * This is not quick but if only doing a few days backwards/forwards then it is very accurate.
 *
 * @param startDate from
 * @param endDate   to
 * @return day count between the two dates, this can be negative if startDate is after endDate
 */
public static long daysBetween(@NotNull final Calendar startDate, @NotNull final Calendar endDate) {

    //Forwards or backwards?
    final boolean forward = startDate.before(endDate);
    // Which direction are we going
    final int multiplier = forward ? 1 : -1;

    // The date we are going to move.
    final Calendar date = (Calendar) startDate.clone();

    // Result
    long daysBetween = 0;

    // Start at millis (then bump up until we go back a day)
    int fieldAccuracy = 4;
    int field;
    int dayBefore, dayAfter;
    while (forward && date.before(endDate) || !forward && endDate.before(date)) {
        // We start moving slowly if no change then we decrease accuracy.
        switch (fieldAccuracy) {
            case 4:
                field = Calendar.MILLISECOND;
                break;
            case 3:
                field = Calendar.SECOND;
                break;
            case 2:
                field = Calendar.MINUTE;
                break;
            case 1:
                field = Calendar.HOUR_OF_DAY;
                break;
            default:
            case 0:
                field = Calendar.DAY_OF_MONTH;
                break;
        }
        // Get the day before we move the time, Change, then get the day after.
        dayBefore = date.get(Calendar.DAY_OF_MONTH);
        date.add(field, multiplier);
        dayAfter = date.get(Calendar.DAY_OF_MONTH);

        // This shifts lining up the dates, one field at a time.
        if (dayBefore == dayAfter && date.get(field) == endDate.get(field))
            fieldAccuracy--;
        // If day has changed after moving at any accuracy level we bump the day counter.
        if (dayBefore != dayAfter) {
            daysBetween += multiplier;
        }
    }
    return daysBetween;
}

Ви можете видалити @NotNullанотації, вони використовуються Intellij для аналізу коду на льоту

Ви говорите, що "це прекрасно працює в автономній програмі", але ви отримуєте "незвичні значення різниці", коли "включаєте це в мою логіку для читання зі звіту". Це свідчить про те, що у вашому звіті є деякі значення, для яких він працює некоректно, а ваша автономна програма не має цих значень. Замість автономної програми я пропоную тест-кейс. Напишіть тестовий приклад так само, як і окрему програму, підкласуючи з класу TestCase JUnit. Тепер ви можете запустити дуже конкретний приклад, знаючи, яке значення ви очікуєте (і не вказуйте його сьогодні для тестового значення, оскільки сьогодні змінюється з часом). Якщо ви введете значення, які використовували в автономній програмі, ваші тести, ймовірно, пройдуть. Це чудово - ви хочете, щоб ці справи продовжували працювати. Тепер додайте значення зі свого звіту, яке не т працює правильно. Ваш новий тест, мабуть, не вдасться. З’ясуйте, чому це не вдається, виправте це і перейдіть до зеленого (усі тести проходять). Запустіть звіт. Подивіться, що все ще зламано; написати тест; змусити його пройти. Досить скоро ви побачите, що ваш звіт працює.

Сто рядків коду для цієї базової функції ???

Просто простий метод:

protected static int calculateDayDifference(Date dateAfter, Date dateBefore){
    return (int)(dateAfter.getTime()-dateBefore.getTime())/(1000 * 60 * 60 * 24); 
    // MILLIS_IN_DAY = 1000 * 60 * 60 * 24;
}

public static int getDifferenceIndays(long timestamp1, long timestamp2) {
    final int SECONDS = 60;
    final int MINUTES = 60;
    final int HOURS = 24;
    final int MILLIES = 1000;
    long temp;
    if (timestamp1 < timestamp2) {
        temp = timestamp1;
        timestamp1 = timestamp2;
        timestamp2 = temp;
    }
    Calendar startDate = Calendar.getInstance(TimeZone.getDefault());
    Calendar endDate = Calendar.getInstance(TimeZone.getDefault());
    endDate.setTimeInMillis(timestamp1);
    startDate.setTimeInMillis(timestamp2);
    if ((timestamp1 - timestamp2) < 1 * HOURS * MINUTES * SECONDS * MILLIES) {
        int day1 = endDate.get(Calendar.DAY_OF_MONTH);
        int day2 = startDate.get(Calendar.DAY_OF_MONTH);
        if (day1 == day2) {
            return 0;
        } else {
            return 1;
        }
    }
    int diffDays = 0;
    startDate.add(Calendar.DAY_OF_MONTH, diffDays);
    while (startDate.before(endDate)) {
        startDate.add(Calendar.DAY_OF_MONTH, 1);
        diffDays++;
    }
    return diffDays;
}

ThreeTen-Extra

Відповідь Віталія Федоренка правильно, описуючи , як виконати цей розрахунок в сучасному стилі з java.time класами ( Duration& ChronoUnit) , вбудовані в Java 8 , а потім (і бек-портіровани на Java 6 і 7 і для Android ).

Days

Якщо ви регулярно використовуєте кількість днів у своєму коді, ви можете замінити прості цілі числа на використання класу. DaysКлас можна знайти в ThreeTen-Extra проекту, розширення java.time і полігон для можливих доповнень до майбутнього java.time. DaysКлас надає спосіб тіпобезопасного уявлення кілька днів в вашому додатку. Клас включає зручні константи для ZEROта ONE.

Враховуючи старі застарілі java.util.Dateоб’єкти у Запитанні, спочатку перетворіть їх на сучасні java.time.Instantоб’єкти. У старих класах дати та часу є нещодавно додані методи для полегшення перетворення на java.time, наприклад java.util.Date::toInstant.

Instant start = utilDateStart.toInstant(); // Inclusive.
Instant stop = utilDateStop.toInstant();  // Exclusive.

Передайте обидва Instantоб'єкти фабричному методу для org.threeten.extra.Days.

У поточній реалізації (2016-06) це виклик обгортки java.time.temporal.ChronoUnit.DAYS.between, детальніше прочитайте ChronoUnitдокумент класу. Щоб бути зрозумілим: усі великі регістри DAYSзнаходяться в переліченні, ChronoUnitтоді як DaysInitial- Cap - це клас від ThreeTen-Extra.

Days days = Days.between( start , stop );

Ви можете передавати ці Daysоб'єкти навколо власного коду. Ви можете здійснити серіалізацію до рядка у стандартному форматі ISO 8601 , зателефонувавши toString. Цей формат PnDвикористовує a Pдля позначення початку та Dозначає "дні", з кількістю днів між ними. Класи java.time та ThreeTen-Extra використовують ці стандартні формати за замовчуванням при генерації та аналізі рядків, що представляють значення дати та часу.

String output = days.toString();

P3D

Days days = Days.parse( "P3D" );  

Цей код обчислює дні між 2 рядками дат:

    static final long MILLI_SECONDS_IN_A_DAY = 1000 * 60 * 60 * 24;
    static final String DATE_FORMAT = "dd-MM-yyyy";
    public long daysBetween(String fromDateStr, String toDateStr) throws ParseException {
    SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
    Date fromDate;
    Date toDate;
    fromDate = format.parse(fromDateStr);
    toDate = format.parse(toDateStr);
    return (toDate.getTime() - fromDate.getTime()) / MILLI_SECONDS_IN_A_DAY;
}

Якщо ви шукаєте рішення, яке повертає належну кількість або днів між, наприклад, 11/30/2014 23:59і 12/01/2014 00:01ось рішенням, використовуючи Joda Time.

private int getDayDifference(long past, long current) {
    DateTime currentDate = new DateTime(current);
    DateTime pastDate = new DateTime(past);
    return currentDate.getDayOfYear() - pastDate.getDayOfYear();
} 

Ця реалізація повернеться 1як різниця в днях. Більшість розміщених тут рішень обчислюють різницю в мілісекундах між двома датами. Це означає, що 0його буде повернено, оскільки різниця між цими двома датами становить лише 2 хвилини.

Вам слід використовувати бібліотеку Joda Time, оскільки Java Util Date іноді повертає неправильні значення.

Joda проти Java Util Date

Наприклад дні між вчора (дд-мм-рррр, 12-07-2016) і першим днем ​​року 1957 р. (Дд-мм-рррр, 01-01-1957):

public class Main {

public static void main(String[] args) {
    SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");

    Date date = null;
    try {
        date = format.parse("12-07-2016");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    //Try with Joda - prints 21742
    System.out.println("This is correct: " + getDaysBetweenDatesWithJodaFromYear1957(date));
    //Try with Java util - prints 21741
    System.out.println("This is not correct: " + getDaysBetweenDatesWithJavaUtilFromYear1957(date));    
}


private static int getDaysBetweenDatesWithJodaFromYear1957(Date date) {
    DateTime jodaDateTime = new DateTime(date);
    DateTimeFormatter formatter = DateTimeFormat.forPattern("dd-MM-yyyy");
    DateTime y1957 = formatter.parseDateTime("01-01-1957");

    return Days.daysBetween(y1957 , jodaDateTime).getDays();
}

private static long getDaysBetweenDatesWithJavaUtilFromYear1957(Date date) {
    SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");

    Date y1957 = null;
    try {
        y1957 = format.parse("01-01-1957");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    return TimeUnit.DAYS.convert(date.getTime() - y1957.getTime(), TimeUnit.MILLISECONDS);
}

Тож я справді раджу вам користуватися бібліотекою Joda Time.

Я зробив це таким чином. це легко :)

Date d1 = jDateChooserFrom.getDate();
Date d2 = jDateChooserTo.getDate();

Calendar day1 = Calendar.getInstance();
day1.setTime(d1);

Calendar day2 = Calendar.getInstance();
day2.setTime(d2);

int from = day1.get(Calendar.DAY_OF_YEAR);
int to = day2.get(Calendar.DAY_OF_YEAR);

int difference = to-from;