En Java, ¿cómo obtengo la diferencia en segundos entre 2 fechas?

La biblioteca de clases Java tiene una clase llamada DateTime. DateTime tiene este método:

int daysBetween(DateTime other) 

que devuelve el número de días entre esto y el parámetro. No tiene un método

 int secondsBetween(DateTime other) 

lo cual sucede que necesito ¿Hay una clase que sea similar a DateTime pero que tenga dicho método?

No estoy familiarizado con DateTime …

Si tiene dos Fechas, puede llamar a getTime para obtener millseconds, obtener el diff y dividir entre 1000. Por ejemplo

 Date d1 = ...; Date d2 = ...; long seconds = (d2.getTime()-d1.getTime())/1000; 

Si tiene objetos de calendario puede llamar

 c.getTimeInMillis() 

y haz lo mismo

Deberías hacer

 org.joda.time.Seconds.secondBetween(date1, date2) 

Deberias hacer eso:

 Date a = ...; Date b = ...; Math.abs(a.getTime()-b.getTime())/1000; 

Aquí la documentación relevante: Date.getTime () . Tenga en cuenta que esto solo funcionará para fechas posteriores al 1 de enero de 1970, 00:00:00 GMT

No existe una clase como DateTime en la API Java SE estándar. Aunque hay uno en joda-time, incluso eso no tiene un método de daysBetween .

Con la API Java estándar, la forma más sencilla de obtener segundos entre dos objetos java.util.Date sería restar sus marcas de tiempo y dividir entre 1000:

 int secondsBetween = (date1.getTime() - date2.getTime()) / 1000; 

No se recomienda usar java.util.Date o System.currentTimeMillis() para medir los tiempos transcurridos. No se garantiza que estas fechas sean monótonas y se producirán cambios cuando se modifique el reloj del sistema (por ejemplo, cuando se corrija desde el servidor). En probabilidad, esto ocurrirá raramente, pero ¿por qué no codificar una solución mejor en lugar de preocuparse por posibles cambios negativos o muy grandes?

En cambio, recomendaría usar System.nanoTime() .

 long t1 = System.nanoTime(); long t2 = System.nanoTime(); long elapsedTimeInSeconds = (t2 - t1) / 1000000000; 

EDITAR

Para obtener más información acerca de la monotonía, consulte la respuesta a una pregunta relacionada que hice, donde sea posible nanoTime utiliza un reloj monotónico. He probado pero solo con Windows XP, Java 1.6 y modificando el reloj por el cual nanoTime era monotónico y el currentTimeMillis no.

También de los documentos en tiempo real de Java :

P: 50. ¿Se devuelve el tiempo mediante el reloj en tiempo real de mejor resolución que el devuelto por System.nanoTime ()?

El reloj en tiempo real y System.nanoTime () se basan en la misma llamada al sistema y, por lo tanto, en el mismo reloj.

Con Java RTS, todas las API basadas en tiempo (por ejemplo, temporizadores, subprocesos periódicos, monitoreo de fecha límite, etc.) se basan en el temporizador de alta resolución. Y, junto con las prioridades en tiempo real, pueden garantizar que el código apropiado se ejecutará en el momento adecuado para las restricciones en tiempo real. Por el contrario, las API Java SE comunes ofrecen solo unos pocos métodos capaces de manejar tiempos de alta resolución, sin garantía de ejecución en un momento dado. El uso de System.nanoTime () entre varios puntos en el código para realizar mediciones de tiempo transcurrido siempre debe ser preciso.

Si está usando Joda (que puede venir como jsr 310 en JDK 7, separar la API de código abierto hasta entonces), entonces hay una clase de segundos con un método de segundos entre medias.

Aquí está el enlace javadoc: http://joda-time.sourceforge.net/api-release/org/joda/time/Seconds.html#secondsBetween(org.joda.time.ReadableInstant,%20org.joda.time.ReadableInstant)

Puede usar org.apache.commons.lang.time.DateUtils para hacerlo más limpio:

 (firstDate.getTime() - secondDate.getTime()) / DateUtils.MILLIS_PER_SECOND 

Me gustaría brindar la respuesta moderna. Las otras respuestas estaban bien cuando se hizo esta pregunta, pero el tiempo pasa. Hoy te recomiendo que uses java.time , la moderna API de fecha y hora de Java .

  ZonedDateTime aDateTime = ZonedDateTime.of(2017, 12, 8, 19, 25, 48, 991000000, ZoneId.of("Europe/Sarajevo")); ZonedDateTime otherDateTime = ZonedDateTime.of(2017, 12, 8, 20, 10, 38, 238000000, ZoneId.of("Europe/Sarajevo")); long diff = ChronoUnit.SECONDS.between(aDateTime, otherDateTime); System.out.println("Difference: " + diff + " seconds"); 

Esto imprime:

 Difference: 2689 seconds 

ChronoUnit.SECONDS.between() funciona con dos objetos ZonedDateTime o dos OffsetDateTime s, dos LocalDateTime s, etc.

Si necesita algo más que solo los segundos, debe considerar usar la clase Duration :

  Duration dur = Duration.between(aDateTime, otherDateTime); System.out.println("Duration: " + dur); System.out.println("Difference: " + dur.getSeconds() + " seconds"); 

Esto imprime:

 Duration: PT44M49.247S Difference: 2689 seconds 

La primera de las dos líneas imprime la duración en formato ISO 8601, la salida significa una duración de 44 minutos y 49.247 segundos.

Por qué java.time?

La clase Date utilizada en varias de las otras respuestas ahora está obsoleta. Joda-Time también se usa en un par (y posiblemente en la pregunta) ahora está en modo de mantenimiento, no se prevén mejoras importantes, y los desarrolladores recomiendan oficialmente migrar a java.time , también conocido como JSR-310.

Pregunta: ¿Puedo usar la API moderna con mi versión de Java?

Si usa al menos Java 6 , puede hacerlo.

  • En Java 8 y versiones posteriores, la nueva API viene incorporada.
  • En Java 6 y 7, obtenga el ThreeTen Backport , el backport de las nuevas clases (ThreeTen for JSR 310 ).
  • En Android, use la edición de Android de ThreeTen Backport. Se llama ThreeTenABP, y hay una explicación completa en esta pregunta: Cómo usar ThreeTenABP en el Proyecto Android .

Qué clase ? ¿Te refieres a la clase Joda DateTime ? Si es así, simplemente puede llamar a getMillis() en cada uno y realizar las restas / escalas apropiadas.

Recomendaría a Joda el trabajo de fecha / hora, por cierto, debido a su API útil e intuitiva, y su seguridad de subprocesos para las opciones de formateo / análisis.

Solo un puntero: si está calculando la diferencia entre dos java.util.Date, el enfoque de restar ambas fechas y dividirlo entre 1000 es razonable, pero tenga especial cuidado si obtiene su referencia java.util.Date de un objeto Calendar. . Si lo hace, debe tener en cuenta el horario de verano de su TimeZone, ya que una de las fechas que está utilizando podría tener lugar en un período de horario de verano.

Eso se explica en el enlace de Prasoon. Recomiendo tomarse un tiempo para leerlo.

Usa este método:

 private Long secondsBetween(Date first, Date second){ return (second.getTime() - first.getTime())/1000; }