Calcolo della differenza tra due istanze di data Java

Sto usando la class java.util.Date di Java in Scala e voglio confrontare un object Date e l’ora corrente. So che posso calcolare il delta usando getTime ():

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

Tuttavia, questo mi lascia solo con long millisecondi. C’è un modo più semplice e più carino per ottenere un delta temporale?

L’API della Date JDK è orribilmente rotta purtroppo. Raccomando di usare la libreria Joda Time .

Joda Time ha un concetto di intervallo di tempo:

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

EDIT: A proposito, Joda ha due concetti: Interval per rappresentare un intervallo di tempo tra due istanti di tempo (rappresentano il tempo tra 8am e 10am), e una Duration che rappresenta un lasso di tempo senza i limiti di tempo effettivi (ad esempio rappresentano due ore !)

Se ti interessano solo le comparazioni temporali, la maggior parte delle implementazioni di Date (incluso quella di JDK) implementa un’interfaccia Comparable che ti consente di utilizzare Comparable.compareTo()

Differenza semplice (senza 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); } 

E poi puoi chiamare:

 getDateDiff(date1,date2,TimeUnit.MINUTES); 

per ottenere il diff delle 2 date in minuti unità.

TimeUnit è java.util.concurrent.TimeUnit , un enum standard Java che va da nanos a giorni.


Diff umano leggibile (senza lib)

 public static Map computeDiff(Date date1, Date date2) { long diffInMillies = date2.getTime() - date1.getTime(); List units = new ArrayList(EnumSet.allOf(TimeUnit.class)); Collections.reverse(units); Map result = new LinkedHashMap(); 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

L’output è simile a Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0} , con le unità ordinate.

Devi solo convertire quella mappa in una stringa user-friendly.


avvertimento

I frammenti di codice di cui sopra computano un semplice diff tra 2 istanti. Può causare problemi durante l’interruttore dell’ora legale, come spiegato in questo post . Ciò significa che se calcoli la differenza tra le date senza tempo potresti avere un giorno / ora mancante.

A mio avviso, la data di diff è soggettiva, specialmente nei giorni. Potresti:

  • conta il numero del tempo trascorso 24 ore: giorno + 1 giorno = 1 giorno = 24 ore

  • conta il numero del tempo trascorso, avendo cura dell’ora legale: giorno + 1 giorno = 1 = 24 ore (ma usando la mezzanotte e l’ora legale potrebbe essere 0 giorni e 23 ore)

  • conta il numero di day switches , ovvero giorno + 1 13:00 – giorno 11:00 = 1 giorno, anche se il tempo trascorso è solo 2 ore (o 1 ora se è presente l’ora legale: p)

La mia risposta è valida se la tua definizione di data differ su giorni corrisponde al 1 ° caso

Con JodaTime

Se utilizzi JodaTime puoi ottenere la differenza per 2 istanti (millies backed ReadableInstant) con:

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

Ma puoi anche ottenere il diff per le date / orari locali:

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

Si noti che questo funziona con le date UTC, quindi la differenza potrebbe essere un giorno di rest se si guardano le date locali. E far sì che funzioni correttamente con le date locali richiede un approccio completamente diverso a causa dell’ora legale.

Devi definire il tuo problema più chiaramente. Puoi semplicemente prendere il numero di millisecondi tra i due oggetti Date e dividerlo per il numero di millisecondi in 24 ore, ad esempio … ma:

  • Questo non prenderà in considerazione i fusi orari: la Date è sempre in UTC
  • Questo non prenderà in considerazione l’ora legale (dove possono esserci giorni che sono lunghi solo 23 ore, per esempio)
  • Anche in UTC, quanti giorni ci sono tra il 16 agosto e il 23 agosto fino al 18 agosto? Sono solo 27 ore, quindi significa un giorno? O dovrebbe essere di tre giorni perché copre tre date?

Utilizzando il framework java.time integrato in 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()); 

Produzione:

ISO-8601: PT24H10M

Minuti: 1450

Per maggiori informazioni, consultare l’ esercitazione Oracle e lo standard ISO 8601 .

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

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

tl; dr

Converti gli oggetti obsoleti java.util.Date nella loro sostituzione, java.time.Instant . Quindi calcola il tempo trascorso come 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

Formato ISO 8601: PnYnMnDTnHnMnS

Lo standard ragionevole ISO 8601 definisce una concisa rappresentazione testuale di un intervallo di tempo come un numero di anni, mesi, giorni, ore, ecc. Lo standard definisce una durata di questo tipo . Il formato è PnYnMnDTnHnMnS dove P indica “Periodo”, T separa la parte di data dalla porzione di tempo e in mezzo i numeri seguiti da una lettera.

Esempi:

  • P3Y6M4DT12H30M5S
    tre anni, sei mesi, quattro giorni, dodici ore, trenta minuti e cinque secondi
  • PT4H30M
    Quattro ore e mezza

java.time

Il framework java.time incorporato in Java 8 e successivo sostituisce le fastidiose classi java.util.Date / java.util.Calendar . Le nuove classi sono ispirate alla struttura di successo Joda-Time , intesa come suo successore, simile nel concetto ma ri-architettata. Definito da JSR 310 . Ampliato dal progetto ThreeTen-Extra . Vedi il tutorial .

Momento

La class Instant rappresenta un momento sulla timeline in UTC con una risoluzione di nanosecondi (fino a nove (9) cifre di una frazione decimale).

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

Meglio evitare le classi precedenti come Date / Calendar . Ma se è necessario interagire con il vecchio codice non ancora aggiornato a java.time , convertire avanti e indietro. Chiama i nuovi metodi di conversione aggiunti alle vecchie classi. Per passare da un java.util.Date a un Instant , chiama Date::toInstant .

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

Lasso di tempo

Le classi java.time hanno diviso questa idea di rappresentare un intervallo di tempo in un numero di anni, mesi, giorni, ore, minuti, secondi in due metà:

  • Period per anni, mesi, giorni
  • Duration per giorni, ore, minuti, secondi

Ecco un esempio.

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

Scarica alla console.

Sia il Period che la Duration utilizzano lo standard ISO 8601 per generare una rappresentazione String del loro valore.

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

ora: 2015-11-26T00: 46: 48.016-05: 00 [America / Montreal] per il futuro: 2015-11-26T00: 46: 48.016-05: 00 [America / Montreal] = PT1H3M

Java 9 aggiunge metodi alla Duration per ottenere la parte di giorni, ore, minuti, parti e secondi.

È ansible ottenere il numero totale di giorni o ore o minuti o secondi o millisecondi o nanosecondi nell’intera durata.

 long totalHours = duration.toHours(); 

In Java 9 la class Duration ottiene nuovi metodi per restituire le varie parti di giorni, ore, minuti, secondi, millisecondi / nanosecondi. Chiama il to…Part metodi to…Part : toDaysPart() , toHoursPart() e così via.

ChronoUnit

Se ti interessa solo una più semplice granularità del tempo, come “numero di giorni trascorsi”, usa l’ ChronoUnit .

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

Un altro esempio.

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

120


A proposito di java.time

Il framework java.time è integrato in Java 8 e versioni successive. Queste classi soppiantano le fastidiose vecchie lezioni di data e ora come java.util.Date , Calendar e SimpleDateFormat .

Il progetto Joda-Time , ora in modalità di manutenzione , consiglia la migrazione a java.time.

Per saperne di più, consultare l’ esercitazione Oracle . E cerca Stack Overflow per molti esempi e spiegazioni. La specifica è JSR 310 .

Dove ottenere le classi java.time?

  • Java SE 8 e SE 9 e versioni successive
    • Built-in.
    • Parte dell’API Java standard con un’implementazione in bundle.
    • Java 9 aggiunge alcune funzionalità e correzioni minori.
  • Java SE 6 e SE 7
    • Gran parte della funzionalità java.time è back-porting su Java 6 e 7 in ThreeTen-Backport .
  • android
    • Il progetto ThreeTenABP adatta ThreeTen-Backport (menzionato sopra) per Android in particolare.
    • Vedi Come usare ….

Il progetto ThreeTen-Extra estende java.time con classi aggiuntive. Questo progetto è un terreno di prova per possibili aggiunte future a java.time. Puoi trovare alcune classi utili come Interval , YearWeek , YearQuarter e altro .


Joda-Time

AGGIORNAMENTO: il progetto Joda-Time è ora in modalità di manutenzione , con il team che consiglia la migrazione alle classi java.time . Lascio questa sezione intatta per la cronologia.

La libreria Joda-Time utilizza ISO 8601 per i suoi valori predefiniti. La sua class Period analizza e genera queste stringhe 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 

Un’alternativa leggermente più semplice:

 System.currentTimeMillis() - oldDate.getTime() 

Per quanto riguarda “più bello”: beh, di cosa hai bisogno esattamente? Il problema con la rappresentazione delle durate di tempo come numero di ore e giorni ecc. È che può portare a inesattezze e aspettative sbagliate a causa della complessità delle date (ad esempio, i giorni possono avere 23 o 25 ore a causa dell’ora legale).

L’utilizzo dell’approccio al millisecondo può causare problemi in alcuni ambienti.

Prendiamo, ad esempio, la differenza tra le due date il 24/03/2007 e il 25/03/2007 dovrebbe essere di 1 giorno;

Tuttavia, utilizzando il percorso del millisecondo, riceverai 0 giorni, se lo esegui nel Regno Unito!

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

Il modo migliore per implementare questo è usare 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; } 

Ci sono molti modi in cui puoi trovare la differenza tra le date e le ore. Uno dei modi più semplici che io conosca sarebbe:

  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 dichiarazione di stampa è solo un esempio: puoi formattarla nel modo che preferisci.

Dal momento che tutte le risposte qui sono corrette ma usano librerie java o di terze parti legacy come joda o simili, farò semplicemente un altro modo usando le nuove classi java.time in Java 8 e successive. Vedi Oracle Tutorial .

Usa LocalDate e 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 ); 

Sottraendo le date in millisecondi funziona (come descritto in un altro post), ma devi utilizzare HOUR_OF_DAY e non HOUR quando svuota le parti di tempo delle tue date:

 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 } 

Dai un’occhiata a Joda Time , che è un’API Date / Time migliorata per Java e dovrebbe funzionare bene con Scala.

Se non vuoi usare JodaTime o simili, la soluzione migliore è probabilmente questa:

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

Il numero di ms al giorno non è sempre lo stesso (a causa dell’ora legale e dei secondi bisestili), ma è molto vicino e almeno gli scostamenti dovuti all’ora legale si annullano per periodi più lunghi. Pertanto la divisione e quindi l’arrotondamento danno un risultato corretto (almeno finché il calendario locale utilizzato non contiene salti temporali diversi da DST e secondi bisestili).

Si noti che ciò presuppone ancora che date1 e date2 siano impostati alla stessa ora del giorno. Per diverse ore del giorno, dovresti prima definire cosa significa “differenza di data”, come sottolineato da Jon Skeet.

Lasciami mostrare la differenza tra Joda Interval e Days:

 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 

Se hai bisogno di una stringa di reso formattata come “2 giorni 03h 42m 07s”, prova questo:

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

Controlla l’esempio qui http://www.roseindia.net/java/beginners/DateDifferent.shtml Questo esempio ti dà la differenza in giorni, ore, minuti, secondi e 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."); } } 

Utilizza il fuso orario GMT per ottenere un’istanza del calendario, imposta l’ora utilizzando il metodo set della class Calendar. Il fuso orario GMT ha 0 offset (non molto importante) e l’indicatore dell’ora legale è impostato su 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)); 

Il seguente codice può darti l’output desiderato:

 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; 

Best thing to do is

 (Date1-Date2)/86 400 000 

That number is the number of milliseconds in a day.

One date-other date gives you difference in milliseconds.

Collect the answer in a double variable.

That’s probably the most straightforward way to do it – perhaps it’s because I’ve been coding in Java (with its admittedly clunky date and time libraries) for a while now, but that code looks “simple and nice” to me!

Are you happy with the result being returned in milliseconds, or is part of your question that you would prefer to have it returned in some alternative format?

Not using the standard API, no. You can roll your own doing something like this:

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

Or you can use Joda :

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

Note: startDate and endDates are -> 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 

Similar to days, you can also get hours, minutes and seconds

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

Just to answer the initial question:

Put the following code in a Function like 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; 

The most important here is to work with long numbers when multiplying and dividing. And of course, the offset that Java applies in its calculus of Dates.

🙂

Here’s a correct Java 7 solution in O(1) without any dependencies.

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

prova questo:

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

you can edit the string in the parse() methods param.

Since you are using Scala, there is a very good Scala library Lamma . With Lamma you can minus date directly with - 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 

Just use below method with two Date objects. If you want to pass current date, just pass new Date() as a second parameter as it is initialised with current time.

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

Also, apart from from number of days, if, you want other parameter difference too, use below snippet,

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

PS Code is entirely taken from an SO answer.