web-dev-qa-db-fra.com

Calculer des jours entre deux dates en Java 8

Je sais qu'il y a beaucoup de questions sur SO sur la façon d'obtenir, mais je veux un exemple d'utilisation d'une nouvelle API Java 8 Date. Je connais aussi la bibliothèque JodaTime, mais je veux une méthode de travail sans bibliothèques externes.

Function doit se plaindre de ces restrictions:

  1. Empêcher les erreurs de date savetime
  2. Les entrées sont deux objets Date (sans heure, je connais heure locale, mais je dois faire avec les instances de date)
javajava-8java-timedaysdate-difference
174
Marcos

Si vous voulez jours calendaires logiques, utilisez DAYS.between() méthode from Java.time.temporal.ChronoUnit :

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

Si vous voulez literal 24 hours hour, (un duration), vous pouvez utiliser le Duration class à la place:

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

Pour plus d'informations, reportez-vous à à ce document (et à d'autres documents concernant Java 8 d'Oracle).

295
syntagma

D'après les commentaires de VGR, voici ce que vous pouvez utiliser:

ChronoUnit.DAYS.between(firstDate, secondDate)
93
Sunil B

Vous pouvez utiliser 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));
29
nazar_art

Vous pouvez utiliser DAYS.between à partir de Java.time.temporal.ChronoUnit

par exemple.

import Java.time.temporal.ChronoUnit;

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

Utilisez les JOURS dans enum Java.time.temporal.ChronoUnit . Voici l'exemple de code:

Sortie: * Nombre de jours entre la date de début: 2015-03-01 et la date de fin: 2016-03-03 est ==> 368 . ** Nombre de jours entre la date de début : 2016-03-03 et fin: 2015-03-01 is ==> -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);

    }

}
5
Pradeep Padmarajaiah

Tout le monde dit d’utiliser ChronoUnit.DAYS.between, mais cela ne fait que déléguer à une autre méthode que vous pouvez appeler vous-même. Donc, vous pouvez aussi faire firstDate.until(secondDate, ChronoUnit.DAYS).

Les documents pour les deux mentionnent en fait les deux approches et recommandent d'utiliser celle qui est la plus lisible.

5
nafg

Voici:

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

Obtenez le nombre de jours avant Noël du jour actuel, essayez ceci

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

get jours entre deux dates date date est l'instance de Java.util.Date

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

Si l’objectif est simplement d’obtenir la différence en jours et que les réponses ci-dessus mentionnent les méthodes des délégués, vous pouvez indiquer qu’une fois, vous pouvez aussi simplement utiliser -

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

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

Si starDate et endDate sont des instances de Java.util.Date, outre à @mohamed réponse

Integer noOfDays = ChronoUnit.DAYS.between(startDate.toInstant(), endDate.toInstant());

mais ChronoUnit.DAYS comptent les jours qui ont duré 24 heures.

0
Pawan

Je sais que cette question concerne Java 8, mais avec Java 9, vous pouvez utiliser:

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