Дней Android между двумя датами

Пожалуйста, обратитесь к этому коду, это может вам помочь.

public String getCountOfDays(String createdDateString, String expireDateString) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy", Locale.getDefault());

    Date createdConvertedDate = null, expireCovertedDate = null, todayWithZeroTime = null;
    try {
        createdConvertedDate = dateFormat.parse(createdDateString);
        expireCovertedDate = dateFormat.parse(expireDateString);

        Date today = new Date();

        todayWithZeroTime = dateFormat.parse(dateFormat.format(today));
    } catch (ParseException e) {
        e.printStackTrace();
    }

    int cYear = 0, cMonth = 0, cDay = 0;

    if (createdConvertedDate.after(todayWithZeroTime)) {
        Calendar cCal = Calendar.getInstance();
        cCal.setTime(createdConvertedDate);
        cYear = cCal.get(Calendar.YEAR);
        cMonth = cCal.get(Calendar.MONTH);
        cDay = cCal.get(Calendar.DAY_OF_MONTH);

    } else {
        Calendar cCal = Calendar.getInstance();
        cCal.setTime(todayWithZeroTime);
        cYear = cCal.get(Calendar.YEAR);
        cMonth = cCal.get(Calendar.MONTH);
        cDay = cCal.get(Calendar.DAY_OF_MONTH);
    }


    /*Calendar todayCal = Calendar.getInstance();
    int todayYear = todayCal.get(Calendar.YEAR);
    int today = todayCal.get(Calendar.MONTH);
    int todayDay = todayCal.get(Calendar.DAY_OF_MONTH);
    */

    Calendar eCal = Calendar.getInstance();
    eCal.setTime(expireCovertedDate);

    int eYear = eCal.get(Calendar.YEAR);
    int eMonth = eCal.get(Calendar.MONTH);
    int eDay = eCal.get(Calendar.DAY_OF_MONTH);

    Calendar date1 = Calendar.getInstance();
    Calendar date2 = Calendar.getInstance();

    date1.clear();
    date1.set(cYear, cMonth, cDay);
    date2.clear();
    date2.set(eYear, eMonth, eDay);

    long diff = date2.getTimeInMillis() - date1.getTimeInMillis();

    float dayCount = (float) diff / (24 * 60 * 60 * 1000);

    return ("" + (int) dayCount + " Days");
}

Вот двухстрочное решение:

long msDiff = Calendar.getInstance().getTimeInMillis() - testCalendar.getTimeInMillis();
long daysDiff = TimeUnit.MILLISECONDS.toDays(msDiff);

В этом примере он получает количество дней между датой «testCalendar» и текущей датой.

Наконец-то я нашел самый простой способ справиться с этим. Вот мой код:

public int getTimeRemaining()
{
    Calendar sDate = toCalendar(this.dateEvent);
    Calendar eDate = toCalendar(System.currentTimeMillis());

    // Get the represented date in milliseconds
    long milis1 = sDate.getTimeInMillis();
    long milis2 = eDate.getTimeInMillis();

    // Calculate difference in milliseconds
    long diff = Math.abs(milis2 - milis1);

    return (int)(diff / (24 * 60 * 60 * 1000));
}

private Calendar toCalendar(long timestamp)
{
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeInMillis(timestamp);
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);
    return calendar;
}

Надеюсь, поможет.

Вы никогда не должны использовать такую ​​формулу, как 24 * 60 * 60 * 1000! Почему? Потому что есть дневное время, и не все дни имеют 24 часа, а что касается високосного года, у которого есть +1 день. Вот почему существует класс календаря. Если вы не хотите добавлять в свой проект какую-либо внешнюю библиотеку, например Jodatime, вы можете использовать чистый класс Calendar с очень эффективной функцией:

public static int numDaysBetween(final Calendar c, final long fromTime, final long toTime) {
    int result = 0;
    if (toTime <= fromTime) return result;

    c.setTimeInMillis(toTime);
    final int toYear = c.get(Calendar.YEAR);
    result += c.get(Calendar.DAY_OF_YEAR);

    c.setTimeInMillis(fromTime);
    result -= c.get(Calendar.DAY_OF_YEAR);

    while (c.get(Calendar.YEAR) < toYear) {
        result += c.getActualMaximum(Calendar.DAY_OF_YEAR);
        c.add(Calendar.YEAR, 1);
    }

    return result;
}

У меня была такая же потребность, я, наконец, остановился на Joda Time, это очень удобно и предлагает множество дополнительных функций, включая ту, которую вы ищете.

Вы можете загрузить файлы с здесь.

После того, как вы включили файл jar в свой проект, вы можете легко сделать, например, следующее:

int daysBetween = Days.daysBetween(new DateTime(sDate), new DateTime(eDate)).getDays();

лучший путь :-

        long fromCalender = Calender.getInstance();
        fromCalender.set...// set the from dates
        long toCalender = Calender.getInstance();
        fromCalender.set...// set the to dates

        long diffmili = fromCalender - toCalender;

        long hours = TimeUnit.MILLISECONDS.toHours(diffmili);
        long days = TimeUnit.MILLISECONDS.toDays(diffmili);
        long min = TimeUnit.MILLISECONDS.toMinutes(diffmili);
        long sec = TimeUnit.MILLISECONDS.toSeconds(diffmili);

Лучшее решение, которое сработало для меня, это:

private static int findDaysDiff(long unixStartTime,long unixEndTime)
    {
        Calendar calendar1 = Calendar.getInstance();
        calendar1.setTimeInMillis(unixStartTime);
        calendar1.set(Calendar.HOUR_OF_DAY, 0);
        calendar1.set(Calendar.MINUTE, 0);
        calendar1.set(Calendar.SECOND, 0);
        calendar1.set(Calendar.MILLISECOND, 0);

        Calendar calendar2 = Calendar.getInstance();
        calendar2.setTimeInMillis(unixEndTime);
        calendar2.set(Calendar.HOUR_OF_DAY, 0);
        calendar2.set(Calendar.MINUTE, 0);
        calendar2.set(Calendar.SECOND, 0);
        calendar2.set(Calendar.MILLISECOND, 0);

        return (int) ((calendar2.getTimeInMillis()-calendar1.getTimeInMillis())/(24 * 60 * 60 * 1000));

    }

Так как он сначала конвертирует Hour, Minute, Second и Millisecond в 0 и теперь разница будет только в днях.

fun TimeZone.daysBetween(from: Date, to: Date): Int {
    val offset = rawOffset + dstSavings
    return ((to.time + offset) / 86400000).toInt() - ((from.time + offset) / 86400000).toInt()
}

Попробуй:

    val f = SimpleDateFormat("yyyy-MM-dd HH:mm:ss").apply {
        timeZone = TimeZone.getTimeZone("GMT")
    }
    val df = f.parse("2019-02-28 22:59:59")
    val dt = f.parse("2019-02-28 23:00:00")

    TimeZone.getTimeZone("GMT").daysBetween(df, dt)  // 0
    TimeZone.getTimeZone("GMT+1").daysBetween(df, dt) // 1

java.time и ThreeTenABP

Я хотел бы внести современный ответ: используйте java.time, современный API даты и времени Java для вашей работы с датами. Если разрабатываете для Android API level 25 и ниже, то через бэкпорт для Android, ThreeTenABP (ссылка внизу).

    LocalDate eDate = LocalDate.now(ZoneId.of("Europe/Paris"));
    LocalDate sDate = eDate.minusDays(127);

    long daysBetween = ChronoUnit.DAYS.between(sDate, eDate);
    System.out.println(daysBetween);

Когда я запустил этот код сегодня, результат был ожидаемым:

127

Обратите внимание, что код не только короче, но и всего одна строка для поиска разницы; это также яснее и естественнее для чтения. Классы Date и Calendar, которые вы использовали, плохо спроектированы и давно устарели. Я рекомендую вам не использовать их.

Что пошло не так в вашем коде?

У вас int переполнение при преобразовании 127 дней в миллисекунды. В математике 127 * 24 * 3600 * 1000 равно 10 972 800 000. Поскольку числа, которые вы умножаете, равны int, Java выполняет умножение в int, а наибольшее число, которое может содержать int, равно 2 147 483 647, что далеко не достаточно для ожидаемого результат. В этой ситуации было бы неплохо, если бы Java выдал исключение или каким-то другим образом сообщил нам об ошибке. Это не так. Он неявно отбрасывает старшие биты, что дает нам результат -1 912 101 888. Вычитание этого отрицательного числа из текущего времени эквивалентно добавлению 22 дней и нескольких часов. Это объясняет, почему вы получили 22. Забавно, что было опубликовано 13 ответов, и кажется, что никто этого не заметил…

Однако даже при выполнении умножения с использованием типа long 127 дней по-прежнему вычисляются неправильно. Если 127 дней пересекают переход на летнее время (DST) или обратно, что во Франции имеет место в течение 254 из 365 дней в году, днем ​​перехода будет не 24 часа, а либо 23, либо 25 часов. Что вызывает неправильное количество миллисекунд.

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

Вопрос: Разве для java.time не требуется Android API уровня 26?

java.time прекрасно работает как на старых, так и на новых устройствах Android. Просто требуется как минимум Java 6.

• В Java 8 и более поздних версиях, а также на более новых устройствах Android (начиная с уровня API 26) современный API встроен.
• В не-Android Java 6 и 7 получите ThreeTen Backport, бэкпорт современных классов (ThreeTen для JSR 310; см. ссылки внизу).
• На (старом) Android используйте версию ThreeTen Backport для Android. Он называется ThreeTenABP. И убедитесь, что вы импортируете классы даты и времени из org.threeten.bp с подпакетами.

Ссылки

• учебное пособие по Oracle: дата и время, объясняющее, как использовать java.time.
• Запрос спецификации Java (JSR) 310, где впервые было описано java.time.
• Проект ThreeTen Backport, бэкпорт java.time на Java 6 и 7 (ThreeTen для JSR-310).
• ThreeTenABP, версия ThreeTen Backport для Android
• Вопрос: Как использовать ThreeTenABP в проекте Android, с очень тщательным объяснение.

Делайте так, он поддерживает все уровни API.

    Calendar cal = Calendar.getInstance();
    SimpleDateFormat sdf = new SimpleDateFormat("MMM dd yyyy HH:mm:ss", 
    Locale.ENGLISH);
    try {
        String datestart="June 14 2018 16:02:37";
        cal.setTime(sdf.parse(datestart));// all done
         Calendar cal1=Calendar.getInstance();
        String formatted = sdf.format(cal1.getTime());//formatted date as i want
        cal1.setTime(sdf.parse(formatted));// all done

        long msDiff = cal1.getTimeInMillis() - cal.getTimeInMillis();
        long daysDiff = TimeUnit.MILLISECONDS.toDays(msDiff);
        Toast.makeText(this, "days="+daysDiff, Toast.LENGTH_SHORT).show();
    } catch (ParseException e) {
        e.printStackTrace();
    }

ответ неверен в некоторых датах, таких как «2019/02/18», «2019/02/19», но я редактирую и исправляю ошибку

это лучший метод:

 public int getCountOfDays(String createdDateString, String expireDateString) {

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

        Date createdConvertedDate = null;
        Date expireCovertedDate = null;
        try {
            createdConvertedDate = dateFormat.parse(createdDateString);
            expireCovertedDate = dateFormat.parse(expireDateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }


        Calendar start = new GregorianCalendar();
        start.setTime(createdConvertedDate);

        Calendar end = new GregorianCalendar();
        end.setTime(expireCovertedDate);

        long diff = end.getTimeInMillis() - start.getTimeInMillis();

        float dayCount = (float) diff / (24 * 60 * 60 * 1000);


        return (int) (dayCount);
    }

Наслаждайтесь и, если это было полезно, + проголосуйте за этот ответ;)

Расширение Kotlin:

fun Date?.getDaysBetween(dest: Date?): Int {

    if(this == null || dest == null) return 0

    val diff = abs(this.time - dest.time)
    val dayCount = diff.toFloat() / (24 * 60 * 60 * 1000)
    return dayCount.toInt()
}

Я считаю дни между датой последней отправки и текущей датой, если она меньше нуля, тогда студент не может подать заявку. Я работаю с котлином. Приведенный ниже код поможет вам.

 var calendar=Calendar.getInstance().time
 var dateFormat= SimpleDateFormat("dd/M/yyyy")
 var d2=dateFormat.parse(data.get("date").toString())
 var cd=dateFormat.format(calendar)
 var d1=dateFormat.parse(cd)
 var diff=d2.time-d1.time
 var ddd= TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS)

Это версия Java 8 java.time, которая отлично работает для меня. Возможно, вы захотите убедиться, что startDate и endDate установлены на одно и то же время, иначе дни могут отличаться на +-1! Это версии Kotlin, которые я только что скопировал/вставил.

private fun getDawnOfDay(instant: Instant): Temporal =
        LocalDate.from(instant.atZone(ZoneOffset.UTC)).atStartOfDay()

fun getNumberOfDaysInBetween(startDate: Date, endDate: Date) =
        Duration.between(getDawnOfDay(startDate.toInstant()), getDawnOfDay(endDate.toInstant()))
            .toDays()

Я только что немного изменил самый популярный ответ. Вот мое решение: daysBetween() — возвращает количество дней между двумя датами.

public static long daysBetween(Date date1, Date date2) {
        long msDiff = resetTimeToDateStart(date1).getTime() - resetTimeToDateStart(date2).getTime();
        return TimeUnit.MILLISECONDS.toDays(msDiff);
    }
private static Date resetTimeToDateStart(Date dDate){
        if (Utils.isNull(dDate)){
            return null;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(dDate);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }