¿Diferencia en días entre dos fechas en Java?


81

Necesito encontrar el número de días entre dos fechas : una es de un informe y la otra es la fecha actual. Mi fragmento:

  int age=calculateDifference(agingDate, today);

Aquí calculateDifferencehay un método privado, agingDatey todayson Dateobjetos, solo para su aclaración. He seguido dos artículos de un foro de Java, Thread 1 / Thread 2 .

Funciona bien en un programa independiente, aunque cuando incluyo esto en mi lógica para leer el informe, obtengo una diferencia inusual en los valores.

¿Por qué está sucediendo y cómo puedo solucionarlo?

EDITAR:

Obtengo una mayor cantidad de días en comparación con la cantidad real de días.

public static int calculateDifference(Date a, Date b)
{
    int tempDifference = 0;
    int difference = 0;
    Calendar earlier = Calendar.getInstance();
    Calendar later = Calendar.getInstance();

    if (a.compareTo(b) < 0)
    {
        earlier.setTime(a);
        later.setTime(b);
    }
    else
    {
        earlier.setTime(b);
        later.setTime(a);
    }

    while (earlier.get(Calendar.YEAR) != later.get(Calendar.YEAR))
    {
        tempDifference = 365 * (later.get(Calendar.YEAR) - earlier.get(Calendar.YEAR));
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    if (earlier.get(Calendar.DAY_OF_YEAR) != later.get(Calendar.DAY_OF_YEAR))
    {
        tempDifference = later.get(Calendar.DAY_OF_YEAR) - earlier.get(Calendar.DAY_OF_YEAR);
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    return difference;
}

Nota :

Desafortunadamente, ninguna de las respuestas me ayudó a resolver el problema. Logré este problema con la ayuda de la biblioteca Joda-time .


3
¿Qué quiere decir con valores de diferencia inusuales? ¿Podría ser más explícito o dar un ejemplo de algún tipo?
Marcel Gheorghita

1
¿Puedes publicar el código para el método calculateDifference?
Eugene Ryzhikov

Para su información, las clases de fecha y hora viejas problemáticas tales como java.util.Date, java.util.Calendary java.text.SimpleDateFormatahora están legado , suplantados por los java.time clases. Consulte el tutorial de Oracle . Asimismo, el proyecto Joda-Time se encuentra ahora en modo de mantenimiento , y el equipo aconseja la migración a las clases java.time.
Basil Bourque

Respuestas:


149

Le sugiero que use la excelente biblioteca Joda Time en lugar del defectuoso java.util.Date y amigos. Simplemente podrías escribir

import java.util.Date;
import org.joda.time.DateTime;
import org.joda.time.Days;

Date past = new Date(110, 5, 20); // June 20th, 2010
Date today = new Date(110, 6, 24); // July 24th 
int days = Days.daysBetween(new DateTime(past), new DateTime(today)).getDays(); // => 34

3
joda-time.sourceforge.net/faq.html#datediff - Estaba a punto de sugerir lo mismo.
Nebril

2
jodaInstance = new DateTime (jdkDate); Sobre la conversión entre joda time y java.util.Date y amigos, consulte joda-time.sourceforge.net/userguide.html#JDK_Interoperability
Adam Schmideg

2
@ven coder: creo que puedes publicarlo como una pregunta separada sobre el uso de joda time. También puede proporcionar un fragmento de código que arroje un resultado aparentemente incorrecto.
Adam Schmideg

2
@ven coder: actualicé el código de muestra, funciona para mí. Veo esta pregunta respondida. Muestre el código que no le funciona, ya sea aquí o en una pregunta separada.
Adam Schmideg

1
Para su información, el proyecto Joda-Time ahora está en modo de mantenimiento , y el equipo aconseja la migración a las clases java.time . Consulte el tutorial de Oracle .
Basil Bourque

48

Puede que sea demasiado tarde para unirme al juego, pero ¿qué diablos, eh? :)

¿Crees que esto es un problema de subprocesos? ¿Cómo está utilizando la salida de este método, por ejemplo? O

¿Podemos cambiar su código para hacer algo tan simple como:

Calendar calendar1 = Calendar.getInstance();
    Calendar calendar2 = Calendar.getInstance();
    calendar1.set(<your earlier date>);
    calendar2.set(<your current date>);
    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.");
  }

18
Este código no presta atención al horario de verano, por lo que el resultado de la diferencia de días puede no ser correcto.
Johanna

@Johanna Aunque es bastante tarde, ¿podría dar un ejemplo cuando esto falle? He intentado mucho, pero no pude encontrar ningún intervalo de fechas en el que esto falle. Gracias.
abhilash

4
Este error solo ocurre si se encuentra en una zona horaria (su configuración de zona horaria local) que utiliza el horario de verano, por ejemplo, la hora de Europa Central, Berlín, París o Ámsterdam. El día de inicio y finalización del horario de verano no tiene 24 horas, por ejemplo, el 30 de marzo de 2014 solo tuvo 23 horas, mientras que el 26 de octubre de 2014 tendrá 25 horas. Si la fecha anterior es anterior al 30 de marzo a las 2:00 y la fecha posterior es posterior al 30 de marzo a las 3:00, el cálculo falla.
Johanna

23

El diff / (24 * etc) no tiene en cuenta la zona horaria, por lo que si su zona horaria predeterminada tiene un horario de verano, puede desechar el cálculo.

Este enlace tiene una pequeña implementación.

Aquí está la fuente del enlace anterior en caso de que el enlace se caiga:

/** Using Calendar - THE CORRECT WAY**/  
public static long daysBetween(Calendar startDate, Calendar endDate) {  
  //assert: startDate must be before endDate  
  Calendar date = (Calendar) startDate.clone();  
  long daysBetween = 0;  
  while (date.before(endDate)) {  
    date.add(Calendar.DAY_OF_MONTH, 1);  
    daysBetween++;  
  }  
  return daysBetween;  
}  

y

/** Using Calendar - THE CORRECT (& Faster) WAY**/  
public static long daysBetween(final Calendar startDate, final Calendar endDate)
{
  //assert: startDate must be before endDate  
  int MILLIS_IN_DAY = 1000 * 60 * 60 * 24;  
  long endInstant = endDate.getTimeInMillis();  
  int presumedDays = 
    (int) ((endInstant - startDate.getTimeInMillis()) / MILLIS_IN_DAY);  
  Calendar cursor = (Calendar) startDate.clone();  
  cursor.add(Calendar.DAY_OF_YEAR, presumedDays);  
  long instant = cursor.getTimeInMillis();  
  if (instant == endInstant)  
    return presumedDays;

  final int step = instant < endInstant ? 1 : -1;  
  do {  
    cursor.add(Calendar.DAY_OF_MONTH, step);  
    presumedDays += step;  
  } while (cursor.getTimeInMillis() != endInstant);  
  return presumedDays;  
}

4
El segundo método es incorrecto, el final whiledebería serlo. while (cursor.getTimeInMillis() <= endInstant); De lo contrario, obtienes un bucle infinito si menos de un día.
Chris.Jenkins

Del comentario en el enlace "Debe tener en cuenta que el algoritmo proporcionado puede dar 'un día más' de lo esperado. Da 1 como el número de días entre 2009-02-28 19:00:00 y 2009-02-28 19:00:01 ".
Zyoo

16

java.time

En Java 8 y versiones posteriores, use el marco java.time ( Tutorial ).

Duration

La Durationclase representa un lapso de tiempo como una cantidad de segundos más una fracción de segundo. Puede contar días, horas, minutos y segundos.

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println(duration.toDays());

ChronoUnit

Si todo lo que necesita es la cantidad de días, alternativamente puede usar la enumeración . Observe que los métodos de cálculo devuelven a en lugar de .ChronoUnit longint

long days = ChronoUnit.DAYS.between( then, now );

también asegúrese de pasar las fechas a ChronoUnit.DAYS.between en el orden correcto, de lo contrario, devolverá -ve result
RRR_J

13
import java.util.Calendar;
import java.util.Date;

public class Main {
    public static long calculateDays(String startDate, String endDate)
    {
        Date sDate = new Date(startDate);
        Date eDate = new Date(endDate);
        Calendar cal3 = Calendar.getInstance();
        cal3.setTime(sDate);
        Calendar cal4 = Calendar.getInstance();
        cal4.setTime(eDate);
        return daysBetween(cal3, cal4);
    }

    public static void main(String[] args) {
        System.out.println(calculateDays("2012/03/31", "2012/06/17"));

    }

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

1
Loop no es una excelente idea. ¿Qué hay del rendimiento cuando hay opciones más simples para hacer lo mismo?
angelcervera

1
Una mejora del rendimiento sería incrementar en potencias de 2, y luego, cuando la condición date.before (endDate) sea falsa, volver a la iteración anterior y restablecer el incremento en 1. Eso es así si estás a mil millones de días de distancia, haría quizás 30 iteraciones de algo en lugar de mil millones. También podría mejorar el rendimiento haciendo una suposición comprobando los milisegundos, pero eso probablemente sería menos elegante.
Muhd

12

Depende de lo que defina como diferencia. Para comparar dos fechas a medianoche puedes hacerlo.

long day1 = ...; // in milliseconds.
long day2 = ...; // in milliseconds.
long days = (day2 - day1) / 86400000;

9
Este código no presta atención al horario de verano, por lo que es posible que el resultado no sea correcto.
Johanna

@Johanna Esta solución funciona con DST. Cuando se aplica la ronda después de la división, esta diferencia se ignora y el resultado es correcto.
angelcervera

1
@angelcervera La mayoría de las veces será correcto, pero si está cerca, la hora extra podría hacer que la precisión sea de +/- 1 día de descanso (es decir, redondearía al revés).
Muhd

3
@Muhd Sí, tienes razón. La tercera línea debe ser: días largos = Math.round ((día2 - día1) / 86400000D); Es muy importante que el divisor sea un valor doble.
angelcervera

3
Lo siento. Olvidé conectar mi módulo de matemáticas de primer grado en mi cerebro esta mañana. Estaba pensando que restar un negativo eliminaría el cálculo. Deberíamos poder rechazar los comentarios.
Snekse

9

Solución que usa la diferencia entre milisegundos de tiempo, con el redondeo correcto para las fechas de DST:

public static long daysDiff(Date from, Date to) {
    return daysDiff(from.getTime(), to.getTime());
}

public static long daysDiff(long from, long to) {
    return Math.round( (to - from) / 86400000D ); // 1000 * 60 * 60 * 24
}

Una nota: por supuesto, las fechas deben estar en alguna zona horaria.

El código importante:

Math.round( (to - from) / 86400000D )

Si no desea una ronda, puede usar fechas UTC,


1
@marcolopes No, devuelve 32. System.out.println (daysDiff (new Date (2014, 2, 1), new Date (2014, 3, 2))); Tenga cuidado, porque enero es 0.
angelcervera

4

Ilustración del problema: (Mi código calcula delta en semanas, pero el mismo problema se aplica con delta en días)

Aquí hay una implementación de aspecto muy razonable:

public static final long MILLIS_PER_WEEK = 7L * 24L * 60L * 60L * 1000L;

static public int getDeltaInWeeks(Date latterDate, Date earlierDate) {
    long deltaInMillis = latterDate.getTime() - earlierDate.getTime();
    int deltaInWeeks = (int)(deltaInMillis / MILLIS_PER_WEEK);
    return deltaInWeeks; 
}

Pero esta prueba fallará:

public void testGetDeltaInWeeks() {
    delta = AggregatedData.getDeltaInWeeks(dateMar09, dateFeb23);
    assertEquals("weeks between Feb23 and Mar09", 2, delta);
}

La razón es:

Mon Mar 09 00:00:00 EDT 2009 = 1,236,571,200,000
Mon Feb 23 00:00:00 EST 2009 = 1,235,365,200,000
MillisPerWeek = 604,800,000
Por lo tanto,
(Mar09 - Feb 23) / MillisPerWeek =
1,206,000,000 / 604,800,000 = 1.994 ...

pero cualquiera que mire un calendario estaría de acuerdo en que la respuesta es 2.


1
Observe EDT y EST . Estás mirando el horario de verano. 168 horas en una semana (+1 por "ganar" una hora en la primavera) * dos semanas, agregando la hora extra de DST, y tienes: 335/168 = 1.9940476190.
jpswain

3

Yo uso esta funcion:

DATEDIFF("31/01/2016", "01/03/2016") // me return 30 days

mi función:

import java.util.Date;

public long DATEDIFF(String date1, String date2) {
        long MILLISECS_PER_DAY = 24 * 60 * 60 * 1000;
        long days = 0l;
        SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy"); // "dd/MM/yyyy HH:mm:ss");

        Date dateIni = null;
        Date dateFin = null;        
        try {       
            dateIni = (Date) format.parse(date1);
            dateFin = (Date) format.parse(date2);
            days = (dateFin.getTime() - dateIni.getTime())/MILLISECS_PER_DAY;                        
        } catch (Exception e) {  e.printStackTrace();  }   

        return days; 
     }


2

Basado en la respuesta de @ Mad_Troll, desarrollé este método.

He ejecutado alrededor de 30 casos de prueba en su contra, es el único método que maneja correctamente los fragmentos de tiempo sub-día.

Ejemplo: si pasa ahora y ahora + 1 milisegundo, sigue siendo el mismo día. Haciendo 1-1-13 23:59:59.098que 1-1-13 23:59:59.099devuelve 0 días, correctamente; muchos de los otros métodos publicados aquí no harán esto correctamente.

Vale la pena señalar que no le importa de qué manera los coloque, si su fecha de finalización es anterior a su fecha de inicio, contará hacia atrás.

/**
 * This is not quick but if only doing a few days backwards/forwards then it is very accurate.
 *
 * @param startDate from
 * @param endDate   to
 * @return day count between the two dates, this can be negative if startDate is after endDate
 */
public static long daysBetween(@NotNull final Calendar startDate, @NotNull final Calendar endDate) {

    //Forwards or backwards?
    final boolean forward = startDate.before(endDate);
    // Which direction are we going
    final int multiplier = forward ? 1 : -1;

    // The date we are going to move.
    final Calendar date = (Calendar) startDate.clone();

    // Result
    long daysBetween = 0;

    // Start at millis (then bump up until we go back a day)
    int fieldAccuracy = 4;
    int field;
    int dayBefore, dayAfter;
    while (forward && date.before(endDate) || !forward && endDate.before(date)) {
        // We start moving slowly if no change then we decrease accuracy.
        switch (fieldAccuracy) {
            case 4:
                field = Calendar.MILLISECOND;
                break;
            case 3:
                field = Calendar.SECOND;
                break;
            case 2:
                field = Calendar.MINUTE;
                break;
            case 1:
                field = Calendar.HOUR_OF_DAY;
                break;
            default:
            case 0:
                field = Calendar.DAY_OF_MONTH;
                break;
        }
        // Get the day before we move the time, Change, then get the day after.
        dayBefore = date.get(Calendar.DAY_OF_MONTH);
        date.add(field, multiplier);
        dayAfter = date.get(Calendar.DAY_OF_MONTH);

        // This shifts lining up the dates, one field at a time.
        if (dayBefore == dayAfter && date.get(field) == endDate.get(field))
            fieldAccuracy--;
        // If day has changed after moving at any accuracy level we bump the day counter.
        if (dayBefore != dayAfter) {
            daysBetween += multiplier;
        }
    }
    return daysBetween;
}

Puede eliminar las @NotNullanotaciones, Intellij las utiliza para realizar análisis de código sobre la marcha


Tomo en cuenta Millis, esa calculadora no, supongo que redondea los números a 0. Como dije en la parte superior de la respuesta. Aplana tus horas / minutos / segundos / milis y verás que entonces contará correctamente.
Chris.Jenkins

1

Dices que "funciona bien en un programa independiente", pero que obtienes "valores de diferencia inusuales" cuando "incluyes esto en mi lógica para leer el informe". Eso sugiere que su informe tiene algunos valores para los que no funciona correctamente y su programa independiente no tiene esos valores. En lugar de un programa independiente, sugiero un caso de prueba. Escriba un caso de prueba como lo haría con un programa independiente, subclasificando de la clase TestCase de JUnit. Ahora puede ejecutar un ejemplo muy específico, sabiendo qué valor espera (y no lo dé hoy por el valor de prueba, porque hoy cambia con el tiempo). Si ingresa los valores que usó en el programa independiente, sus pruebas probablemente pasarán. Eso es genial, quieres que esos casos sigan funcionando. Ahora, agregue un valor de su informe, uno que no t funciona bien. Su nueva prueba probablemente fallará. Averigua por qué está fallando, arréglalo y ponte verde (todas las pruebas pasan). Ejecute su informe. Mira lo que todavía está roto; escribir una prueba; hazlo pasar. Muy pronto verá que su informe está funcionando.


1

¿¿Cien líneas de código para esta función básica ???

Solo un método simple:

protected static int calculateDayDifference(Date dateAfter, Date dateBefore){
    return (int)(dateAfter.getTime()-dateBefore.getTime())/(1000 * 60 * 60 * 24); 
    // MILLIS_IN_DAY = 1000 * 60 * 60 * 24;
}

5
Ignora las zonas horarias. Ignora el horario de verano y otras anomalías. Ignora el redondeo de días parciales.
Basil Bourque

1
public static int getDifferenceIndays(long timestamp1, long timestamp2) {
    final int SECONDS = 60;
    final int MINUTES = 60;
    final int HOURS = 24;
    final int MILLIES = 1000;
    long temp;
    if (timestamp1 < timestamp2) {
        temp = timestamp1;
        timestamp1 = timestamp2;
        timestamp2 = temp;
    }
    Calendar startDate = Calendar.getInstance(TimeZone.getDefault());
    Calendar endDate = Calendar.getInstance(TimeZone.getDefault());
    endDate.setTimeInMillis(timestamp1);
    startDate.setTimeInMillis(timestamp2);
    if ((timestamp1 - timestamp2) < 1 * HOURS * MINUTES * SECONDS * MILLIES) {
        int day1 = endDate.get(Calendar.DAY_OF_MONTH);
        int day2 = startDate.get(Calendar.DAY_OF_MONTH);
        if (day1 == day2) {
            return 0;
        } else {
            return 1;
        }
    }
    int diffDays = 0;
    startDate.add(Calendar.DAY_OF_MONTH, diffDays);
    while (startDate.before(endDate)) {
        startDate.add(Calendar.DAY_OF_MONTH, 1);
        diffDays++;
    }
    return diffDays;
}

1

ThreeTen-Extra

La respuesta de Vitalii Fedorenko es correcta y describe cómo realizar este cálculo de una manera moderna con las clases java.time ( Duration& ChronoUnit) integradas en Java 8 y posteriores (y adaptadas a Java 6 y 7 y a Android ).

Days

Si usa varios días de forma rutinaria en su código, puede reemplazar meros enteros con el uso de una clase. La Daysclase se puede encontrar en el proyecto ThreeTen-Extra , una extensión de java.time y campo de pruebas para posibles adiciones futuras a java.time. La Daysclase proporciona una forma segura de representar un número de días en su solicitud. La clase incluye constantes convenientes para ZEROy ONE.

Dados los viejos java.util.Dateobjetos obsoletos de la Pregunta, primero conviértalos en java.time.Instantobjetos modernos . Las antiguas clases de fecha y hora tienen métodos recientemente agregados para facilitar la conversión a java.time, como java.util.Date::toInstant.

Instant start = utilDateStart.toInstant(); // Inclusive.
Instant stop = utilDateStop.toInstant();  // Exclusive.

Pase ambos Instantobjetos al método de fábrica para org.threeten.extra.Days.

En la implementación actual (2016-06), esta es una llamada de contenedor java.time.temporal.ChronoUnit.DAYS.between, lea el ChronoUnitdocumento de la clase para obtener más detalles. Para ser claros: todas las mayúsculas DAYSestán en la enumeración, ChronoUnitmientras que initial-cap Dayses una clase de ThreeTen-Extra.

Days days = Days.between( start , stop );

Puede pasar estos Daysobjetos alrededor de su propio código. Puede serializar a una cadena en el formato estándar ISO 8601 llamando toString. Este formato de PnDutiliza una Ppara marcar el comienzo y Dsignifica "días", con un número de días en el medio. Tanto las clases java.time como ThreeTen-Extra utilizan estos formatos estándar de forma predeterminada al generar y analizar cadenas que representan valores de fecha y hora.

String output = days.toString();

P3D

Days days = Days.parse( "P3D" );  

0

Este código calcula los días entre 2 cadenas de fechas:

    static final long MILLI_SECONDS_IN_A_DAY = 1000 * 60 * 60 * 24;
    static final String DATE_FORMAT = "dd-MM-yyyy";
    public long daysBetween(String fromDateStr, String toDateStr) throws ParseException {
    SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
    Date fromDate;
    Date toDate;
    fromDate = format.parse(fromDateStr);
    toDate = format.parse(toDateStr);
    return (toDate.getTime() - fromDate.getTime()) / MILLI_SECONDS_IN_A_DAY;
}

0

Si está buscando una solución que devuelva el número adecuado de días entre, por ejemplo, 11/30/2014 23:59y 12/01/2014 00:01aquí está la solución con Joda Time.

private int getDayDifference(long past, long current) {
    DateTime currentDate = new DateTime(current);
    DateTime pastDate = new DateTime(past);
    return currentDate.getDayOfYear() - pastDate.getDayOfYear();
} 

Esta implementación regresará 1como una diferencia en días. La mayoría de las soluciones publicadas aquí calculan la diferencia en milisegundos entre dos fechas. Significa que 0se devolvería porque solo hay 2 minutos de diferencia entre estas dos fechas.


0

Debería utilizar la biblioteca Joda Time porque Java Util Date a veces devuelve valores incorrectos.

Joda vs Java Util Date

Por ejemplo, días entre ayer (dd-mm-aaaa, 12-07-2016) y el primer día del año 1957 (dd-mm-aaaa, 01-01-1957):

public class Main {

public static void main(String[] args) {
    SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");

    Date date = null;
    try {
        date = format.parse("12-07-2016");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    //Try with Joda - prints 21742
    System.out.println("This is correct: " + getDaysBetweenDatesWithJodaFromYear1957(date));
    //Try with Java util - prints 21741
    System.out.println("This is not correct: " + getDaysBetweenDatesWithJavaUtilFromYear1957(date));    
}


private static int getDaysBetweenDatesWithJodaFromYear1957(Date date) {
    DateTime jodaDateTime = new DateTime(date);
    DateTimeFormatter formatter = DateTimeFormat.forPattern("dd-MM-yyyy");
    DateTime y1957 = formatter.parseDateTime("01-01-1957");

    return Days.daysBetween(y1957 , jodaDateTime).getDays();
}

private static long getDaysBetweenDatesWithJavaUtilFromYear1957(Date date) {
    SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");

    Date y1957 = null;
    try {
        y1957 = format.parse("01-01-1957");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    return TimeUnit.DAYS.convert(date.getTime() - y1957.getTime(), TimeUnit.MILLISECONDS);
}

Así que te recomiendo que uses la biblioteca de Joda Time.


1
Para su información, aunque Joda-Time todavía recibe soporte activo, su equipo de desarrollo aconseja la migración a java.time . Para citar su página de inicio: "Joda-Time es la biblioteca de fecha y hora estándar de facto para Java antes de Java SE 8. Ahora se pide a los usuarios que migren a java.time (JSR-310)".
Basil Bourque

-6

Lo hice de esta manera. es fácil :)

Date d1 = jDateChooserFrom.getDate();
Date d2 = jDateChooserTo.getDate();

Calendar day1 = Calendar.getInstance();
day1.setTime(d1);

Calendar day2 = Calendar.getInstance();
day2.setTime(d2);

int from = day1.get(Calendar.DAY_OF_YEAR);
int to = day2.get(Calendar.DAY_OF_YEAR);

int difference = to-from;

4
Haga algunas pruebas sobre esto, rápidamente se dará cuenta de que esto no funcionará. ¿Desde el 31 de diciembre de 2013 hasta el 1 de enero de 2014, eso es un día de diferencia, verdad? Su cálculo funcionará, 1 - 365 = -364. Lo que ciertamente no es correcto.
Chris.Jenkins
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.