Calcular la diferencia entre dos instancias de fecha Java

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

Pregunta

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

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

Sin embargo, esto sólo me deja con una long que representa milisegundos. ¿Hay alguna forma más simple, más agradable para conseguir un delta de tiempo?

¿Fue útil?

Solución

La API Date JDK se rompe horrible desgracia. Recomiendo el uso de Joda Time biblioteca .

Joda tiempo tiene un concepto de tiempo Intervalo : 

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

EDIT: Por cierto, Joda tiene dos conceptos: Interval para representar un intervalo de tiempo entre dos instantes de tiempo (representar el tiempo 08 a.m.-10 a.m.), y un Duration que representa una longitud de tiempo sin los límites reales de tiempo (por ejemplo, representan dos horas!)

Si sólo se preocupan por comparaciones de tiempo, la mayoría de las implementaciones Date (incluyendo el JDK uno) implementa la interfaz Comparable que le permite utilizar el Comparable.compareTo()

Otros consejos

diff 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 a continuación, se puede llamar a: 

getDateDiff(date1,date2,TimeUnit.MINUTES);

para obtener el diff de las 2 fechas en la unidad de minutos.

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

diff legible por el hombre (sin 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 salida es algo así como Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, con las unidades clasificadas.

Sólo hay que convertir ese mapa para una cadena fácil de usar.

Advertencia

Los fragmentos de código anteriores calculan un diff simple entre 2 instantes. Puede causar problemas durante un cambio de horario de verano, como se explica en este post . Esto significa que si usted calcula el diff entre las fechas sin tiempo usted puede tener un día perdido / hora.

En mi opinión el diff fecha es una especie de subjetiva, especialmente en días. Es posible que:

  • contar el número de tiempo transcurrido 24h: día + 1 - días = 1 día = 24 horas

  • contar el número de tiempo transcurrido, el cuidado de horario de verano: día + 1 - días = 1 = 24 horas (pero usando el tiempo de la medianoche y horario de verano podría ser 0 días y 23 h)

  • contar el número de day switches, lo que significa día + 1 13:00 - día 11 a.m. = 1 día, incluso si el tiempo transcurrido es sólo 2h (o 1 hora si hay ahorro de luz del día: p)

Mi respuesta es válida si su definición de la fecha de diferencias en los días coincide con el primero caso

Con JodaTime

Si está utilizando JodaTime que pueda obtener el diff para 2 instantes (millies respaldados ReadableInstant) data con: 

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

Sin embargo, también se puede obtener el diff de 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 fechas UTC, por lo que la diferencia puede ser un día de descanso si nos fijamos en las fechas locales. Y conseguir que funcione correctamente con las fechas locales requiere un enfoque completamente diferente debido al horario de verano.

Es necesario definir su problema con mayor claridad. Usted podría acaba de tomar el número de milisegundos entre los dos objetos Date y se dividen por el número de milisegundos en 24 horas, por ejemplo, pero ...:

  • Esto no va a tomar en consideración las zonas horarias - Date está siempre en UTC
  • Esto no tomará en cuenta el ahorro de tiempo (en el que no puede haber días que son sólo 23 horas de duración, por ejemplo) la luz del día
  • Incluso dentro de UTC, cuántos días hay en agosto décimo sexta 23:00 a agosto decimooctava 02 a.m.? Es tan sólo 27 horas, así que ¿significa un día? O debe ser tres días, ya que abarca tres fechas?

tl; dr

Convertir los objetos obsoletos java.util.Date a su sustitución, java.time.Instant. A continuación, calcular el tiempo transcurrido como 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 Formato: PnYnMnDTnHnMnS

Lo sensible estándar 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. el estándar tal envergadura como un . El formato es PnYnMnDTnHnMnS donde el P significa "Período", la T separa la parte de fecha desde la porción de tiempo, y en el medio son 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 java.time marco integrado en Java 8 y posterior suplanta las clases java.util.Date / java.util.Calendar viejos molestos. Las nuevas clases son inspirados por el gran éxito Joda-Time marco, que pretende ser su sucesor, similar en concepto, pero rediseñado. Definido por JSR 310 . Extendido por el ThreeTen-Extra proyecto . Vea la Tutorial .

Moment

El Instant clase 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 heredadas, tales como Date / Calendar. Pero si debe interoperar con código antiguo no ha actualizado a java.time , convertir de ida y vuelta. Llame a nuevos métodos de conversión añadido a las viejas clases. Para pasar de una java.util.Date a un Instant , llamada Date::toInstant . 

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

espacio de tiempo

Las clases java.time han dividido esta idea de que representa un lapso de tiempo como un número de años, meses, días, horas, minutos, segundos en dos mitades:

Este es 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 Period y Duration utilizan el href="https://en.wikipedia.org/wiki/ISO_8601#Durations" rel="noreferrer"> ISO 8601 estándar 

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

Ahora: 2015-11-26T00: 46: 48,016 a 05: 00 [América / Montreal] para el futuro: 11/26/2015T00: 46: 48,016 a 05: 00 [América / Montreal] = PT1H3M

Java 9 añade métodos para Duration para obtener la parte días, las horas, los minutos parte, y segundo parcial.

Usted puede obtener el número total de días, horas o minutos o segundos o milisegundos o nanosegundos en toda la duración. 

long totalHours = duration.toHours();

En Java 9 del clase Duration obtiene nueva métodos para el retorno de las diversas partes de días, horas, minutos, segundos, milisegundos / nanosegundos. Llamar a los métodos to…Part:. toDaysPart(), toHoursPart(), y así sucesivamente

ChronoUnit

Si sólo se preocupan por una granularidad más grande simple de tiempo, tales como “número de días transcurridos”, utilice el ChronoUnit enum. 

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 java.time marco está construido en Java 8 y versiones posteriores. Estas clases suplantan los legado clases de fecha y hora molestos, como java.util.Date , Calendar , y SimpleDateFormat .

El href="http://www.joda.org/joda-time/" rel="noreferrer"> Joda-Time proyecto , ahora en el modo de mantenimiento , aconseja migración a java.time.

Para obtener más información, consulte la Oracle Tutorial . Y la búsqueda de desbordamiento de pila durante muchos ejemplos y explicaciones. Especificación es JSR 310 .

¿Dónde obtener las clases java.time?

El rel="noreferrer"> ThreeTen-Extra extiende java.time con clases adicionales. Este proyecto es un campo de pruebas para posibles futuras adiciones a java.time. Usted puede encontrar algunas clases útiles aquí como Interval , YearWeek , YearQuarter , y más .

Joda-Time

ACTUALIZACIÓN: El Joda-Time proyecto se encuentra en modo de mantenimiento, con el equipo de asesoramiento migración a la clases java.time . Les dejo esta sección intacta de la historia.

La biblioteca Joda-Time utiliza ISO 8601 por sus valores por defecto. Su clase Period analiza y genera estos PnYnMnDTnHnMnS cadenas. 

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

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

https://www.joda.org/joda-time/faq .html # datediff

Una alternativa un poco más simple: 

System.currentTimeMillis() - oldDate.getTime()

En cuanto a la "mejor": bueno, ¿qué es exactamente lo que necesita? El problema con la representación de duraciones de tiempo como un número de horas y días, etc es que puede dar lugar a imprecisiones y expectativas equivocadas debido a la complejidad de las fechas (por ejemplo, días pueden tener 23 o 25 horas debido al horario de ahorro de luz diurna).

Aplicando un enfoque de milisegundos pueden causar problemas en algunos locales.

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

Sin embargo, el uso de la ruta de milisegundos, obtendrá 0 días, si ejecuta 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 manera de implementar esto es utilizar 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 de encontrar la diferencia entre fechas y horas. Una de las maneras más simples, que yo sepa 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 sentencia print es sólo un ejemplo - puede darle formato, la forma que desee

.

Desde todas las respuestas aquí son correctas, pero el uso de Java legado o bibliotecas 3 ª parte como joda o similares, que se acaba de caer otra manera el uso de la nueva java.time clases en Java 8 y versiones posteriores. Ver Oracle Tutorial .

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

Al restar las fechas en milisegundos funciona (como se describe en otro post), pero Tienes para utilizar HOUR_OF_DAY y no por hora cuando la limpieza de las partes de la hora de 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
}

Si no desea utilizar JodaTime o similares, la mejor solución es probablemente la siguiente: 

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 siempre es la misma (a causa de horario de verano y saltar segundos), pero es muy estrecha, y por lo menos desviaciones debidas a la hora de verano se cancelan durante períodos más largos. Por lo tanto dividir y luego redondeo dará un resultado correcto (al menos tan largo como el calendario local utilizada no contiene tiempo extraño salta distinta de DST y saltar segundos).

Tenga en cuenta que esto todavía supone que date1 y date2 se fijan a la misma hora del día. Para diferentes horas del día, que le primero tiene que definir lo que "diferencia de fechas" significa, como se ha señalado por Jon Skeet.

Tome un vistazo a Joda Time , que es una mejora Fecha / Hora API para Java y debería funcionar bien con Scala.

Te voy a enseñar la diferencia entre el intervalo y Joda Días: 

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 07s 03h 42m", 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;
}

Comprobar ejemplo aquí http://www.roseindia.net/java/beginners/DateDifferent Shtml Este ejemplo le dan la diferencia en días, horas, minutos, segundos y milisegundos seg 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.");
    }
}

Uso GMT zona horaria para obtener una instancia del calendario, establecer el tiempo utilizando el método de juego de clase Calendar. La zona horaria GMT ha compensado 0 (no es realmente importante) y la luz del día de la bandera ahorro de tiempo establecido en 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));

Después de código que puede dar 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";
    }
}

Nota: startDate y endDates son -> 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();

y fecha de finalización

Al igual que en días, también se puede obtener horas, minutos y segundos 

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

int daysDiff = (date1.getTime() - date2.getTime()) / MILLIS_PER_DAY;

Lo mejor que puedes hacer es 

(Date1-Date2)/86 400 000

Ese número es el número de milisegundos en un día.

Una fecha fecha le da otra diferencia en milisegundos.

Recoger la respuesta en un doble variable.

Eso es probablemente la forma más sencilla de hacerlo - tal vez es porque he estado de codificación en Java (con sus bibliotecas de fecha y hora es cierto torpe) desde hace un tiempo, pero que el código se ve "sencillo y agradable" a mí!

¿Está satisfecho con el resultado que se devuelven en milisegundos, o es parte de su pregunta que usted prefiere tenerlo devuelta en un formato alternativo?

No utilizar la API estándar, no. Puede rodar su propio hacer algo como esto: 

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

O puede usar Joda : 

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

Sólo para responder a la pregunta inicial:

Coloque el siguiente código en una función como a largo 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;

El más importante aquí es trabajar con números largos al multiplicar y dividir. Y, por supuesto, el desplazamiento que Java se aplica en su cálculo de fechas.

:)

Dado que la cuestión se etiqueta con 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

Aquí hay una solución correcta Java 7 en O (1) sin ningún tipo de dependencias. 

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

Después de vadear a través de todas las otras respuestas, para mantener el tipo de fecha 7 de Java, sino ser más precisos / estándar con el enfoque 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;
}

intente lo siguiente: 

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

se puede editar la cadena en el análisis sintáctico () métodos parámetro.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top