Le calcul de la différence entre Java deux occurrences de date

Simple diff (sans lib)

/**
 * Get a diff between two dates
 * @param date1 the oldest date
 * @param date2 the newest date
 * @param timeUnit the unit in which you want the diff
 * @return the diff value, in the provided unit
 */
public static long getDateDiff(Date date1, Date date2, TimeUnit timeUnit) {
    long diffInMillies = date2.getTime() - date1.getTime();
    return timeUnit.convert(diffInMillies,TimeUnit.MILLISECONDS);
}

Et vous pouvez appeler:

getDateDiff(date1,date2,TimeUnit.MINUTES);

pour obtenir la diff des 2 dates dans les minutes de l'unité.

TimeUnit est java.util.concurrent.TimeUnit, un standard de Java enum allant de nanos pour jours.

---

Lisible par l'homme diff (sans lib)

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {

    long diffInMillies = date2.getTime() - date1.getTime();

    //create the list
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);

    //create the result map of TimeUnit and difference
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;

    for ( TimeUnit unit : units ) {

        //calculate difference in millisecond 
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;

        //put the result in the map
        result.put(unit,diff);
    }

    return result;
}

http://ideone.com/5dXeu6

La sortie est quelque chose comme Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, avec les unités commandées.

Vous suffit de convertir qui correspond à un convivial chaîne.

---

Avertissement

Le code ci-dessus des extraits de calculer un simple diff entre 2 instants. Il peut causer des problèmes pendant l'heure d'été de l'interrupteur, comme expliqué dans le ce post. Cela signifie que si vous calculez la diff entre les dates avec un rien de temps vous pouvez avoir un manque de jour/heure.

À mon avis la date de diff est une sorte de subjectivité, surtout sur jours. Vous pouvez:

• compter le nombre de 24h le temps écoulé: jour+1 jour = 1 jour = 24h

• compter le nombre de temps écoulé, en prenant soin de l'heure d'été: jour+1 jour = 1 = 24h (mais l'utilisation de minuit l'heure et de l'heure d'été, il pourrait être de 0 jour et 23h)

• compter le nombre de day switches, ce qui signifie jour+1 1pm jours de 11h = 1 journée, même si le temps écoulé est juste 2h (ou 1h si il y a une heure :p)

Ma réponse est valable que si votre définition de la date de diff sur les jours de match le 1er cas

Avec JodaTime

Si vous utilisez JodaTime vous pouvez obtenir le diff pour 2 instants (millies soutenu ReadableInstant) dates:

Interval interval = new Interval(oldInstant, new Instant());

Mais vous pouvez aussi faire la diff Locales pour les dates/heures:

//returns 4 because of the leap year of 366 days
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5), PeriodType.years()).getYears() 

//this time it returns 5
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5+1), PeriodType.years()).getYears() 

//And you can also use these static methods
Years.yearsBetween(LocalDate.now(), LocalDate.now().plusDays(365*5)).getYears()

Vous devez définir votre problème plus clairement. Vous pourrait il suffit de prendre le nombre de millisecondes entre les deux Date objets et de les diviser par le nombre de millisecondes dans les 24 heures, par exemple... mais:

• Ce ne prendra pas en compte les fuseaux horaires - Date est toujours en UTC
• Ce ne sera pas l'heure d'été en considération (où il peut y avoir des jours qui ne sont que 23 heures, par exemple)
• Même au sein de l'UTC, combien de jours sont là, dans le 16 août 11pm au 18 août à 2h du matin? C'est seulement de 27 heures, cela veut-il dire un jour? Ou devrait-il être trois jours, parce qu'il couvre trois dates?

tl;dr

Convertir votre obsolètes java.util.Date les objets à leur remplacement, java.time.Instant. Puis de calculer le temps écoulé comme un Duration.

Duration d = 
    Duration.between(                   //Calculate the span of time between two moments as a number of hours, minutes, and seconds.
        myJavaUtilDate.toInstant() ,    //Convert legacy class to modern class by calling new method added to the old class.
        Instant.now()                   //Capture the current moment in UTC. About two and a half hours later in this example.
    )
;

d.toString(): PT2H34M56S

d.toMinutes(): 154

d.toMinutesPart(): 34

Format ISO 8601: PnYnMnDTnHnMnS

Le sensible standard ISO 8601 définit une forme concise, la représentation textuelle d'un laps de temps qu'un certain nombre d'années, mois, jours, heures, etc. La norme exige que de tels une durée de un durée. Le format est PnYnMnDTnHnMnS où la P signifie "Période", le T sépare la partie date de la partie heure, et entre les deux sont des chiffres suivis d'une lettre.

Exemples:

• P3Y6M4DT12H30M5S
  trois ans, six mois, quatre jours, douze heures, trente minutes et cinq secondes
• PT4H30M
  Quatre heures et demie

java.temps

La java.le temps cadre intégré dans Java 8 et, plus tard, supplante le gênants vieux java.util.Date/java.util.Calendar classes. Les nouvelles classes sont inspirés par la très réussie Joda-Time cadre, comme son successeur, un concept similaire, mais ré-architecturé. Défini par JSR 310. Prolongé par le ThreeTen-Extra projet. Voir la Tutoriel.

Moment

La Instantané classe représente un moment dans le scénario de UTC avec une résolution de nanosecondes (jusqu'à neuf (9) chiffres d'une fraction décimale).

Instant instant = Instant.now() ;  //Capture current moment in UTC.

Mieux éviter de l'héritage des classes comme Date/Calendar. Mais si vous devez inter-opérer avec de l'ancien code pas encore mis à jour à java.temps, convertir en arrière et en avant. Appelle de nouvelles méthodes de conversion ajouté des anciennes classes. Pour passer d'une java.util.Date à un Instantané, appel Date: toInstant.

Instant instant = myJavaUtilDate.toInstant() ;  //Convert from legacy `java.util.Date` class to modern `java.time.Instant` class.

Laps de temps

La java.les classes de temps avoir partagé cette idée de représenter un laps de temps qu'un certain nombre d'années, mois, jours, heures, minutes, secondes en deux moitiés:

• Délai pendant des années, les mois, les jours
• Durée de jours, heures, minutes, secondes

Ici est un exemple.

ZoneId zoneId = ZoneId.of ( "America/Montreal" );
ZonedDateTime now = ZonedDateTime.now ( zoneId );
ZonedDateTime future = now.plusMinutes ( 63 );
Duration duration = Duration.between ( now , future );

De vidage de la console.

Les deux Period et Duration utiliser le ISO 8601 standard pour la génération d'une représentation de Chaîne de valeur.

System.out.println ( "now: " + now + " to future: " + now + " = " + duration );

maintenant: 2015-11-26T00:46:48.016-05:00[America/Montreal] pour l'avenir: 2015-11-26T00:46:48.016-05:00[America/Montreal] = PT1H3M

Java 9 ajoute des méthodes de Duration pour obtenir les jours de la partie, heures le cadre, à quelques minutes de la partie, et les secondes de la partie.

Vous pouvez obtenir le nombre total de jours ou en heures ou en minutes ou en secondes ou millisecondes ou nanosecondes dans l'ensemble de la Durée.

long totalHours = duration.toHours();

En Java 9 la Durée de la classe obtient de nouvelles méthodes pour le retour les différentes parties de jours, heures, minutes, secondes, millisecondes/nanosecondes. Appelez le to…Part méthodes: toDaysPart(), toHoursPart(), et ainsi de suite.

ChronoUnit

Si vous ne se soucient plus simples, plus grande granularité de temps, tels que le “nombre de jours écoulés”, utilisez la ChronoUnit enum.

long daysElapsed = ChronoUnit.DAYS.between( earlier , later );

Un autre exemple.

Instant now = Instant.now();
Instant later = now.plus( Duration.ofHours( 2 ) );
…
long minutesElapsed = ChronoUnit.MINUTES.between( now , later );

120

---

Sur java.temps

La java.le temps cadre est intégré dans Java 8 et les versions ultérieures. Ces classes permettent d'éviter la pénible vieux héritage date du temps des classes comme java.util.Date, Agenda, & SimpleDateFormat.

La Joda-Time projet, maintenant dans le mode de maintenance, conseille la migration vers java.temps.

Pour en savoir plus, consultez les Oracle Tutoriel. Et de recherche de Débordement de Pile pour de nombreux exemples et des explications. La spécification est JSR 310.

Où obtenir le java.les classes de temps?

• Java SE 8 et SE 9 et plus tard
  • Intégré.
  • Partie de la norme API Java avec une liasse de mise en œuvre.
  • Java 9 ajoute quelques fonctionnalités mineures et corrections.
• Java SE 6 et SE 7
  • Une grande partie de la java.fonction temps est de retour, porté à Java 6 & 7 dans ThreeTen-Backport.
• Android
  • La ThreeTenABP projet s'adapte ThreeTen-Backport (mentionné ci-dessus) pour Android en particulier.
  • Voir Comment l'utiliser....

La ThreeTen-Extra projet s'étend java.temps avec d'autres classes. Ce projet est un terrain d'essai pour de possibles futurs ajouts à java.temps. Vous pouvez trouver quelques classes utiles ici comme Intervalle, YearWeek, YearQuarter, et plus.

---

Joda-Time

Mise à JOUR: Le Joda-Time projet est maintenant dans le mode de maintenance, avec l'équipe conseiller de la migration vers le java.le temps classes. Je laisse cette section intacte pour l'histoire.

La Joda-Time library utilise la norme ISO 8601 pour sa valeur par défaut. Son Period classe d'analyse et génère ces PnYnMnDTnHnMnS chaînes.

DateTime now = DateTime.now(); //Caveat: Ignoring the important issue of time zones.
Period period = new Period( now, now.plusHours( 4 ).plusMinutes( 30));
System.out.println( "period: " + period );

Rend:

period: PT4H30M

Un peu plus simple alternative:

System.currentTimeMillis() - oldDate.getTime()

Pour "le plus beau": eh bien, qu'est-ce exactement avez-vous besoin? Le problème avec les représentant des durées de temps qu'un certain nombre d'heures et de jours etc. c'est qu'il peut conduire à des inexactitudes et de fausses attentes en raison de la complexité de dates (par exemple, les jours peuvent avoir 23 ou 25 heures en raison de l'heure avancée).

Il ya beaucoup de façons dont vous pouvez trouver la différence entre deux dates & fois. L'une des façons les plus simples que je connaisse serait:

      Calendar calendar1 = Calendar.getInstance();
      Calendar calendar2 = Calendar.getInstance();
      calendar1.set(2012, 04, 02);
      calendar2.set(2012, 04, 04);
      long milsecs1= calendar1.getTimeInMillis();
      long milsecs2 = calendar2.getTimeInMillis();
      long diff = milsecs2 - milsecs1;
      long dsecs = diff / 1000;
      long dminutes = diff / (60 * 1000);
      long dhours = diff / (60 * 60 * 1000);
      long ddays = diff / (24 * 60 * 60 * 1000);

      System.out.println("Your Day Difference="+ddays);

L'instruction print est juste un exemple - vous pouvez la mettre en forme comme vous le souhaitez.

Soustrayant la date en millisecondes œuvres (comme décrit dans un autre post), mais vous ont à utiliser HOUR_OF_DAY et pas d'HEURE lors de la suppression des temps de parties de vos dates:

public static final long MSPERDAY = 60 * 60 * 24 * 1000;
...
final Calendar dateStartCal = Calendar.getInstance();
dateStartCal.setTime(dateStart);
dateStartCal.set(Calendar.HOUR_OF_DAY, 0); //Crucial.
dateStartCal.set(Calendar.MINUTE, 0);
dateStartCal.set(Calendar.SECOND, 0);
dateStartCal.set(Calendar.MILLISECOND, 0);
final Calendar dateEndCal = Calendar.getInstance();
dateEndCal.setTime(dateEnd);
dateEndCal.set(Calendar.HOUR_OF_DAY, 0); //Crucial.
dateEndCal.set(Calendar.MINUTE, 0);
dateEndCal.set(Calendar.SECOND, 0);
dateEndCal.set(Calendar.MILLISECOND, 0);
final long dateDifferenceInDays = ( dateStartCal.getTimeInMillis()
                                  - dateEndCal.getTimeInMillis()
                                  ) / MSPERDAY;
if (dateDifferenceInDays > 15) {
    //Do something if difference > 15 days
}

Prendre un coup d'oeil à Joda Time, ce qui est une amélioration de la Date/Heure API pour Java et devrait fonctionner correctement avec Scala.

Si vous avez besoin d'une formaté Chaîne de retour comme
"2 Jours 03h 42m 07s", essayez ceci:

public String fill2(int value)
{
    String ret = String.valueOf(value);

    if (ret.length() < 2)
        ret = "0" + ret;            
    return ret;
}

public String get_duration(Date date1, Date date2)
{                   
    TimeUnit timeUnit = TimeUnit.SECONDS;

    long diffInMilli = date2.getTime() - date1.getTime();
    long s = timeUnit.convert(diffInMilli, TimeUnit.MILLISECONDS);

    long days = s / (24 * 60 * 60);
    long rest = s - (days * 24 * 60 * 60);
    long hrs = rest / (60 * 60);
    long rest1 = rest - (hrs * 60 * 60);
    long min = rest1 / 60;      
    long sec = s % 60;

    String dates = "";
    if (days > 0) dates = days + " Days ";

    dates += fill2((int) hrs) + "h ";
    dates += fill2((int) min) + "m ";
    dates += fill2((int) sec) + "s ";

    return dates;
}

Utiliser l'heure GMT pour obtenir une instance de l'Agenda, définissez l'heure à l'aide de la méthode du Calendrier de la classe. Le fuseau horaire GMT a 0 offset (pas vraiment important) et de l'heure indicateur a la valeur false.

    final Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 9);
    cal.set(Calendar.DAY_OF_MONTH, 29);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date startDate = cal.getTime();

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 12);
    cal.set(Calendar.DAY_OF_MONTH, 21);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date endDate = cal.getTime();

    System.out.println((endDate.getTime() - startDate.getTime()) % (1000l * 60l * 60l * 24l));

public static String getDifferenceBtwTime(Date dateTime) {
long timeDifferenceMilliseconds = new Date().getTime() - dateTime.getTime();
long diffSeconds = timeDifferenceMilliseconds / 1000;
long diffMinutes = timeDifferenceMilliseconds / (60 * 1000);
long diffHours = timeDifferenceMilliseconds / (60 * 60 * 1000);
long diffDays = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24);
long diffWeeks = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 7);
long diffMonths = (long) (timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 30.41666666));
long diffYears = (long)(timeDifferenceMilliseconds / (1000 * 60 * 60 * 24 * 365));
if (diffSeconds < 1) {
return "one sec ago";
} else if (diffMinutes < 1) {
return diffSeconds + " seconds ago";
} else if (diffHours < 1) {
return diffMinutes + " minutes ago";
} else if (diffDays < 1) {
return diffHours + " hours ago";
} else if (diffWeeks < 1) {
return diffDays + " days ago";
} else if (diffMonths < 1) {
return diffWeeks + " weeks ago";
} else if (diffYears < 12) {
return diffMonths + " months ago";
} else {
return diffYears + " years ago";
}
}   

Meilleure chose à faire est de

(Date1-Date2)/86 400 000 

Que le nombre est le nombre de millisecondes en une journée.

Une date-autre date vous donne la différence en millisecondes.

Recueillir la réponse dans un double variable.

C'est probablement la façon la plus simple de le faire - c'est peut-être parce que j'ai été le codage en Java (avec son certes maladroit, la date et l'heure des bibliothèques) pour un certain temps maintenant, mais que le code est "simple et gentil" de moi!

Êtes-vous heureux avec le résultat retourné en millisecondes, ou d'une partie de votre question que vous préférez l'avoir retourné dans certains autre format?

Juste pour répondre à la question initiale:

Placez le code suivant dans une Fonction tout au Long de getAge(){}

Date dahora = new Date();
long MillisToYearsByDiv = 1000l *60l * 60l * 24l * 365l;
long javaOffsetInMillis = 1990l * MillisToYearsByDiv;
long realNowInMillis = dahora.getTime() + javaOffsetInMillis;
long realBirthDayInMillis = this.getFechaNac().getTime() + javaOffsetInMillis;
long ageInMillis = realNowInMillis - realBirthDayInMillis;
return ageInMillis / MillisToYearsByDiv;

Le plus important ici est de travailler avec des numéros longs lorsque la multiplication et la division. Et bien sûr, le décalage que Java s'applique dans son calcul de Dates.

🙂

Voici une correcte de Java 7 solution en O(1), sans dépendances.

public static int countDaysBetween(Date date1, Date date2) {
Calendar c1 = removeTime(from(date1));
Calendar c2 = removeTime(from(date2));
if (c1.get(YEAR) == c2.get(YEAR)) {
return Math.abs(c1.get(DAY_OF_YEAR) - c2.get(DAY_OF_YEAR)) + 1;
}
//ensure c1 <= c2
if (c1.get(YEAR) > c2.get(YEAR)) {
Calendar c = c1;
c1 = c2;
c2 = c;
}
int y1 = c1.get(YEAR);
int y2 = c2.get(YEAR);
int d1 = c1.get(DAY_OF_YEAR);
int d2 = c2.get(DAY_OF_YEAR);
return d2 + ((y2 - y1) * 365) - d1 + countLeapYearsBetween(y1, y2) + 1;
}
private static int countLeapYearsBetween(int y1, int y2) {
if (y1 < 1 || y2 < 1) {
throw new IllegalArgumentException("Year must be > 0.");
}
//ensure y1 <= y2
if (y1 > y2) {
int i = y1;
y1 = y2;
y2 = i;
}
int diff = 0;
int firstDivisibleBy4 = y1;
if (firstDivisibleBy4 % 4 != 0) {
firstDivisibleBy4 += 4 - (y1 % 4);
}
diff = y2 - firstDivisibleBy4 - 1;
int divisibleBy4 = diff < 0 ? 0 : diff / 4 + 1;
int firstDivisibleBy100 = y1;
if (firstDivisibleBy100 % 100 != 0) {
firstDivisibleBy100 += 100 - (firstDivisibleBy100 % 100);
}
diff = y2 - firstDivisibleBy100 - 1;
int divisibleBy100 = diff < 0 ? 0 : diff / 100 + 1;
int firstDivisibleBy400 = y1;
if (firstDivisibleBy400 % 400 != 0) {
firstDivisibleBy400 += 400 - (y1 % 400);
}
diff = y2 - firstDivisibleBy400 - 1;
int divisibleBy400 = diff < 0 ? 0 : diff / 400 + 1;
return divisibleBy4 - divisibleBy100 + divisibleBy400;
}
public static Calendar from(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
return c;
}
public static Calendar removeTime(Calendar c) {
c.set(HOUR_OF_DAY, 0);
c.set(MINUTE, 0);
c.set(SECOND, 0);
c.set(MILLISECOND, 0);
return c;
}

essayez ceci:

int epoch = (int) (new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").parse("01/01/1970  00:00:00").getTime() / 1000);

vous pouvez modifier la chaîne dans le parse() méthodes param.

Juste utiliser la méthode ci-dessous avec deux Date objets. Si vous souhaitez transmettre le courant de la date, il suffit de passer new Date() comme deuxième paramètre tel qu'il est initialisé avec le temps actuel.

public String getDateDiffString(Date dateOne, Date dateTwo)
{
long timeOne = dateOne.getTime();
long timeTwo = dateTwo.getTime();
long oneDay = 1000 * 60 * 60 * 24;
long delta = (timeTwo - timeOne) / oneDay;
if (delta > 0) {
return "dateTwo is " + delta + " days after dateOne";
}
else {
delta *= -1;
return "dateTwo is " + delta + " days before dateOne";
}
}

Aussi, en dehors de de nombre de jours, si vous voulez d'autres paramètre de différence aussi, utiliser de l'extrait de code ci-dessous,

int year = delta / 365;
int rest = delta % 365;
int month = rest / 30;
rest = rest % 30;
int weeks = rest / 7;
int days = rest % 7;

P. S Code est entièrement pris d'une SORTE de réponse.

Les versions antérieures de Java que vous pouvez essayer.

 public static String daysBetween(Date createdDate, Date expiryDate) {
Calendar createdDateCal = Calendar.getInstance();
createdDateCal.clear();
createdDateCal.setTime(createdDate);
Calendar expiryDateCal = Calendar.getInstance();
expiryDateCal.clear();
expiryDateCal.setTime(expiryDate);
long daysBetween = 0;
while (createdDateCal.before(expiryDateCal)) {
createdDateCal.add(Calendar.DAY_OF_MONTH, 1);
daysBetween++;
}
return daysBetween+"";
}

@Michael Borgwardt réponse en fait ne fonctionne pas correctement dans Android. Les erreurs d'arrondi existent. Exemple 19 au 21 Mai, dit 1 jour, car elle jette 1,99 1. Utilisation ronde avant la conversion en int.

Fixer

int diffInDays = (int)Math.round(( (newerDate.getTime() - olderDate.getTime()) 
/ (1000 * 60 * 60 * 24) ))

Notez que cela fonctionne avec les dates UTC, donc, la différence peut être un jour de congé si vous regardez les dates locales. Et à la faire fonctionner correctement avec les dates locales nécessite une approche totalement différente en raison de l'heure avancée.

J'ai aimé le TimeUnit approche fondée sur jusqu'à ce que j'ai trouvé qu'il ne couvre que les cas triviaux où le nombre de combien d'unités d'une timeunit sont dans l'unité supérieure est fixe. Ce en dehors des pauses lorsque vous voulez savoir combien de mois, année, etc sont entre les deux.

voici un comptage approche, pas aussi efficace que certains autres, mais il semble fonctionner pour moi et prend en compte l'heure d'été, trop.

public static String getOffsetAsString( Calendar cNow, Calendar cThen) {
Calendar cBefore;
Calendar cAfter;
if ( cNow.getTimeInMillis() < cThen.getTimeInMillis()) {
cBefore = ( Calendar) cNow.clone();
cAfter = cThen;
} else {
cBefore = ( Calendar) cThen.clone();
cAfter = cNow;
}
//compute diff
Map<Integer, Long> diffMap = new HashMap<Integer, Long>();
int[] calFields = { Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH, Calendar.HOUR_OF_DAY, Calendar.MINUTE, Calendar.SECOND, Calendar.MILLISECOND};
for ( int i = 0; i < calFields.length; i++) {
int field = calFields[ i];
long    d = computeDist( cAfter, cBefore, field);
diffMap.put( field, d);
}
final String result = String.format( "%dY %02dM %dT %02d:%02d:%02d.%03d",
diffMap.get( Calendar.YEAR), diffMap.get( Calendar.MONTH), diffMap.get( Calendar.DAY_OF_MONTH), diffMap.get( Calendar.HOUR_OF_DAY), diffMap.get( Calendar.MINUTE), diffMap.get( Calendar.SECOND), diffMap.get( Calendar.MILLISECOND));
return result;
}
private static int computeDist( Calendar cAfter, Calendar cBefore, int field) {
cBefore.setLenient( true);
System.out.print( "D " + new Date( cBefore.getTimeInMillis()) + " --- " + new Date( cAfter.getTimeInMillis()) + ": ");
int count = 0;
if ( cAfter.getTimeInMillis() > cBefore.getTimeInMillis()) {
int fVal = cBefore.get( field);
while ( cAfter.getTimeInMillis() >= cBefore.getTimeInMillis()) {
count++;
fVal = cBefore.get( field);
cBefore.set( field, fVal + 1);
System.out.print( count + "/"  + ( fVal + 1) + ": " + new Date( cBefore.getTimeInMillis()) + " ] ");
}
int result = count - 1;
cBefore.set( field, fVal);
System.out.println( "" + result + " at: " + field + " cb = " + new Date( cBefore.getTimeInMillis()));
return result;
}
return 0;
}

Il y a un moyen facile de le faire en java

//créer une méthode utilitaire

public long getDaysBetweenDates(Date d1, Date d2){
return TimeUnit.MILLISECONDS.toDays(d1.getTime() - d2.getTime());
}

Cette méthode retourne le nombre de jours entre 2 dates. Soit vous pouvez utiliser la valeur par défaut de java au format de date peut facilement convertir tout format de la date.

Si vous voulez fixer la question des plages de dates que croix de l'heure d'été limite (par exemple, une date dans l'heure d'été et l'autre en hiver), vous pouvez l'utiliser pour obtenir la différence en jours:

public static long calculateDifferenceInDays(Date start, Date end, Locale locale) {
Calendar cal = Calendar.getInstance(locale);
cal.setTime(start);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
long startTime = cal.getTimeInMillis();
cal.setTime(end);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
long endTime = cal.getTimeInMillis();
//calculate the offset if one of the dates is in summer time and the other one in winter time
TimeZone timezone = cal.getTimeZone();
int offsetStart = timezone.getOffset(startTime);
int offsetEnd = timezone.getOffset(endTime);
int offset = offsetEnd - offsetStart;
return TimeUnit.MILLISECONDS.toDays(endTime - startTime + offset);
}

Appelez simplement getTime sur chacun d'eux, la différence, et de diviser par le nombre de millisecondes dans une journée.