Le calcul de la différence entre les deux instances de date Java

StackOverflow https://stackoverflow.com/questions/1555262

Question

J'utilise la classe java.util.Date de Java Scala et que vous voulez comparer un objet Date et l'heure actuelle. Je sais que je peux calculer le delta en utilisant getTime (): 

(new java.util.Date()).getTime() - oldDate.getTime()

Cependant, cela me laisse juste avec un représentant long millisecondes. Y at-il plus simple, plus agréable d'obtenir un delta de temps?

Était-ce utile?

La solution

L'API est horriblement Date cassé JDK malheureusement. Je recommande d'utiliser Joda Time Library .

Joda Time a un concept de temps Intervalle : 

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

EDIT: Par ailleurs, Joda a deux concepts: Interval pour représenter un intervalle de temps entre deux instants (représentant le temps huit heures-10 heures), et un Duration qui représente une longueur de temps sans limites de temps réel (par exemple, représentent deux heures!)

Si vous ne vous préoccupez comparisions temps, la plupart des implémentations de Date (y compris l'un JDK) implémente l'interface Comparable qui vous permet d'utiliser le Comparable.compareTo()

Autres conseils

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 pouvez-vous appeler: 

getDateDiff(date1,date2,TimeUnit.MINUTES);

pour obtenir le diff des 2 dates dans l'unité minutes.

TimeUnit est java.util.concurrent.TimeUnit, un enum Java standard allant de nanos à jour.

diff lisible humain (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.

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

Avertissement

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

A mon avis la date diff est un peu subjectif, surtout les jours. Vous pouvez:

  • compter le nombre de temps écoulé 24h: 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 le temps de minuit et l'heure d'été, il pourrait être de 0 jour et 23 h)

  • compter le nombre de day switches, ce qui signifie jour + 1 13 heures - jour 11 heures = 1 jour, même si le temps écoulé est juste 2h (enregistrement ou 1h s'il y a un jour: p)

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

Avec JodaTime

Si vous utilisez JodaTime vous pouvez obtenir la diff 2 (instants Millies soutenu ReadableInstant) avec dates: 

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

Mais vous pouvez également obtenir la diff pour connaître 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 des dates UTC, la différence peut être un jour de congé si vous regardez les dates locales. Et l'obtenir pour fonctionner correctement avec des dates locales nécessite une approche complètement différente en raison de l'heure d'été.

Vous devez définir votre problème plus clairement. Vous pourrait ne prendre que 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 les fuseaux horaires en considération - Date est toujours en UTC
  • Cela ne prendra pas l'heure d'été en considération (où il peut y avoir des jours qui sont seulement 23 heures, par exemple)
  • Même dans UTC, combien de jours sont là au 16e Août au 18 Août 23:00 2 heures? Il est seulement 27 heures, alors que cela signifie un seul jour? Ou devrait-il être trois jours car il couvre trois dates?

En utilisant le cadre java.time construit en 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 Tutorial et ISO 8601 standard .

tl; dr

Convertir vos objets obsolètes java.util.Date à leur remplacement, java.time.Instant. Calculez ensuite le temps écoulé comme 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

ISO 8601 Format: PnYnMnDTnHnMnS

norme ISO 8601 href="https://en.wikipedia.org/wiki/ISO_8601" raisonnable définit une représentation textuelle concise d'un laps de temps en tant que nombre des années, mois, jours, heures, etc. Les appels standard comme un span durée . Le format est PnYnMnDTnHnMnS où le P signifie « période », la T sépare la partie date de la partie de temps, et entre 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.time

Le java.time cadre construit en Java 8 et supplante plus tard, les anciennes classes java.util.Date / de java.util.Calendar gênants. Les nouvelles classes sont inspirés par le Joda-Time cadre, conçu comme son successeur, similaire dans le concept, mais re-architecturé. Défini par JSR 310 . Prolongée par le ThreeTen-Extra projet . Voir la Tutoriel.

Moment

La classe Instant représente un moment sur la timeline dans 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.

Best pour éviter les classes existantes telles que Date / Calendar. Mais si vous devez interopérer avec l'ancien code pas encore mis à jour java.time , reconvertir en arrière. Appel de nouvelles méthodes de conversion ajoutées aux anciennes classes. Pour passer d'un java.util.Date un Instant , appel Date::toInstant . 

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

laps de temps

Les classes java.time ont divisé cette idée de représenter une période de temps un certain nombre d'années, mois, jours, heures, minutes, secondes en deux moitiés:

  • Period depuis des années, mois, 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 );

Dump à la console.

Les deux Period et Duration utilisent ISO 8601 standard pour générer une représentation de chaîne de leur valeur. 

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

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

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

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

long totalHours = duration.toHours();

En Java 9 la classe de Duration obtient de nouvelles méthodes pour retourner les différentes parties de jours, heures, minutes, secondes, millisecondes / nanosecondes. Appelez les méthodes de to…Part. toDaysPart(), toHoursPart(), etc.

ChronoUnit

Si vous ne vous préoccupez une granularité plus simple plus de temps, comme « nombre de jours écoulés », utilisez la balise 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

A propos de java.time

Le java.time cadre est construit en Java 8 et versions ultérieures. Ces classes supplantent les classes date temps héritage gênant vieux href="https://en.wikipedia.org/wiki/Legacy_system" tels que java.util.Date , Calendar , et SimpleDateFormat .

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

Pour en savoir plus, consultez le Oracle Tutoriel . Et la recherche Stack Overflow pour de nombreux exemples et explications. Spécification est JSR 310 .

Où obtenir les classes java.time?

Le projet ThreeTen-Extra java.time étend avec des classes supplémentaires. Ce projet est un terrain d'essai pour les futurs ajouts possibles à java.time. Vous trouverez peut-être des classes utiles ici comme Interval , YearWeek , YearQuarter et plus .

Joda-Time

MISE À JOUR: Le projet Joda-Time est maintenant mode maintenance , avec l'équipe de conseiller la migration vers la page les cours de java.time. Je laisse cette partie intacte pour l'histoire.

La bibliothèque Joda-Time utilise ISO 8601 pour ses valeurs par défaut. Sa classe et génère Period parse ces chaînes de 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 );

Renders: 

period: PT4H30M

Une alternative un peu plus simple: 

System.currentTimeMillis() - oldDate.getTime()

Pour ce qui est « plus agréable »: bien, qu'est-ce exactement que vous avez besoin? Le problème avec représentant des durées de temps en nombre d'heures et de jours, etc. est qu'il peut conduire à des inexactitudes et de fausses attentes en raison de la complexité des dates (par exemple jours peuvent avoir 23 ou 25 heures en raison de l'heure d'été).

En utilisant l'approche de milliseconde peut causer des problèmes dans certains endroits.

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

Cependant, en utilisant la route milliseconde, vous aurez 0 jours, si vous exécutez ce 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);  
}

Une meilleure façon de mettre en œuvre est d'utiliser java.util.Calendar 

/** 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 y a plusieurs façons que vous pouvez trouver la différence entre les dates et heures. L'une des façons les plus simples que je connais 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);

La déclaration d'impression est juste un exemple - vous pouvez formater, la façon dont vous aimez

.

Étant donné que toutes les réponses ici sont correctes, mais utilisent libs java legs ou 3ème partie comme Joda ou similaire, je vais simplement laisser tomber une autre façon nouvelle en utilisant java.time des classes en Java 8 et versions ultérieures. Voir Oracle Tutoriel .

Utilisez 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 post), mais vous Vous à utiliser HOUR_OF_DAY et non HOUR pour dégager les parties de temps 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
}

Si vous ne souhaitez pas utiliser JodaTime ou similaire, la solution est probablement la mieux adaptée à ceci: 

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 ne sont pas toujours les mêmes (à cause de l'heure d'été et sauter secondes), mais il est très proche, et au moins les écarts dus à l'heure d'été annulent sur des périodes plus longues. Par conséquent, la division et l'arrondi donnera un résultat correct (au moins aussi longtemps que le calendrier local utilisé ne contient pas le temps bizarre saute autre que l'heure d'été et sauter secondes).

Notez que cela suppose encore que date1 et date2 sont fixés au même moment de la journée. Pour différents moments de la journée, vous auriez d'abord définir ce que la « différence de date » signifie, comme l'a souligné Jon Skeet.

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

Permettez-moi de montrer la différence entre Joda Intervalle et 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 en forme 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érifier 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 de:.) 

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

Utiliser le fuseau horaire GMT pour obtenir une instance du calendrier, définissez l'heure à l'aide de la méthode de jeu de classe Calendrier. Le fuseau horaire GMT a 0 décalage (pas vraiment important) et le drapeau de l'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));

code suivant peut vous donner la sortie désiré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";
    }
}

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

import org.joda.time.Duration;
import org.joda.time.Interval;
// Use .getTime() unless it is a joda DateTime object
Interval interval = new Interval(startDate.getTime(), endDate.getTime());
Duration period = interval.toDuration();
//gives the number of days elapsed between start 
period.getStandardDays();

et la date de fin

Similaire à jour, vous pouvez également obtenir des heures, minutes et secondes 

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

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 dans une journée.

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

Récupérer la réponse dans un deux variable.

C'est probablement la façon la plus simple de le faire - peut-être est parce que je l'ai été le codage en Java (avec ses certes la date maladroites et bibliothèques temps) pendant un certain temps maintenant, mais ce code semble « simple et agréable » pour moi!

Êtes-vous satisfait du résultat étant retourné en millisecondes, ou fait partie de votre question que vous préférez avoir retourné dans un format alternatif?

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

Vous pouvez aussi utiliser Joda : 

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

Juste pour répondre à la question initiale:

Placez 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 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 en O (1) correct Java 7 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;
}

Après avoir pataugé dans toutes les autres réponses, de garder Java 7 type de date, mais être plus précis / standard avec l'approche diff Java 8, 

public static long daysBetweenDates(Date d1, Date d2) {
    Instant instant1 = d1.toInstant();
    Instant instant2 = d2.toInstant();
    long diff = ChronoUnit.DAYS.between(instant1, instant2);
    return diff;
}

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

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top