Oblicz dni między dwiema datami w Javie 8

Wiem, że jest wiele pytań na temat SO, ale chcę i przykład przy użyciu nowego interfejsu API Java 8 Date. Znam również bibliotekę JodaTime, ale chcę sposób pracy bez bibliotek zewnętrznych.

Funkcja musi narzekać na te ograniczenia:

1. Zapobiegaj błędom od daty oszczędzania
2. Dane wejściowe to dwa obiekty Data (bez czasu znam lokalny czas, ale muszę zrobić z instancjami daty)

Jeśli chcesz logiczne dni kalendarzowe , użyj DAYS.between()metody z java.time.temporal.ChronoUnit:

LocalDate dateBefore;
LocalDate dateAfter;
long daysBetween = DAYS.between(dateBefore, dateAfter);

Jeśli chcesz dosłownie 24 godziny na dobę ( czas trwania ), możesz Durationzamiast tego skorzystać z zajęć:

LocalDate today = LocalDate.now()
LocalDate yesterday = today.minusDays(1);
// Duration oneDay = Duration.between(today, yesterday); // throws an exception
Duration.between(today.atStartOfDay(), yesterday.atStartOfDay()).toDays() // another option

Aby uzyskać więcej informacji, zapoznaj się z tym dokumentem .

Na podstawie komentarzy VGR tutaj możesz użyć:

ChronoUnit.DAYS.between(firstDate, secondDate)

Możesz użyć until():

LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
LocalDate christmas = LocalDate.of(2014, Month.DECEMBER, 25);

System.out.println("Until christmas: " + independenceDay.until(christmas));
System.out.println("Until christmas (with crono): " + independenceDay.until(christmas, ChronoUnit.DAYS));

Możesz używać DAYS.betweenzjava.time.temporal.ChronoUnit

na przykład

import java.time.temporal.ChronoUnit;

public long getDaysCountBetweenDates(LocalDate dateBefore, LocalDate dateAfter) {
    return DAYS.between(dateBefore, dateAfter);
}

Jeśli startDate i endDate są instancją java.util.Date

Możemy użyć metody between () z ChronoUnit enum:

public long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive) {
    //..
}

ChronoUnit.DAYS zlicza dni, które ukończyły 24 godziny .

import java.time.temporal.ChronoUnit;

ChronoUnit.DAYS.between(startDate.toInstant(), endDate.toInstant());

//OR 

ChronoUnit.DAYS.between(Instant.ofEpochMilli(startDate.getTime()), Instant.ofEpochMilli(endDate.getTime()));

Użyj DAYS in enum java.time.temporal.ChronoUnit . Poniżej znajduje się przykładowy kod:

Dane wyjściowe: * Liczba dni między datą rozpoczęcia: 01.03.2015 a datą zakończenia: 2016-03-03 wynosi ==> 368. ** Liczba dni między datą rozpoczęcia: 03.03.2016 i datą zakończenia: 01.03.2015 jest ==> -368 *

package com.bitiknow.date;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

/**
 * 
 * @author pradeep
 *
 */
public class LocalDateTimeTry {
    public static void main(String[] args) {

        // Date in String format.
        String dateString = "2015-03-01";

        // Converting date to Java8 Local date
        LocalDate startDate = LocalDate.parse(dateString);
        LocalDate endtDate = LocalDate.now();
        // Range = End date - Start date
        Long range = ChronoUnit.DAYS.between(startDate, endtDate);
        System.out.println("Number of days between the start date : " + dateString + " and end date : " + endtDate
                + " is  ==> " + range);

        range = ChronoUnit.DAYS.between(endtDate, startDate);
        System.out.println("Number of days between the start date : " + endtDate + " and end date : " + dateString
                + " is  ==> " + range);

    }

}

Wszyscy mówią, aby używać ChronoUnit.DAYS.between, ale to tylko deleguje na inną metodę, którą możesz nazwać sobą. Więc możesz też zrobić firstDate.until(secondDate, ChronoUnit.DAYS).

Dokumenty dla obu faktycznie wspominają o obu podejściach i mówią, aby użyć tego, który jest bardziej czytelny.

Proszę bardzo:

public class DemoDate {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println("Current date: " + today);

        //add 1 month to the current date
        LocalDate date2 = today.plus(1, ChronoUnit.MONTHS);
        System.out.println("Next month: " + date2);

        // Put latest date 1st and old date 2nd in 'between' method to get -ve date difference
        long daysNegative = ChronoUnit.DAYS.between(date2, today);
        System.out.println("Days : "+daysNegative);

        // Put old date 1st and new date 2nd in 'between' method to get +ve date difference
        long datePositive = ChronoUnit.DAYS.between(today, date2);
        System.out.println("Days : "+datePositive);
    }
}

Uzyskaj liczbę dni przed świętami Bożego Narodzenia od bieżącego dnia, spróbuj tego

System.out.println(ChronoUnit.DAYS.between(LocalDate.now(),LocalDate.of(Year.now().getValue(), Month.DECEMBER, 25)));

Jeśli celem jest uzyskanie różnicy w dniach, a ponieważ powyższe odpowiedzi wspominają o metodach delegowania, chcielibyśmy zauważyć, że kiedyś można po prostu użyć -

public long daysInBetween(java.time.LocalDate startDate, java.time.LocalDate endDate) {
  // Check for null values here

  return endDate.toEpochDay() - startDate.toEpochDay();
}

get dni między dwiema datami data jest instancją java.util.Date

public static long daysBetweenTwoDates(Date dateFrom, Date dateTo) {
            return DAYS.between(Instant.ofEpochMilli(dateFrom.getTime()), Instant.ofEpochMilli(dateTo.getTime()));
        }

Wiem, że to pytanie dotyczy Java 8, ale w Javie 9 możesz użyć:

public static List<LocalDate> getDatesBetween(LocalDate startDate, LocalDate endDate) {
    return startDate.datesUntil(endDate)
      .collect(Collectors.toList());
}

Użyj klasy lub metody, która najlepiej odpowiada Twoim potrzebom:

• klasa czasu trwania ,
• Klasa okresowa ,
• lub metoda ChronoUnit.between .

Czas trwania mierzy czas przy użyciu wartości opartych na czasie (sekundy, nanosekundy).

Okres używa wartości opartych na dacie (lata, miesiące, dni).

Metoda ChronoUnit.between jest przydatna, gdy chcesz zmierzyć ilość czasu w pojedynczej jednostce czasu, na przykład dni lub sekund.

https://docs.oracle.com/javase/tutorial/datetime/iso/period.html