Cómo calcular días entre fechas en Java

5 feb 2024 4 min di lettura
Cómo calcular días entre fechas en Java
Indice dei contenuti

Introducción

En el mundo del desarrollo de software, gestionar fechas y horas es una tarea común pero crucial. Ya sea que esté creando una herramienta de gestión de proyectos, planificando eventos o realizando un seguimiento de plazos, calcular la diferencia entre dos fechas es una necesidad crítica. Java, con su sólido conjunto de bibliotecas y clases, ofrece varias formas de realizar esta tarea con precisión y facilidad. En este artículo exploraremos cómo dominar la manipulación del tiempo calculando el número de días entre dos fechas en Java, proporcionando ejemplos prácticos para guiarle.

Comprender la API de fecha y hora de Java

Antes de sumergirnos en los cálculos, es fundamental comprender las dos API principales que ofrece Java para gestionar fechas y horas:

  • java.util.Date y java.util.Calendar (API heredada): las versiones anteriores de Java proporcionaban estas clases para manipular la fecha y la hora. Sin embargo, tienen varias limitaciones y problemas de diseño, como la mutabilidad y la falta de seguridad de los subprocesos.
  • Paquete java.time (API moderna): introducida en Java 8, esta API, también conocida como API de fecha y hora, soluciona las deficiencias de las clases heredadas. Es inmutable, seguro para subprocesos y trabajar con él es más intuitivo. Para la mayoría de los proyectos nuevos, este es el enfoque recomendado.

Calcular días entre dos fechas usando java.time

Programa Java que demuestra cómo calcular el número de días entre dos fechas utilizando el paquete java.time. Este ejemplo ilustra el uso de las clases LocalDate y ChronoUnit de la API Date-Time de Java 8. El programa calcula el número total de días entre dos fechas especificadas, considerando también los años bisiestos, lo que lo hace muy preciso para cualquier cálculo que involucre duraciones entre fechas.

import java.time.LocalDate;
 import java.time.temporal.ChronoUnit;

 public class DaysBetweenDates {

 public static void main(String[] args) {
 //Define start and end dates
 LocalDate startDate = LocalDate.of(2023, 1, 1); //Start date (YYYY-MM-DD)
 LocalDate endDate = LocalDate.of(2023, 12, 31); //End date (YYYY-MM-DD)

 //Calculate the number of days between the start and end dates
 long daysBetween = ChronoUnit.DAYS.between(startDate, endDate);

 //Output the result
 System.out.println("Total days between " + startDate + " and " + endDate + ": " + daysBetween);
 }
 }

Detalles del programa:

Instancias de LocalDate: dos instancias de LocalDate representan las fechas de inicio y finalización. Puedes cambiar estas fechas según tus necesidades.

Calcular días entre: el método ChronoUnit.DAYS.between(startDate, endDate) calcula el número total de días entre las dos instancias de LocalDate. Considera los años bisiestos, lo que garantiza la precisión en cualquier rango de años.

Salida: Finalmente, el programa imprime en la consola el número calculado de días entre las fechas de inicio y finalización.

Ejecución y salida

Para ejecutar este programa, necesitará tener Java instalado en su sistema y compilar el archivo (por ejemplo, javac DaysBetweenDates.java) y luego ejecutar el archivo de clase compilado (por ejemplo, java DaysBetweenDates). El resultado mostrará el total de días entre las fechas de inicio y finalización especificadas, por ejemplo:

Total days between 2023-01-01 and 2023-12-31: 364

Gestión de zona horaria

Si trabaja con horas y zonas horarias, considere usar ZonedDateTime o Instant para operaciones de fecha y hora que requieran reconocimiento de zona horaria. Calcular la diferencia en días considerando las zonas horarias sigue un enfoque similar pero tiene en cuenta las diferencias de zona horaria.

import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.temporal.ChronoUnit;

 public class DaysBetweenDatesWithTimeZones {

 public static void main(String[] args) {
 //Define start and end dates with time zones
 ZonedDateTime startDateTime = ZonedDateTime.of(2023, 1, 1, 0, 0, 0, 0, ZoneId.of("UTC"));
 ZonedDateTime endDateTime = ZonedDateTime.of(2023, 12, 31, 0, 0, 0, 0, ZoneId.of("UTC"));

 //Calculate the number of days between the start and end dates considering time zones
 long daysBetweenTimeZones = ChronoUnit.DAYS.between(startDateTime, endDateTime);

 //Output the result
 System.out.println("Total days between dates with time zones: " + daysBetweenTimeZones);
 }
 }

Detalles del programa:

Instancias ZonedDateTime: crea dos instancias ZonedDateTime para la fecha de inicio y finalización, ambas configuradas en la zona horaria "UTC". Puede cambiar la zona horaria cambiando el parámetro ZoneId.of("UTC").

Calcular días entre: El método ChronoUnit.DAYS.between(startDateTime, endDateTime) calcula el número total de días entre el inicio y el final de las instancias de ZonedDateTime, considerando cuidadosamente la zona horaria.

Salida: El programa imprime el total de días entre las fechas especificadas en la consola.

Enfoque API heredado

Para aquellos que trabajan en sistemas heredados o no pueden usar Java 8 o posterior, aún pueden calcular la diferencia usando java.util.Calendar:

import java.util.Calendar;

 public class DaysBetweenDatesLegacy {

 public static void main(String[] args) {
 //Create Calendar instances for the start and end dates
 Calendar startCalendar = Calendar.getInstance();
 startCalendar.set(2023, Calendar.JANUARY, 1); //Set start date
 Calendar endCalendar = Calendar.getInstance();
 endCalendar.set(2023, Calendar.DECEMBER, 31); //Set end date

 //Calculate the difference in milliseconds between the start and end dates
 long startTime = startCalendar.getTimeInMillis();
 long endTime = endCalendar.getTimeInMillis();
 long daysBetween = (endTime - startTime) /(24 * 60 * 60 * 1000); //Convert milliseconds to days

 //Output the number of days between the two dates
 System.out.println("Days between dates (Legacy): " + daysBetween);
 }
 }

Este método manipula directamente milisegundos para calcular la diferencia, lo que puede ser menos intuitivo y propenso a errores que usar la API java.time.

Detalles del programa:

Instancias de calendario: crea dos instancias de calendario para representar las fechas de inicio y finalización. El método set se utiliza para especificar el año, mes y día de cada uno.

Cálculo en milisegundos: recupere el tiempo en milisegundos para la fecha de inicio y finalización usando getTimeInMillis(). Luego se calcula la diferencia entre estos tiempos.

Cálculo de días: la diferencia en milisegundos se convierte a días dividiendo por la cantidad de milisegundos en un día (24 * 60 * 60 * 1000).

Ejecución y salida

Para ejecutar este programa, compílelo con javac DaysBetweenDatesLegacy.java y luego ejecútelo usando java DaysBetweenDatesLegacy. El resultado mostrará el número total de días entre el 1 de enero de 2023 y el 31 de diciembre de 2023, así:

Days between dates (Legacy): 364

Conclusión

Calcular el número de días entre dos fechas en Java es un requisito común que se puede lograr con API tanto modernas como heredadas. El paquete java.time, introducido en Java 8, proporciona un enfoque más sólido, inmutable y fluido para manejar cálculos de fecha y hora, lo que lo convierte en la opción preferida para nuevos proyectos. Al comprender y utilizar estas herramientas, podrá dominar la manipulación del tiempo en sus aplicaciones Java, garantizando cálculos de fecha y hora precisos y eficientes. Ya sea que esté planificando eventos, rastreando los cronogramas de proyectos o simplemente organizando fechas, las API de fecha y hora de Java brindan la funcionalidad que necesita para administrar el tiempo de manera efectiva.

Support us with a

Successivamente, completa il checkout per l'accesso completo a Noviello.it.
Bentornato! Accesso eseguito correttamente.
Ti sei abbonato con successo a Noviello.it.
Successo! Il tuo account è completamente attivato, ora hai accesso a tutti i contenuti.
Operazione riuscita. Le tue informazioni di fatturazione sono state aggiornate.
La tua fatturazione non è stata aggiornata.