Cálculo de la diferencia entre dos instancias de fecha de Java

Estoy usando la clase java.util.Date de Java en Scala y quiero comparar un objeto Date y la hora actual. Sé que puedo calcular el delta usando getTime ():

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

Sin embargo, esto solo me deja con una representación long milisegundos. ¿Hay alguna manera más simple y más agradable de obtener un delta de tiempo?

La API de Date JDK está terriblemente rota por desgracia. Recomiendo usar la biblioteca Joda Time .

Joda Time tiene un concepto de intervalo de tiempo:

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

EDITAR: por cierto, Joda tiene dos conceptos: Interval para representar un intervalo de tiempo entre dos instantes de tiempo (representa el tiempo entre 8am y 10am), y una Duration que representa un período de tiempo sin los límites de tiempo reales (por ejemplo, representan dos horas) !

Si solo le importan las comparaciones de tiempo, la mayoría de las implementaciones de Date (incluido el JDK) implementa una interfaz Comparable que le permite usar Comparable.compareTo()

Diferencia simple (sin 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); } 

Y luego puedes llamar:

 getDateDiff(date1,date2,TimeUnit.MINUTES); 

para obtener la diferencia de las 2 fechas en minutos unidad.

TimeUnit es java.util.concurrent.TimeUnit , una enumeración Java estándar que va de nanos a días.


Human legible diff (sin 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

La salida es algo así como Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0} , con las unidades ordenadas.

Solo tienes que convertir ese mapa en una cadena fácil de usar.


Advertencia

Los fragmentos de código anteriores calculan una diferencia simple entre 2 instantes. Puede causar problemas durante un cambio de horario de verano, como se explica en esta publicación . Esto significa que si calcula la diferencia entre las fechas sin tiempo, es posible que tenga un día / hora faltante.

En mi opinión, la diferencia de fecha es algo subjetiva, especialmente en días. Puedes:

  • cuente el número de 24 horas de tiempo transcurrido: día + 1 día = 1 día = 24 horas

  • cuente la cantidad de tiempo transcurrido, teniendo cuidado de los ahorros de luz diurna: día + 1 día = 1 = 24 horas (pero utilizando la hora de medianoche y los ahorros de luz diurna podrían ser 0 días y 23 horas)

  • cuente el número de day switches de day switches , lo que significa día + 1 1 p.m. – día 11 a.m. = 1 día, incluso si el tiempo transcurrido es solo 2 h (o 1 h si hay un horario de verano: p)

Mi respuesta es válida si su definición de diferencia de fecha en días coincide con el primer caso

Con JodaTime

Si está utilizando JodaTime, puede obtener el diff para 2 instantes (millies backed ReadableInstant) fechas con:

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

Pero también puede obtener la diferencia para fechas / horas 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) ) 

Tenga en cuenta que esto funciona con las fechas UTC, por lo que la diferencia puede ser un día libre si observa las fechas locales. Y hacer que funcione correctamente con las fechas locales requiere un enfoque completamente diferente debido al horario de verano.

Debes definir tu problema más claramente. Simplemente podría tomar el número de milisegundos entre los dos objetos de Date y dividir por el número de milisegundos en 24 horas, por ejemplo … pero:

  • Esto no tomará en cuenta las zonas horarias – La Date siempre está en UTC
  • Esto no tomará en cuenta el horario de verano (donde puede haber días que solo tienen 23 horas de duración, por ejemplo)
  • Incluso dentro de UTC, ¿cuántos días hay del 16 de agosto a las 11 p.m. al 18 de agosto a las 2 a.m. Son solo 27 horas, ¿eso significa un día? ¿O debería ser tres días porque cubre tres fechas?

Usando el marco java.time integrado 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()); 

Salida:

ISO-8601: PT24H10M

Minutos: 1450

Para obtener más información, consulte el Tutorial de Oracle y el estándar ISO 8601 .

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

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

tl; dr

Convierta sus obsoletos objetos java.util.Date a su reemplazo, java.time.Instant . Luego calcule el tiempo transcurrido como una 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

El estándar sensible ISO 8601 define una representación textual concisa de un lapso de tiempo como un número de años, meses, días, horas, etc. Las llamadas estándar tales como una duración de duración . El formato es PnYnMnDTnHnMnS donde la P significa “Período”, la T separa la porción de la fecha de la porción de tiempo, y entre ellos están los números seguidos por una letra.

Ejemplos:

  • P3Y6M4DT12H30M5S
    tres años, seis meses, cuatro días, doce horas, treinta minutos y cinco segundos
  • PT4H30M
    Cuatro horas y media

java.time

El marco java.time integrado en Java 8 y posterior suplanta las problemáticas antiguas clases java.util.Date / java.util.Calendar . Las nuevas clases están inspiradas en el exitoso framework Joda-Time , diseñado como su sucesor, similar en concepto pero rediseñado. Definido por JSR 310 . Ampliado por el proyecto ThreeTen-Extra . Ver el tutorial .

Momento

La clase Instant representa un momento en la línea de tiempo en UTC con una resolución de nanosegundos (hasta nueve (9) dígitos de una fracción decimal).

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

Lo mejor es evitar las clases antiguas, como Date / Calendar . Pero si debe interoperar con el código anterior que aún no se ha actualizado a java.time , conviértalo de ida y vuelta. Llame a nuevos métodos de conversión agregados a las clases antiguas. Para pasar de java.util.Date a Instant , llame a Date::toInstant .

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

Lapso de tiempo

Las clases de java.time han dividido esta idea de representar un lapso de tiempo como una cantidad de años, meses, días, horas, minutos, segundos en dos mitades:

  • Period por años, meses, días
  • Duration por días, horas, minutos, segundos

Aquí hay un ejemplo.

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

Volcado a la consola.

Tanto el Period como la Duration usan el estándar ISO 8601 para generar una representación de Cadena de su valor.

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

ahora: 2015-11-26T00: 46: 48.016-05: 00 [América / Montreal] al futuro: 2015-11-26T00: 46: 48.016-05: 00 [America / Montreal] = PT1H3M

Java 9 agrega métodos a la Duration para obtener la parte de días, parte de horas, parte de minutos y parte de segundos.

Puede obtener la cantidad total de días u horas o minutos o segundos o milisegundos o nanosegundos en toda la Duración.

 long totalHours = duration.toHours(); 

En Java 9, la clase Duration obtiene nuevos métodos para devolver las distintas partes de días, horas, minutos, segundos, milisegundos / nanosegundos. Llame to…Part métodos: toDaysPart() , toHoursPart() , y así sucesivamente.

ChronoUnit

Si solo le interesa una granularidad de tiempo mayor y más simple, como la “cantidad de días transcurridos”, use la enumeración ChronoUnit .

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

Otro ejemplo.

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

120


Acerca de java.time

El marco java.time está integrado en Java 8 y posterior. Estas clases suplantan a las problemáticas antiguas clases heredadas de fecha y hora como java.util.Date , Calendar y SimpleDateFormat .

El proyecto Joda-Time , ahora en modo de mantenimiento , aconseja la migración a java.time.

Para obtener más información, consulte el Tutorial de Oracle . Y busque Stack Overflow para obtener muchos ejemplos y explicaciones. La especificación es JSR 310 .

¿Dónde obtener las clases de java.time?

  • Java SE 8 y SE 9 y posteriores
    • Incorporado.
    • Parte de la API Java estándar con una implementación integrada.
    • Java 9 agrega algunas características y correcciones menores.
  • Java SE 6 y SE 7
    • Gran parte de la funcionalidad de java.time se transfiere a Java 6 y 7 en ThreeTen-Backport .
  • Androide
    • El proyecto ThreeTenABP adapta ThreeTen-Backport (mencionado anteriormente) específicamente para Android.
    • Vea Cómo usar …

El proyecto ThreeTen-Extra amplía java.time con clases adicionales. Este proyecto es un terreno de prueba para posibles adiciones futuras a java.time. Puede encontrar algunas clases útiles aquí, como Interval , YearWeek , YearQuarter y más .


Joda-Time

ACTUALIZACIÓN: El proyecto Joda-Time ahora está en modo de mantenimiento , y el equipo recomienda la migración a las clases java.time . Dejo esta sección intacta para la historia.

La biblioteca Joda-Time usa ISO 8601 para sus valores predeterminados. Su clase Period analiza y genera estas cadenas 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 

Una alternativa ligeramente más simple:

 System.currentTimeMillis() - oldDate.getTime() 

En cuanto a “más agradable”: bueno, ¿qué es exactamente lo que necesitas? El problema de representar las duraciones de tiempo como un número de horas y días, etc. es que puede generar imprecisiones y expectativas incorrectas debido a la complejidad de las fechas (por ejemplo, los días pueden tener 23 o 25 horas debido al horario de verano).

El uso de un enfoque de milisegundos puede causar problemas en algunas configuraciones regionales.

Tomemos, por ejemplo, la diferencia entre las dos fechas 24/03/2007 y 25/03/2007 debe ser de 1 día;

Sin embargo, usando la ruta en milisegundos, obtendrás 0 días, ¡si ejecutas esto en el Reino Unido!

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

Una mejor forma de implementar esto es usar 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; } 

Hay muchas maneras en que puede encontrar la diferencia entre fechas y horas. Una de las formas más simples que conozco sería:

  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 statement impresa es solo un ejemplo: puede formatearla de la manera que desee.

Como todas las respuestas aquí son correctas, pero utilizo java heredado o librerías de terceros como joda o similar, me limitaré a utilizar otras nuevas clases java.time en Java 8 y posterior. Vea el Tutorial de Oracle .

Use LocalDate y 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 ); 

Restar las fechas en milisegundos funciona (como se describe en otra publicación), pero debe usar HOUR_OF_DAY y no HOUR cuando borre las partes de tiempo de sus fechas:

 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 } 

Eche un vistazo a Joda Time , que es una API de fecha / hora mejorada para Java y debería funcionar bien con Scala.

Si no desea utilizar JodaTime o similar, la mejor solución es probablemente esta:

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

El número de ms por día no es siempre el mismo (debido al horario de verano y los segundos intercalares), pero está muy cerca, y al menos las desviaciones debidas al horario de verano se cancelan durante períodos más largos. Por lo tanto, dividir y luego redondear dará un resultado correcto (al menos, siempre que el calendario local utilizado no contenga saltos de tiempo extraños que no sean DST y segundos intercalares).

Tenga en cuenta que esto aún asume que date1 y date2 están configurados a la misma hora del día. Para diferentes momentos del día, primero debe definir qué significa “diferencia de fecha”, como lo señaló Jon Skeet.

Déjame mostrar la diferencia entre Joda Interval y 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 

Si necesita una cadena de retorno con formato como “2 días 03h 42m 07s”, intente esto:

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

Ver ejemplo aquí http://www.roseindia.net/java/beginners/DateDifferent.shtml Este ejemplo le da la diferencia en días, horas, minutos, segundos y milisegundos :).

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

Use la zona horaria GMT para obtener una instancia del Calendario, configure la hora usando el método set de la clase Calendario. La zona horaria GMT tiene un desplazamiento de 0 (no es realmente importante) y un indicador de horario de verano establecido en falso.

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

El siguiente código puede darle el resultado deseado:

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

prueba esto:

 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.