Calculer les jours entre deux dates dans Java 8

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

La fonction doit se plaindre de ces restrictions:

1. Empêche les erreurs de sauvegarder la date
2. Les entrées sont deux objets de Date (sans heure, je connais localdatetime, mais je dois faire avec les instances de date)

Si vous voulez des jours calendaires logiques , utilisez la DAYS.between()méthode de java.time.temporal.ChronoUnit:

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

Si vous voulez des jours littéraux de 24 heures (une durée ), vous pouvez utiliser la Durationclasse à 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 .

Sur la base des commentaires de VGR, voici ce que vous pouvez utiliser:

ChronoUnit.DAYS.between(firstDate, secondDate)

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

Vous pouvez utiliser à DAYS.betweenpartir dejava.time.temporal.ChronoUnit

par exemple

import java.time.temporal.ChronoUnit;

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

Si startDate et endDate sont des instances de java.util.Date

Nous pouvons utiliser la méthode between () de l' énumération ChronoUnit :

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

ChronoUnit.DAYS compte les jours qui se sont terminés sur 24 heures .

import java.time.temporal.ChronoUnit;

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

//OR 

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

Utilisez les JOURS dans l'énumération 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 la date de fin: 2015-03-01 est ==> -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);

    }

}

Tout le monde dit d'utiliser ChronoUnit.DAYS.between mais cela délègue simplement à une autre méthode que vous pourriez vous appeler. Vous pourriez donc aussi le faire firstDate.until(secondDate, ChronoUnit.DAYS).

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

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

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

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

Si l'objectif est simplement d'obtenir la différence en jours et que les réponses ci-dessus mentionnent les méthodes de délégué, je voudrais souligner qu'une fois, vous pouvez également simplement utiliser -

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

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

obtenir des jours entre deux dates date est une instance de java.util.Date

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

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

Utilisez la classe ou la méthode qui répond le mieux à vos besoins:

• la classe Durée ,
• Classe de période ,
• ou la méthode ChronoUnit.between .

Une durée mesure une durée en utilisant des valeurs basées sur le temps (secondes, nanosecondes).

Une période utilise des valeurs basées sur la date (années, mois, jours).

La méthode ChronoUnit.between est utile lorsque vous souhaitez mesurer une quantité de temps dans une seule unité de temps, comme des jours ou des secondes.

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