Diff simple (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 puis pouvez-vous appeler:

getDateDiff(date1,date2,TimeUnit.MINUTES);

Pour obtenir le diff des 2 dates en minutes.

TimeUnit est java.util.concurrent.TimeUnit, une énumération Java standard allant de nanos à days.

Diff lisible par l'homme (sans lib)

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {
    long diffInMillies = date2.getTime() - date1.getTime();
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;
    for ( TimeUnit unit : units ) {
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;
        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.

Il vous suffit de convertir cette carte en une carte conviviale chaîne.

Avertissement

Les extraits de code ci-dessus calculent un diff simple entre 2 instants. Cela peut causer des problèmes lors d'un changement d'heure d'été, comme expliqué dans ce post. Cela signifie que si vous calculez la différence entre les dates sans heure, vous pouvez avoir un jour/heure manquant.

À mon avis, la différence de date est un peu subjective, surtout les 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 en utilisant l'heure de minuit et l'heure d'été, il pourrait être 0 jour et 23h)

• Comptez le nombre de day switches, ce qui signifie jour + 1 1pm-jour 11am = 1 jour, même si le temps écoulé n'est que de 2h (ou 1h s'il y a une heure d'été: p)

Ma réponse est valide si votre définition de date diff sur les jours correspond au 1er cas

Avec JodaTime

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

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

Mais vous pouvez également obtenir le diff pour les dates/heures locales:

// 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()

int diffInDays = (int)( (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 pour que cela fonctionne correctement avec les dates locales, il faut une approche complètement différente en raison de l'heure d'été.

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

• Cela ne prendra pas en compte les fuseaux horaires - Date est toujours en UTC
• Cela ne prendra pas en compte l'heure d'été (où il peut y avoir des jours qui ne durent que 23 heures, par exemple)
• Même dans UTC, combien de jours y a-t-il en août 16 23h au 18 août 2h? C'est seulement 27 heures, donc cela signifie-t-il un jour? Ou devrait-il être trois jours, parce qu'il couvre trois dates?

En utilisant le java.temps cadre intégré dans Java 8+:

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println("ISO-8601: " + duration);
System.out.println("Minutes: " + duration.toMinutes());

Sortie:

ISO-8601: PT24H10M

Procès-verbal: 1450

Pour plus d'informations, consultez le Oracle Tutorialet la norme ISO 8601.

Days d = Days.daysBetween(startDate, endDate);
int days = d.getDays();

Http://joda-time.sourceforge.net/faq.html#datediff

Tl; dr

Convertissez vos objets java.util.Date obsolètes en leur remplacement, java.time.Instant. Calculez ensuite le temps écoulé sous la forme d'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

La norme sensible ISO 8601 définit une représentation textuelle concise d'un laps de temps comme un nombre d'années, de mois, de jours, d'heures, etc. Les appels standard tels une durée de un durée. Le format est PnYnMnDTnHnMnS où le P signifie "Période", le T sépare la partie date de la partie temps, 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

Le java.time framework intégré dans Java 8 et versions ultérieures supplante le vieux gênant java.util.Date/java.util.Calendar cours. Les nouvelles classes sont inspirées par le très réussi Joda-Time framework, conçu comme son successeur, similaire dans le concept mais ré-architecturé. Défini par JSR 310. Le projet ThreeTen-Extra a été étendu par le projet ThreeTen-Extra . Voir le tutoriel .

Moment

Le Instant la 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 vaut éviter les classes héritées telles que Date/Calendar. Mais si vous devez inter-opérer avec l'ancien code non encore mis à jour vers java.temps , convertir d'avant en arrière. Appelez de nouvelles méthodes de conversion ajoutées aux anciennes classes. Pour passer d'une java.util.Date pour une Instant, appel Date::toInstant.

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

Durée

Le java.les classes de temps ont divisé cette idée de représenter une période de temps sous forme de nombre les années, les mois, les jours, les heures, les minutes, les secondes en deux moitiés:

• Period pendant des années, des mois, des jours
• Duration pendant des jours, heures, minutes, secondes

Voici un exemple.

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

Vidage sur console.

Les deux Period et Durationutilisent la norme ISO 8601 pour générer une représentation de chaîne de leur valeur.

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

Maintenant: 2015-11-26T00:46:48.016-05:00[Amérique/Montréal] à l'avenir: 2015-11-26T00:46:48.016-05: 00[Amérique/Montréal] = PT1H3M

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

Vous pouvez obtenir le nombre total de jours ou d'heures ou de minutes ou de secondes ou de millisecondes ou de nanosecondes sur toute la durée.

long totalHours = duration.toHours();

En Java 9 le Duration la classe obtient de nouvelles méthodes pour renvoyer 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 vous souciez que d'une granularité plus simple et plus grande du temps, telle que "nombre de jours écoulés", utilisez le 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

À propos de java.temps

Le java.time framework est intégré à Java 8 et versions ultérieures. Ces classes supplantent les anciennes héritées classes date-heure gênantes telles que java.util.Date, Calendar, & SimpleDateFormat.

Le projet Joda-Time, maintenant en mode maintenance, conseille la migration vers java.temps.

Pour en savoir plus, voir le Tutoriel Oracle. Et rechercher Stack Overflow pour de nombreux exemples et 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 l'API Java standard avec une implémentation groupée.
  • Java 9 ajoute quelques fonctionnalités et corrections mineures.
• Java SE 6 et SE 7
  • Une grande partie du java.fonction temps est de retour, porté à Java 6 et 7ThreeTen-Backport.
• Android
  • Le Troisabp le projet s'adapte ThreeTen-Backport (mentionné ci-dessus) pour Android spécifiquement.
  • Voir Comment utiliser....

Le projetThreeTen-Extra étend java.temps avec des cours supplémentaires. Ce projet est un terrain d'essai pour d'éventuels ajouts futurs à java.temps. Vous pouvez trouver quelques classes utiles ici comme Interval, YearWeek, YearQuarter, et plus.

Joda-Temps

MISE À JOUR: Le projetJoda-Time est maintenant en modemaintenance , l'équipe conseillant la migration vers le java.temps classes. Je laisse cette section intacte pour l'histoire.

La bibliothèque Joda-Time utilise ISO 8601 pour ses valeurs par défaut. Sa classe Period analyse et génère ces chaînes PnYnMnDTnHnMnS.

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

Une alternative légèrement plus simple:

System.currentTimeMillis() - oldDate.getTime()

Quant à "nicer": eh bien, de quoi avez-vous besoin exactement? Le problème avec la représentation des durées de temps en nombre d'heures et de jours, etc. est - ce que cela peut conduire à des inexactitudes et des attentes erronées en raison de la complexité des dates (par exemple, les jours peuvent avoir 23 ou 25 heures en raison de l'heure d'été).

L'utilisation d'une approche en milliseconde peut causer des problèmes dans certains paramètres régionaux.

Prenons, par exemple, la différence entre les deux dates 03/24/2007 et 03/25/2007 devrait être de 1 jour;

Cependant, en utilisant la route milliseconde, vous obtiendrez 0 jours, si vous exécutez cela au Royaume-Uni!

/** Manual Method - YIELDS INCORRECT RESULTS - DO NOT USE**/  
/* This method is used to find the no of days between the given dates */  
public long calculateDays(Date dateEarly, Date dateLater) {  
   return (dateLater.getTime() - dateEarly.getTime()) / (24 * 60 * 60 * 1000);  
} 

La meilleure façon de l'implémenter est d'utiliser java.util.Calendrier

/** Using Calendar - THE CORRECT WAY**/  
public static long daysBetween(Calendar startDate, Calendar endDate) {  
  Calendar date = (Calendar) startDate.clone();  
  long daysBetween = 0;  
  while (date.before(endDate)) {  
    date.add(Calendar.DAY_OF_MONTH, 1);  
    daysBetween++;  
  }  
  return daysBetween;  
}  

Il existe de nombreuses façons de trouver la différence entre les dates et les heures. L'un des moyens 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 n'est qu'un exemple - vous pouvez la formater comme vous le souhaitez.

Puisque toutes les réponses ici sont correctes mais utilisent java hérité ou des bibliothèques tierces comme joda ou similaire, je vais simplement laisser tomber une autre façon en utilisant new java.time classes dans Java 8 et versions ultérieures. VoirTutoriel Oracle .

Utiliser LocalDate et ChronoUnit:

LocalDate d1 = LocalDate.of(2017, 5, 1);
LocalDate d2 = LocalDate.of(2017, 5, 18);

long days = ChronoUnit.DAYS.between(d1, d2);
System.out.println( days );

Soustraire les dates en millisecondes fonctionne (comme décrit dans un autre article), mais vous avez pour utiliser HOUR_OF_DAY et non HOUR lors de l'effacement des parties temporelles 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
}

Jetez un oeil àJoda Time , qui est une API Date/Heure améliorée pour Java et devrait fonctionner correctement avec Scala.

Si vous ne voulez pas utiliser JodaTime ou similaire, la meilleure solution est probablement la suivante:

final static long MILLIS_PER_DAY = 24 * 3600 * 1000;
long msDiff= date1.getTime() - date2.getTime();
long daysDiff = Math.round(msDiff / ((double)MILLIS_PER_DAY));

Le nombre de ms par jour n'est pas toujours le même (à cause de l'heure d'été et des secondes intercalaires), mais il est très proche, et au moins les écarts dus à l'heure d'été s'annulent sur de plus longues périodes. Par conséquent, diviser puis arrondir donnera un résultat correct (au moins tant que le calendrier local utilisé ne contient pas de sauts de temps étranges autres que DST et leap deuxième).

Notez que cela suppose que date1 et date2 sont réglés à la même heure de la journée. Pour différents moments de la journée, vous devez d'abord définir ce que signifie "différence de date", comme l'a souligné Jon Skeet.

Permettez-moi de montrer la différence entre l'intervalle Joda et les jours:

DateTime start = new DateTime(2012, 2, 6, 10, 44, 51, 0);
DateTime end = new DateTime(2012, 2, 6, 11, 39, 47, 1);
Interval interval = new Interval(start, end);
Period period = interval.toPeriod();
System.out.println(period.getYears() + " years, " + period.getMonths() + " months, " + period.getWeeks() + " weeks, " + period.getDays() + " days");
System.out.println(period.getHours() + " hours, " + period.getMinutes() + " minutes, " + period.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *1 weeks, 1 days*
//0 hours, 54 minutes, 56 seconds 

//Period can set PeriodType,such as PeriodType.yearMonthDay(),PeriodType.yearDayTime()...
Period p = new Period(start, end, PeriodType.yearMonthDayTime());
System.out.println(p.getYears() + " years, " + p.getMonths() + " months, " + p.getWeeks() + " weeks, " + p.getDays() + "days");
System.out.println(p.getHours() + " hours, " + p.getMinutes() + " minutes, " + p.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *0 weeks, 8 days*
//0 hours, 54 minutes, 56 seconds 

Si vous avez besoin d'une chaîne de retour formatée 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;
}

Vérifiez l'exemple ici http://www.roseindia.net/java/beginners/DateDifferent.shtml Cet exemple vous donne la différence en jours, heures, minutes, secondes et milli sec :).

import java.util.Calendar;
import java.util.Date;

public class DateDifferent {
    public static void main(String[] args) {
        Date date1 = new Date(2009, 01, 10);
        Date date2 = new Date(2009, 07, 01);
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        calendar1.setTime(date1);
        calendar2.setTime(date2);
        long milliseconds1 = calendar1.getTimeInMillis();
        long milliseconds2 = calendar2.getTimeInMillis();
        long diff = milliseconds2 - milliseconds1;
        long diffSeconds = diff / 1000;
        long diffMinutes = diff / (60 * 1000);
        long diffHours = diff / (60 * 60 * 1000);
        long diffDays = diff / (24 * 60 * 60 * 1000);
        System.out.println("\nThe Date Different Example");
        System.out.println("Time in milliseconds: " + diff + " milliseconds.");
        System.out.println("Time in seconds: " + diffSeconds + " seconds.");
        System.out.println("Time in minutes: " + diffMinutes + " minutes.");
        System.out.println("Time in hours: " + diffHours + " hours.");
        System.out.println("Time in days: " + diffDays + " days.");
    }
}

Utilisez le fuseau horaire GMT pour obtenir une instance du calendrier, définissez l'heure à l'aide de la méthode set de la classe Calendar. Le fuseau horaire GMT a un décalage de 0 (pas vraiment important) et un indicateur d'heure d'été défini sur 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));

Le code suivant peut vous donner la sortie souhaitée:

String startDate = "Jan 01 2015";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMM dd yyyy");
LocalDate date = LocalDate.parse(startDate, formatter);

String currentDate = "Feb 11 2015";
LocalDate date1 = LocalDate.parse(currentDate, formatter);

System.out.println(date1.toEpochDay() - date.toEpochDay());

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

int daysDiff = (date1.getTime() - date2.getTime()) / MILLIS_PER_DAY;

La meilleure chose à faire est

(Date1-Date2)/86 400 000 

Ce nombre est le nombre de millisecondes par jour.

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

Collectez la réponse dans une variable double .

C'est probablement la façon la plus simple de le faire - peut-être parce que je code en Java (avec ses bibliothèques de date et d'heure certes maladroites) depuis un certain temps maintenant, mais ce code me semble "simple et agréable"!

Êtes-vous satisfait du résultat renvoyé en millisecondes, ou fait-il partie de votre question que vous préféreriez le renvoyer dans un autre format?

Ne pas utiliser l'API standard, non. Vous pouvez rouler votre propre faire quelque chose comme ceci:

class Duration {
    private final TimeUnit unit;
    private final long length;
    // ...
}

Ou vous pouvez utiliser Joda:

DateTime a = ..., b = ...;
Duration d = new Duration(a, b);

Remarque: startDate et endDates sont -> java.util.Date

import org.joda.time.Duration;
import org.joda.time.Interval;
Interval interval = new Interval(startDate.getTime(), endDate.getTime);
Duration period = interval.toDuration();
period.getStandardDays() //gives the number of days elapsed between start and end date

Semblable à jours, vous pouvez également obtenir des heures, des minutes et des secondes

period.getStandardHours();
period.getStandardMinutes();
period.getStandardSeconds();

Juste pour répondre à la question initiale:

Mettez le code suivant dans une fonction comme Long 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 nombres longs lors de la multiplication et de la division. Et bien sûr, le décalage que Java applique dans son calcul des Dates.

:)

Puisque la question est étiquetée avec Scala,

import scala.concurrent.duration._
val diff = (System.currentTimeMillis() - oldDate.getTime).milliseconds
val diffSeconds = diff.toSeconds
val diffMinutes = diff.toMinutes
val diffHours = diff.toHours
val diffDays = diff.toDays

Voici une solution Java 7 correcte dans O(1) sans aucune dépendance.

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 param des méthodes parse ().

Puisque vous utilisez Scala, il existe une très bonne bibliothèque Scala Lamma . Avec Lamma, vous pouvez réduire la date directement avec - operator

scala> Date(2015, 5, 5) - 2     // minus days by int
res1: io.lamma.Date = Date(2015,5,3)

scala> Date(2015, 5, 15) - Date(2015, 5, 8)   // minus two days => difference between two days
res2: Int = 7