Los desarrolladores a menudo necesitan realizar operaciones de programación como recuperar la fecha actual, manipular fechas y formatear fechas en sus aplicaciones. Mientras que el tradicional de Java java.util.Calendar
la clase tuvo su día, la nueva LocalDate
La clase hace más con muchas menos líneas de código. Este artículo le presenta LocalDate
y el java.time
API para usar fechas, horas y duraciones en sus programas.
Nota: Introducido en Java 8, java.time
estandariza muchos elementos de la cultura popular. Biblioteca Joda-Time. Los conceptos presentados aquí se pueden aplicar a cualquiera de las bibliotecas, pero generalmente se recomienda el estándar JDK.
Reemplazar calendario con LocalDate
La manipulación de fechas del calendario es un aspecto esencial de muchas aplicaciones escritas en Java. Tradicionalmente, los desarrolladores confiaban en la java.util.Calendar
clase para obtener la fecha actual:
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1; // Note: Months are zero-based
int day = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(year + "-" + month + "-" + day);
El LocalDate
clase de la java-time
API ofrece una alternativa más eficiente::
LocalDate currentDate = LocalDate.now();
System.out.println(currentDate);
En este ejemplo, verá la diferencia entre la verbosidad del tradicional Calendar
clase y el más nuevo LocalDate
clase. La clase más nueva hace más con mucho menos código. A continuación, veremos algunas formas sencillas de utilizar java.time.LocalDate en sus programas Java.
Formas sencillas de utilizar LocalDate
Así es como usaríamos LocalDate
para devolver la fecha actual según el reloj del sistema:
System.out.println(LocalDate.now());
Aquí creamos un LocalDate
instancia con el año, mes y día especificados:
System.out.println(LocalDate.of(2023, 9, 19));
En el siguiente ejemplo, analizamos una representación de cadena de una fecha y devolvemos un LocalDate
instancia:
String dateString = "2024-04-19"; // ISO-8601 format
LocalDate date = LocalDate.parse(dateString);
System.out.println(date);
En los casos en los que tengamos la fecha con un formato diferente al ISO-8601, podríamos utilizar lo siguiente:
String dateString = "19/04/2024"; // Custom format
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
LocalDate date = LocalDate.parse(dateString, formatter);
System.out.println(date);
Estos son sólo algunos ejemplos de la LocalDate
La clase se utiliza para escenarios de aplicaciones donde es necesario manipular la fecha del calendario. Ahora veamos usos más complejos para LocalDate
.
Manipular componentes de fecha específicos
A veces, necesitamos poder trabajar con los componentes de una fecha, como día, mes, año, hora, minuto o segundo. Las operaciones de ejemplo incluyen comparar, calcular o validar información de fecha.
A continuación se muestra un ejemplo de cómo llamar a componentes de fecha específicos:
import java.time.LocalDate;
LocalDate date = LocalDate.now(); // Get the current date
System.out.println("Year: " + date.getYear()); // prints the year of the current date
System.out.println("Month: " + date.getMonthValue()); // prints the month of the current date
System.out.println("Day: " + date.getDayOfMonth()); // // prints the day of the current date
System.out.println("Hour: " + dateTime.getHour()); // Prints the hour of the current date
System.out.println("Minute: " + dateTime.getMinute()); // Prints the minute of the current date
System.out.println("Second: " + dateTime.getSecond()); // Prints the second of the current date
Contar días, meses o años.
¿Qué pasa con los casos en los que necesitamos sumar o restar días, meses o años de la fecha del calendario dada? Así es cómo LocalDate
maneja este caso de uso:
plusDays(int days) - Adds or subtracts the specified days from the date and returns a new LocalDate instance.
minusDays(int days) - Subtracts days from the date.
plusMonths(int months) - Adds the specified number of months to the date and returns a new LocalDate instance.
minusMonths(int months): Subtracts months from the date.
plusYears(int years) - Adds the specified years from the date and returns a new LocalDate instance.
minusYears(int years) - Subtracts years from the date.
Resolviendo el desafío del año bisiesto
Un año bisiesto es un año calendario que contiene un día adicional, o 366 días frente a los 365 habituales. Cualquier programa que utilice fechas del calendario también debe tener en cuenta los años bisiestos. Afortunadamente, java.time
‘s Year
La clase maneja este cálculo por nosotros:
isLeapYear(): Returns true if the year is a leap year
Dos formas de comparar fechas
Comparar fechas es algo que hacemos muy a menudo en programación. Aquí hay una forma más antigua de comparar fechas usando LocalDate
y el compareTo
método:
import java.time.LocalDate;
LocalDate date1 = LocalDate.now(); // Create the first date object
LocalDate date2 = LocalDate.now(); // Create the second date object
// Compare dates using the compareTo() method
int comparison = date1.compareTo(date2);
if (comparison < 0) {
System.out.println("Date 1 is before Date 2");
} else if (comparison > 0) {
System.out.println("Date 1 is after Date 2");
} else if (comparison == 0) {
System.out.println("Date 1 is equal to Date 2");
}
Una forma más intuitiva y limpia de comparar fechas es utilizando el isBefore
, isAfter
o isEqual
métodos:
if (date1.isBefore(date2)) {
System.out.println("Date 1 is before Date 2");
} else if (date1.isAfter(date2)) {
System.out.println("Date 1 is after Date 2");
} else if (date1.isEqual(date2)) {
System.out.println("Date 1 is equal to Date 2");
}
Calcular la duración en unidades temporales
Otro requisito común para las aplicaciones empresariales es la capacidad de calcular distancias temporales en unidades temporales. El java.time
La API nos permite hacer esto fácilmente.
Este ejemplo calcula la duración entre dos puntos en el tiempo medido en horas y minutos:
import java.time.LocalDateTime;
import java.time.Duration;
public class DurationExample {
public static void main(String[] args) {
LocalDateTime start = LocalDateTime.of(2024, 4, 1, 10, 0); // April 1, 2024, 10:00
LocalDateTime end = LocalDateTime.of(2024, 4, 2, 11, 30); // April 2, 2024, 11:30
Duration duration = Duration.between(start, end);
long hours = duration.toHours();
long minutes = duration.toMinutes() % 60;
System.out.println("Duration is " + hours + " hours and " + minutes + " minutes.");
}
}
En este caso la duración del tiempo es de 25 horas y 30 minutos.
Aquí calculamos la duración entre dos fechas en años, meses y días:
import java.time.LocalDate;
import java.time.Period;
public class PeriodExample {
public static void main(String[] args) {
LocalDate startDate = LocalDate.of(2024, 1, 1);
LocalDate endDate = LocalDate.of(2024, 12, 31);
Period period = Period.between(startDate, endDate);
System.out.println("Period is " + period.getYears() + " years, " +
period.getMonths() + " months, and " +
period.getDays() + " days.");
}
}
El resultado en este caso es 0 años, 11 meses y 30 días.
Manejo de zonas horarias
Al trabajar en una aplicación en producción, es posible que haya encontrado errores debido a zonas horarias configuradas incorrectamente. En ocasiones, la aplicación se implementa en un servidor con una zona horaria diferente a la del país en el que se presta servicio. Veamos formas de gestionar las diferencias en las zonas horarias utilizando java.time
clases y métodos.
Primero, podemos usar el ZonedDateTime
clase para gestionar una fecha y hora con información de zona horaria. A continuación se explica cómo obtener la hora actual para dos zonas horarias determinadas:
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
public class TimeZoneExample {
public static void main(String[] args) {
ZoneId newYorkZone = ZoneId.of("America/New_York");
ZoneId londonZone = ZoneId.of("Europe/London");
ZonedDateTime nowInNewYork = ZonedDateTime.now(newYorkZone);
ZonedDateTime nowInLondon = ZonedDateTime.now(londonZone);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println("Current time in New York: " + nowInNewYork.format(formatter));
System.out.println("Current time in London: " + nowInLondon.format(formatter));
}
}
Si ejecutamos este código el 19 de abril de 2024 a las 12:00 p.m. UTC, el resultado sería el siguiente:
- Hora actual en Nueva York: 2024-04-19 08:00:00
- Hora actual en Londres: 2024-04-19 13:00:00
¿Qué tal la conversión entre zonas horarias? A continuación se explica cómo convertir una hora determinada de una zona a otra:
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class TimeZoneConversion {
public static void main(String[] args) {
LocalDateTime localDateTime = LocalDateTime.of(2024, 4, 19, 15, 30);
ZoneId originalZone = ZoneId.of("Asia/Tokyo");
ZoneId targetZone = ZoneId.of("America/Los_Angeles");
ZonedDateTime originalZonedDateTime = ZonedDateTime.of(localDateTime, originalZone);
ZonedDateTime targetZonedDateTime = originalZonedDateTime.withZoneSameInstant(targetZone);
System.out.println("Time in Tokyo: " + originalZonedDateTime);
System.out.println("Time in Los Angeles: " + targetZonedDateTime);
}
}
La salida en este caso sería:
- Hora en Tokio: 2024-04-19T15:30+09:00[Asia/Tokyo]
- Hora en Los Ángeles: 2024-04-19T01:30-07:00[America/Los_Angeles]
Transiciones de horario de verano
Las transiciones del horario de verano (DST) pueden interrumpir la funcionalidad de su aplicación si no se manejan adecuadamente. A continuación se explica cómo manejar una transición de horario de verano utilizando el ZonedDateTime
clase:
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class TimeZoneConversion {
public static void main(String[] args) {
LocalDateTime localDateTime = LocalDateTime.of(2024, 4, 19, 15, 30);
ZoneId originalZone = ZoneId.of("Asia/Tokyo");
ZoneId targetZone = ZoneId.of("America/Los_Angeles");
ZonedDateTime originalZonedDateTime = ZonedDateTime.of(localDateTime, originalZone);
ZonedDateTime targetZonedDateTime = originalZonedDateTime.withZoneSameInstant(targetZone);
System.out.println("Time in Tokyo: " + originalZonedDateTime);
System.out.println("Time in Los Angeles: " + targetZonedDateTime);
}
}
Aquí está el resultado de este cálculo:
- Antes de que finalice el horario de verano: 2024-11-03T01:30-04:00[America/New_York]
- Después del final del horario de verano: 2024-11-03T01:30-05:00[America/New_York]
Conclusión
Los desarrolladores se ocupan de fechas y horas en la mayoría de las aplicaciones. El java.time
API incorpora elementos de la obsoleta joda-time
biblioteca y los estandariza desde Java 8 en adelante. Como has visto en este artículo, java.time
ofrece muchas construcciones poderosas para administrar la fecha y la hora en sus aplicaciones.
Recapitulemos los puntos principales de este artículo:
- El
java.time
El paquete proporciona un enfoque más claro e intuitivo para manejar fechas y horas en comparación con el método tradicional.java.util.Calendar
clase. - Usando
java.time
le permite realizar operaciones como recuperar la fecha actual, manipular fechas y formatear con menos líneas de código y menos complejidad. java.time
Funciones API comoplusDays()
yminusMonths()
Admite aritmética de fechas sencilla que es más engorrosa de ver con elCalendar
clase.- Métodos más nuevos como
isBefore()
,isAfter()
yisEqual()
Ofrecer una forma más legible y directa de comparar fechas que usarcompareTo()
. ZonedDateTime
simplifica la gestión avanzada de zonas horarias y los cálculos del horario de verano, proporcionando herramientas sólidas para aplicaciones globales.- El
java.time
La biblioteca admite potentes opciones de análisis y formato de fecha que son más fáciles de usar y comprender que las clases de fecha y hora tradicionales de Java, lo que mejora la legibilidad y el mantenimiento del código. - La biblioteca moderna de fecha y hora está diseñada para ser inmutable y segura para subprocesos, lo que genera menos efectos secundarios y errores en entornos de subprocesos múltiples.
Para proyectos nuevos o al mantener aplicaciones Java existentes, se recomienda realizar la transición a la java.time
API por su manejo más eficiente, claro y sólido de las operaciones de fecha y hora.
Copyright © 2024 IDG Communications, Inc.