Différence en jours entre deux dates en Java?

Je vous suggère d'utiliser l'excellent Joda Time de la bibliothèque au lieu de l'imparfait de java.util.Date et amis. Vous pouvez simplement écrire

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

La diff /(24 * etc) ne prend pas de Fuseau horaire en compte, donc si votre fuseau horaire par défaut a une heure d'été, il peut lancer le calcul off.

Ce lien a une jolie petite mise en œuvre.

Ici est la source du lien ci-dessus dans le cas où le lien est en bas:

/** 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;  
}  

et

/** 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;  
}

Cela dépend de ce que vous définissez comme la différence. Pour comparer deux dates à minuit, vous pouvez le faire.

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

Solution à l'aide de la différence entre les millisecondes de temps, avec arrondi correct de l'heure d'été dates:

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
}

Une remarque: bien sûr, les dates doivent être dans une certaine fuseau horaire.

Le code important:

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

Si vous ne voulez pas rond, vous pouvez utiliser UTC dates,

J'utilise cette fonction:

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

ma fonction:

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

Basé sur @Mad_Troll réponse, j'ai développé cette méthode.

J'ai couru à propos de 30 cas de test contre elle, est la seule méthode qui gère sous le temps de la journée fragments correctement.

Exemple: Si vous passez maintenant & maintenant + 1 milliseconde, c'est toujours le même jour.
Faire 1-1-13 23:59:59.098 à 1-1-13 23:59:59.099 retourne 0 jours, correctement; attribuer des autres méthodes posté ici ne pas le faire correctement.

Intéressant de noter qu'il ne se soucie pas de la façon dont vous les mettez dans, Si votre date de fin qui est avant la date de votre départ, il va compter à rebours.

/**
* 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;
}

Vous pouvez supprimer le @NotNull annotations, ces données sont utilisées par l'Ide de faire de l'analyse de code à la volée

Centaine de lignes de code pour cette fonction de base???

Juste une méthode simple:

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

ThreeTen-Extra

La Réponse par Vitalii Fedorenko est correct, décrivant la manière d'effectuer ce calcul de façon moderne avec java.le temps classes (Durée & ChronoUnit) intégré dans Java 8 et plus tard (et dos-porté à Java 6 & 7 et pour Android).

Days

Si vous êtes en utilisant un certain nombre de jours régulièrement dans votre code, vous pouvez le remplacer de simples entiers avec l'utilisation d'une classe. Le Jours classe peut être trouvé dans la ThreeTen-Extra projet, une extension de java.de temps et de terrain d'essai pour de possibles futurs ajouts à java.temps. Le Days classe fournit un moyen sûr de représenter un nombre de jours de votre demande. La classe comprend la pratique des constantes pour ZÉRO et ON.

Compte tenu de la vieille désuet java.util.Date objets dans la Question, d'abord les convertir moderne java.temps.Instantané objets. La vieille date-heure classes ont récemment ajouté des méthodes pour faciliter la conversion de java.le temps, tel un java.util.Date: toInstant.

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

Passer les deux Instant objets à l'usine méthode pour org.threeten.supplémentaire.Jours.

Dans l'implémentation actuelle (2016-06) c'est un wrapper appel java.temps.temporelle.ChronoUnit.JOURS.entre, lire la ChronoUnit classe doc pour plus de détails. Pour être clair: tout en majuscules DAYS est dans l'enum ChronoUnit alors que les premières-cap Days est une classe de ThreeTen-Extra.

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

Vous pouvez passer ces Days les objets autour de votre propre code. Vous pouvez sérialiser à une Chaîne dans la norme ISO 8601 format en appelant toString. Ce format de PnD utilise un P pour marquer le début et D signifie “jours”, avec un nombre de jours entre les deux. Les deux java.les classes de temps et ThreeTen-Extra utiliser ces formats standard par défaut lors de la génération et l'analyse des Chaînes de caractères représentant la date valeurs de temps.

String output = days.toString();

P3D

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

Si vous êtes à la recherche d'une solution qui renvoie un nombre ou de jours entre par exemple 11/30/2014 23:59 et 12/01/2014 00:01 voici la solution à l'aide de Joda Time.

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

Cette mise en œuvre sera de retour 1 comme une différence en jours. La plupart des solutions posté ici calculer la différence en millisecondes entre deux dates. Cela signifie que 0 serait retourné parce qu'il y a seulement 2 minutes de différence entre ces deux dates.

Vous devez utiliser Joda Time library parce que Java Util Date renvoie des valeurs erronées parfois.

Joda vs Java Util Date

Par exemple les jours entre hier (jj-mm-aaaa, 12-07-2016) et le premier jour de l'année 1957 (jj-mm-aaaa, 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);
}

Donc j'ai vraiment des conseils vous de faire usage de Joda Time library.