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

getDateDiff(date1,date2,TimeUnit.MINUTES);

pour obtenir la différence des 2 dates en minutes unité.

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

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.

vous avez juste à convertir cette carte en une chaîne facile à utiliser.

Avertissement

les extraits de code ci-dessus calculent une différence simple entre 2 instants. Il peut causer des problèmes lors d'un changement de jour, 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 temps écoulé: jour+1-jour = 1 jour = 24h

• compter le nombre de temps écoulé, en tenant compte de l'heure avancée: jour+1-jour = 1 = 24h (mais en utilisant l'Heure de minuit et l'heure avancée il pourrait être 0 jour et 23h)

• compter le nombre de day switches , ce qui signifie Jour+1 1pm-jour 11am = 1 jour, même si le temps écoulé est juste 2h (ou 1h s'il ya un changement de jour :p)

ma réponse est valide si votre définition de différence de date sur les jours correspondent au 1er cas

With JodaTime

si vous utilisez JodaTime vous pouvez obtenir la diff pour 2 instants (millies backed ReadableInstant) dates avec:

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

mais vous pouvez également obtenir la 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 qu'il 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 pourrait juste prendre le nombre de millisecondes entre les deux Date objets et diviser par le nombre de millisecondes en 24 heures, par exemple... mais:

• cela ne tiendra pas compte des fuseaux horaires - Date est toujours en TUC
• cela ne tiendra pas compte de l'heure d'été (où il peut y avoir des jours qui ne sont que de 23 heures long, par exemple)
• même en UTC, combien de jours y a-t-il entre le 16 août 23h et le 18 Août 2h? C'est seulement 27 heures, donc ça veut dire un jour? Ou ça devrait être trois jours parce que ça couvre trois rendez-vous?

utilisant le java.time framework 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

Minutes: 1450

pour plus d'informations, voir le Oracle Tutorial et la ISO 8601 standard.

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

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

tl; dr

Convertir vos obsolète java.util.Date les objets à leur remplacement, java.time.Instant . Calculer ensuite 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 la norme ISO 8601 définit une représentation textuelle concise d'un intervalle de temps comme un nombre d'années, de mois, de jours, d'heures, etc. La norme appelle une telle portée un durée . Le format est PnYnMnDTnHnMnS où P signifie" période", le T sépare la partie date de la partie heure, et entre les deux sont des nombres suivis d'une lettre.

exemples:

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

de java.time

Le de java.time framework intégré dans Java 8 et supplante plus tard les anciennes classes java.util.Date / java.util.Calendar . Les nouvelles classes sont inspirées par les succès Joda-Time cadre, destiné à son successeur, similaire dans le concept, mais ré-architecture. Défini par JSR 310 . Prolongé par le projet ThreeTen-Extra . Voir le Tutorial .

Moment

la classe Instant représente un moment sur la ligne de temps 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.

mieux vaut éviter les classes héritées telles que Date / Calendar . Mais si vous devez interférer avec l'ancien code pas encore mis à jour en java.temps , convertissez-vous. Appelez les 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.

durée

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

• Period pour années, mois ,jours
• Duration pendant des jours, des heures, des 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 à console.

les deux Period et Duration utilisent 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 millisecondes ou nanosecondes dans toute la durée.

long totalHours = duration.toHours();

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

ChronoUnit

si vous vous souciez seulement d'une granularité plus grande du temps plus simple, comme" nombre de jours écoulés", utilisez le ChronoUnit enum.

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

autre exemple.

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

120

à Propos de java.time

Le de java.time framework est construit dans Java 8 et plus tard. Ces classes remplacent les anciennes classes de date legacy telles que java.util.Date , Calendar , & SimpleDateFormat .

Le Joda-Time , qui est maintenant dans mode maintenance , avis de migration vers java.temps.

pour en savoir plus, voir le Oracle Tutorial . Et rechercher le débordement de la pile 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 suiv.
  • Built-in.
  • fait partie de L'API Java standard avec une implémentation groupée.
  • Java 9 ajoute des fonctionnalités mineures et des corrections.
• Java SE 6 et SE 7
  • la plupart des Java.la fonctionnalité time est rétroportée à Java 6 & 7 dans ThreeTen-Backport .
• Android
  • Le ThreeTenABP "1519610920 projet" s'adapte ThreeTen-Backport (mentionné ci-dessus) pour Android spécifiquement.
  • voir comment utiliser... .

le projet ThreeTen-Extra étend java.temps avec des cours supplémentaires. Ce projet est un terrain d'expérimentation pour d'éventuelles futures additions à java.temps. Vous pouvez trouver ici quelques cours utiles tels que: Interval , YearWeek , YearQuarter , et plus .

Joda-Time

mise à jour: le projet Joda-Time est maintenant en mode maintenance , avec l'équipe conseillant la migration vers le java.temps classes. Je laisse cette section intacte pour l'histoire.

The Joda-Time la bibliothèque utilise ISO 8601 par défaut. Sa classe Period Parse 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()

comme pour "nicer": Eh bien, de quoi avez-vous besoin exactement? Le problème de la représentation des durées en nombre d'heures, de jours, etc. est 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 de milliseconde peut causer des problèmes dans certains endroits.

prenons, par exemple, la différence entre les deux dates 03/24/2007 et 03/25/2007 devrait être d'un jour;

Cependant, en utilisant la milliseconde route, vous aurez 0 jours, si vous exécutez ceci 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 d'implémenter ceci 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 y a plusieurs façons de trouver la différence entre les dates et les heures. 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);

la déclaration imprimée n'est qu'un exemple - vous pouvez la formater comme vous voulez.

puisque toutes les réponses ici sont correctes, mais utilisez Java legacy ou des libs tiers comme joda ou similaire, je vais juste laisser tomber une autre façon en utilisant le nouveau java.classes de temps en Java 8 et plus tard. Voir Oracle Tutoriel .

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

soustrayant les dates en millisecondes fonctionne( comme décrit dans un autre post), mais vous ont pour utiliser HOUR_OF_DAY et non HOUR lors du nettoyage des 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
}

regardez 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 celle-ci:

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 bissextiles), mais il est très proche, et au moins les déviations dues à l'heure d'hiver s'annulent sur de plus longues périodes. Par conséquent, diviser puis arrondir donnera un résultat correct (au moins aussi longtemps que le calendrier local utilisé ne contient pas sauts de temps bizarres autre que L'heure d'été et les secondes intercalaires).

notez que cela suppose toujours que date1 et date2 sont placé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.

laissez-moi faire 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;
}

cocher 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 :).

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 en utilisant la méthode set de la classe calendrier. Le fuseau horaire GMT a 0 décalage (pas vraiment important) et le drapeau d'heure d'été mis à 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 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";
    }
}   

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.

collecter la réponse dans un double variable.

C'est probablement la façon la plus simple de le faire - peut-être parce que je codais en Java (avec ses bibliothèques date et time) depuis un certain temps maintenant, mais ce code semble" simple et agréable " pour 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?

ne Pas utiliser l'API standard, pas de. 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);

Note: 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

similaire aux 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 marqué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 correcte de Java 7 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 éditer la chaîne dans la méthode parse() param.

puisque vous utilisez Scala, il y a une très bonne bibliothèque Scala Lamma . Avec Lamma vous pouvez Moins date directement avec - opérateur

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