tiempo - private date fecha java

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

Question

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 long representación de milisegundos. ¿Hay alguna forma más simple y agradable de obtener un delta de tiempo?

Answer 1

Dif 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 el diff de las 2 fechas en minutos unidad.

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

Dif. Legible por humanos (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 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 fechas sin tiempo, es posible que falte un día / hora.

En mi opinión, la fecha es un poco subjetiva, especialmente en los días. Puedes:

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

• cuente la cantidad de tiempo transcurrido, cuidando el horario de verano: día + 1 - día = 1 = 24h (pero utilizando el horario de medianoche y el horario de verano podría ser de 0 días y 23h)

• cuente la cantidad de day switches de day switches , lo que significa día + 1 1pm - día 11am = 1 día, incluso si el tiempo transcurrido es de solo 2h (o 1h si hay un horario de verano: p)

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

Con JodaTime

Si está utilizando JodaTime, puede obtener la diferencia para las fechas de 2 instantes (milis respaldados por ReadableInstant) con:

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

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

Answer 2

tl; dr

Convierta sus objetos java.util.Date obsoletos a su reemplazo, java.time.Instant . Luego calcula 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. El estándar llama a tal lapso de una duración . El formato es PnYnMnDTnHnMnS donde P significa "Período", la T separa la parte de la fecha de la parte de la hora y entre ellos hay números seguidos de 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 java.time posteriores reemplaza las viejas y problemáticas clases java.util.Date / java.util.Calendar . Las nuevas clases están inspiradas en el exitoso marco Joda-Time , pensado como su sucesor, similar en concepto pero rediseñado. Definido por JSR 310 . Extendido 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 nanoseconds (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 como Date / Calendar . Pero si debe interactuar con el código antiguo que aún no se ha actualizado a java.time , convierta de un lado a otro. Llama nuevos métodos de conversión añadidos a las clases antiguas. Para pasar de un java.util.Date a un 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 un número 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 );

Volcar a la consola.

Tanto el Period como la Duration utilizan 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 [América / Montreal] = PT1H3M

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

Puede obtener el número 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 varias partes de días, horas, minutos, segundos, milisegundos / nanosegundos. Llame a los métodos de la to…Part : toDaysPart() , toHoursPart() , etc.

ChronoUnit

Si solo le interesa una granularidad de tiempo más simple, como el "número 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 java.time posteriores. Estas clases sustituyen a las antiguas y problemáticas clases 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 . Y busca para muchos ejemplos y explicaciones. La especificación es JSR 310 .

¿Dónde obtener las clases java.time?

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

El proyecto ThreeTen-Extra extiende 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 more .

Tiempo de joda

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

La biblioteca de Joda-Time utiliza 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

Answer 3

Déjame mostrarte 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 

Answer 4

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

Answer 5

El JDK Date API está horriblemente roto por desgracia. Recomiendo usar la biblioteca Joda Time .

Joda Time tiene un concepto de Interval de tiempo:

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 (representa el tiempo entre las 8 am y las 10 am), y una Duration que representa un período de tiempo sin los límites de tiempo reales (por ejemplo, representa dos horas) !)

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

Answer 6

El uso del 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, si utiliza 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 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;  
}  

Answer 7

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 declaración de impresión es solo un ejemplo: puede formatearla de la forma que desee.

Answer 8

Necesitas definir tu problema más claramente. Puede simplemente tomar la cantidad de milisegundos entre los dos objetos Date y dividir por la cantidad de milisegundos en 24 horas, por ejemplo ... pero:

• Esto no tendrá en cuenta las zonas horarias: la Date siempre está en UTC
• Esto no tendrá en cuenta el horario de verano (por ejemplo, puede haber días que duren solo 23 horas)
• Incluso dentro de la UTC, ¿cuántos días hay del 16 de agosto a las 11 p. Son solo 27 horas, ¿eso significa un día? ¿O deberían ser tres días porque cubre tres fechas?

Answer 9

Restar las fechas en milisegundos funciona (como se describe en otra publicación), pero debe usar HOUR_OF_DAY y no HOUR para borrar 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
}

Answer 10

Si necesita una cadena de retorno formateada 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;
}

Answer 11

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

La cantidad de ms por día no siempre es la misma (debido al horario de verano y los segundos de salto), 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 mientras el calendario local utilizado no contenga saltos de tiempo extraños que no sean DST y segundos de salto).

Tenga en cuenta que esto todavía 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.

Answer 12

Una alternativa un poco más simple:

System.currentTimeMillis() - oldDate.getTime()

En cuanto a "mejor": bueno, ¿qué es exactamente lo que necesitas? El problema de representar la duración del tiempo como una cantidad de horas y días, etc., es que puede llevar a imprecisiones y expectativas erróneas debido a la complejidad de las fechas (por ejemplo, los días pueden tener 23 o 25 horas debido al horario de verano).

Answer 13

Usando el framework 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 .

Answer 14

Use la zona horaria GMT para obtener una instancia del calendario, establezca la hora utilizando el método establecido de la clase Calendario. La zona horaria de GMT tiene un desplazamiento de 0 (no es realmente importante) y el 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));

Answer 15

Ver ejemplo aquí http://www.roseindia.net/java/beginners/DateDifferent.shtml Este ejemplo le da 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.");
    }
}

Answer 16

Ya que todas las respuestas aquí son correctas, pero use java heredadas o librerías de terceros como joda o similar, simplemente lo eliminaré de otra manera utilizando nuevas clases de java.time en Java 8 y posteriores. Ver 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 );

Answer 17

Aquí hay una solución correcta de Java 7 en O (1) sin ninguna dependencia.

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

Answer 18

Dado que la pregunta está etiquetada 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

Answer 19

Después de leer todas las demás respuestas, para mantener el tipo de fecha de Java 7 pero ser más preciso / estándar con el enfoque de diferencia de 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;
}

Answer 20

El siguiente código puede darle la salida deseada:

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

Answer 21

Esa es probablemente la forma más sencilla de hacerlo, tal vez porque he estado programando en Java (con sus bibliotecas de fecha y hora, sin lugar a dudas) por un tiempo, ¡pero ese código me parece "simple y agradable"!

¿Está satisfecho con el resultado que se devuelve en milisegundos o es parte de su pregunta que preferiría que se devuelva en algún formato alternativo?

Answer 22

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 u otra fecha le da la diferencia en milisegundos.

Recoge la respuesta en una variable doble .

Answer 23

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

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

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

Answer 24

Sólo para responder a la pregunta inicial:

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

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

:)

Answer 25

prueba esto:

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

puede editar la cadena en los métodos parse () param.

Answer 26

No utilizando la API estándar, no. Puedes rodar tu propio haciendo algo como esto:

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

O puedes usar Joda :

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

Answer 27

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

Answer 28

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.

Answer 29

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

Answer 30

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

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