Java est un langage de programmation qui a progressé et s'est améliorée au fil du temps. Les classes de gestion des dates en sont un exemple. java.util.Date y java.util.Calendar, qui existent depuis la nuit des temps. Cependant, ces classes ne sont pas les plus adaptées à la gestion des dates en Java. C'est pourquoi, chez Euroinnova, nous allons nous concentrer sur les variables de la classe date type.
Les Paquet java.time est une bonne alternative pour gérer les dates en Java, bien qu'elle présente certaines singularités et variables que vous devez prendre en compte. Connaissez-vous LocalTime ou LocalDateTime ? Préparez-vous car nous allons approfondir cet aspect, afin que vous puissiez clore cet article avec toutes les informations nécessaires. Si vous souhaitez continuer à vous familiariser avec Java, nous vous recommandons de consulter l'ouvrage Cours avancé de programmation frontale avec Javascript Angular.
Qu'est-ce qu'une date en Java ?
Les gestion des dates en Java est d'une grande importance pour de nombreuses applications, car c'est le seul moyen d'enregistrer et de gérer des événements chronologiques. Comme nous le disons, le Classe de date en Java est présent depuis les premières versions du langage, ce qui permet de représenter un point dans le temps (millisecondes depuis le 1er janvier 1970, 00:00:00 GMT).
Cependant, les versions les plus récentes de Java ont remplacé la classe Date par les classes du paquetage java.time. Pourquoi ? Parce que sa fonctionnalité était limitée par certaines incohérences, comme l'absence de prise en charge directe des fuseaux horaires. C'est pourquoi de nouvelles classes ont été introduites dans Java 8, comme Date locale, Heure locale y LocalDateTime, Le nouveau système, qui permet une plus grande précision et un meilleur contrôle des opérations de datation.
Comment obtenir la date en Java ?
Obtenir la date du jour en Java est un processus simple, puisqu'il suffit d'utiliser la classe Date locale du paquet java.time. Cette méthode vous permet d'obtenir la date actuelle du système de manière efficace. Voici un exemple de cette méthode :
import java.time.LocalDate ;
public class DateExample {
public static void main(String[] args) {
LocalDate today = LocalDate.now() ;
System.out.println(«Date d'aujourd'hui : » + aujourd'hui) ;
}
}
Comme nous pouvons le voir dans ce code, il existe une méthode now() dans la classe Date locale. Ceci renvoie la date actuelle dans le format aaaa-mm-jj, qui est le format standard en Java. Si nous voulons également obtenir l'heure, nous devons recourir à la classe LocalDateTime.
Comme on peut le constater, cette méthode est plus moderne que la classe Date, car elle offre une plus grande flexibilité et une meilleure compatibilité avec la classe formats de date et d'heure java.
Comment déclarer une variable date en Java ?
Déclarer une variable de Type de date en Java est très simple, mais vous devez savoir quelle classe de date vous devez utiliser dans votre projet. Par exemple, ce projet utilise le paquetage java.util, que declara una variable de tipo Date y la empieza con la fecha y hora actuales.
import java.util.Date;
public class DateDeclaration {
public static void main(String[] args) {
Date date = new Date(); // Fecha actual
System.out.println(«Fecha actual: » + date);
}
}
El valor representado por esta fecha será impreso en formato de cadena, incluyendo información de hora y minuto. Sin embargo, ya sabemos que la clase Date tiene ciertas limitaciones, por lo que recomendamos optar por las nuevas clases del paquete java.time, que cuenta con una mayor precisión y control. Quedaría tal que así con la clase Date locale.
import java.time.LocalDate ;
public class LocalDateExample {
public static void main(String[] args) {
LocalDate localDate = LocalDate.of(2023, 10, 12); // Año, mes y día
System.out.println(«Fecha: » + localDate);
}
}
Aquí se especifican los valores de año, mes y día. Además, el uso de formatter java date facilita el parsing date y su transformación en diferentes formatos.
El paquete java.time, en profundidad
Ahora toca adentrarse de lleno en el Paquet java.time. Como hemos dicho, fue introducido en Java 8 para mejorar la manipulación de fechas y horas, resolviendo las limitaciones de las clases Date y Calendar. En este paquete se incluyen clases como LocalDate, LocalTime, LocalDateTime y ZonedDateTime, cada una diseñada para un objetivo en concreto.
El paquete java.time se basa en los principios de inmutabilidad y claridad, permitiendo una manipulación más precisa y segura de las fechas y horas en aplicaciones de Java. Además, su formato genera un uso más intuitivo y moderno, facilitando la lectura, escritura y transformación de fechas en diversos formatting date java.
Date locale
Les clase LocalDate es la principal herramienta en java.time, y es que permite trabajar con fechas sin necesidad de gestionar zonas horarias ni tiempos específicos. Esta clase es muy útil para almacenar eventos que solo requieren información de fecha, además de que se puede obtener la fecha actual mediante el método now().
También se pueden sumar o restar días, meses o años de una fecha utilizando métodos como plusDays() o minusMonths(). Por otro lado, se pueden comparar fechas usando métodos como isBefore() o isAfter(). Aquí te dejamos un ejemplo de cómo sumar días a una fecha:
LocalDate today = LocalDate.now() ;
LocalDate futureDate = today.plusDays(10); // Sumar 10 días
System.out.println(«Fecha futura: » + futureDate);
De esta manera, se pueden manipular plazos o eventos programados en fechas específicas sin necesidad de recurrir a componentes de tiempo como hour minute o hh mm ss.
Heure locale
Heure locale es otra clase del paquete java.time que permite manejar el tiempo sin asociarse a una fecha específica., puesto que solo contiene información sobre horas, minutos, segundos y nanosegundos. Así, es ideal para situaciones en las que solo se necesita registrar tiempos sin preocuparse por el día, como en horarios de apertura,
Aquí tenemos un ejemplo:
LocalTime time = LocalTime.of(14, 30); // Hora: 14:30
System.out.println(«Hora: » + time);
LocalDateTime
La clase LocalDateTime combina tanto la fecha como la hora en un solo objetivo, siendo una de las clases más versátiles en java.time. ¿Por qué? Porque incluye tanto las funcionalidades de LocalDate como de LocalTime, manejando tanto la fecha como el tiempo sin incluir la zona horaria.
Aquí te dejamos un ejemplo de LocalDateTime con el método of() para definir tanto la fecha como la hora.
LocalDateTime dateTime = LocalDateTime.of(2023, 10, 12, 14, 30); // Año, mes, día, hora y minuto
System.out.println(«Fecha y hora: » + dateTime);
Instant
Instant es una clase en Java para representar un momento específico en la línea de tiempo, medido en nanosegundos desde el 1 de enero de 1970, 00:00:00 GMT. Lo diferente es que se trabaja con un concepto universal de tiempo (UTC), ideal para operaciones en las que se requiere una precisión temporal muy alta.
Aquí te dejamos un pequeño ejemplo:
Instant instant = Instant.now(); // Fecha y hora actuales en formato UTC
System.out.println(«Instantáneo: » + instant);
ZonedDateTime
La clase ZonedDateTime mezcla la funcionalidad de LocalDateTime con el manejo de zonas horarias, lo que nos deja trabajar con fechas y horas en diferentes ubicaciones. Para las aplicaciones internacionales, los eventos ocurren en diferentes zonas horarios, por lo que se necesitan conversiones automáticas.
Este es un ejemplo de cómo crear un ZonedDateTime:
ZonedDateTime zonedDateTime = ZonedDateTime.now();
System.out.println(«Fecha y hora con zona: » + zonedDateTime);
Period
Period es otra clase importante en Java para representar un intervalo de tiempo en términos de años, meses y días. Sobre todo, se utiliza cuando se desea calcular la diferencia entre dos fechas sin tener en cuenta las horas o los segundos. Así, un Period se puede crear muy fácil usando el método between().
LocalDate startDate = LocalDate.of(2020, 1, 1);
LocalDate endDate = LocalDate.now();
Period period = Period.between(startDate, endDate);
System.out.println(«Diferencia: » + period.getYears() + » años»);
Duration
Duration está diseñada para representar un intervalo de tiempo, pero en términos de horas, minutos, segundos y nanosegundos. Su diferencia con Period radica en que está orientada a medir lapsos de tiempo más cortos y específicos, como, por ejemplo, una llamada telefónica.
Así puedes crear una Duration:
LocalTime startTime = LocalTime.of(10, 0);
LocalTime endTime = LocalTime.of(12, 30);
Duration duration = Duration.between(startTime, endTime);
System.out.println(«Duración: » + duration.toHours() + » horas»);
Partes de una fecha o una hora
En Java, una fecha o hora se compone de varias partes. Por ejemplo, en la clase Date locale, puedes obtener el año, mes y día de una fecha específica usando métodos como getYear(), getMonthValue y getDayofMonth(). Aquí te dejamos un ejemplo:
LocalDate date = LocalDate.now();
int year = date.getYear();
int month = date.getMonthValue();
int day = date.getDayOfMonth();
System.out.println(«Año: » + year + «, Mes: » + month + «, Día: » + day);
De igual manera se puede hacer con las partes de una hora, como hora, minuto y segundo. En este caso, se usan métodos como getHour(), getMinute() y getSecond().
LocalTime time = LocalTime.now();
int hour = time.getHour();
int minute = time.getMinute();
System.out.println(«Hora: » + hour + «, Minuto: » + minute);
Transformar fechas y horas
Esta es una duda común, puesto que transformar fechas y horas en Java es una de las tareas más recurrentes. Sin embargo, completar esta misión es realmente fácil cuando se usan clases como LocalDate, LocalTime, LocalDateTime y ZonedDateTime.
Por ejemplo, para transformar un objeto de LocalDate a un LocalDateTime simplemente se puede combinar una fecha con un tiempo mediante el método atTime().
LocalDate date = LocalDate.now();
LocalDateTime dateTime = date.atTime(14, 30);
System.out.println(«Fecha y hora: » + dateTime);
De igual manera, para transformar una fecha a un formato de cadena específico puedes usar DateTimeFormatter, que te permite definir el formato deseado y luego aplicarlo a la fecha u hora.
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(«dd-MM-yyyy»);
String formattedDate = date.format(formatter);
System.out.println(«Fecha formateada: » + formattedDate);
Ajustes temporales
Les ajustes temporales se usan en Java para modificar fechas o tiempos de acuerdo con ciertas reglas predefinidas. Como ya hemos visto, se pueden sumar o restar días, semanas, meses o años con una clase de métodos. Sin embargo, también se pueden realizar ajustes basados en días específicos del mes o del año. Por ejemplo, ajustar una fecha para que caiga en el último día del mes usando el método withDayOfMonth().
LocalDate endOfMonth = today.withDayOfMonth(today.lengthOfMonth());
System.out.println(«Último día del mes: » + endOfMonth);
Formato personalizado de fechas
El formato de las fechas también se puede personalizar en Java usando la clase DateTimeFormatter, que deja definir formatos específicos para convertir horas y fechas. Por ejemplo, si quieres formatear una fecha en el formato dd-mm-yyyy, puedes usar el siguiente código:
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(«dd-MM-yyyy»);
LocalDate date = LocalDate.now();
String formattedDate = date.format(formatter);
System.out.println(«Fecha en formato personalizado: » + formattedDate);
Hay proyectos en los que se necesita presentar fechas de una manera específica, como en informes o en aplicaciones en las que los usuarios viven en diferentes regiones con formatos distintos. Por ello, no te debes olvidar de DateTimeFormatter.
Ejemplos prácticos
Para cerrar este post, no se nos ocurre mejor manera que aportarte una serie de ejemplos prácticos sobre cómo utilizar las clases y métodos del paquete java.time.
Obtener la fecha y hora actuales
Este sería un ejemplo simple de cómo obtener la fecha y hora actuales utilizando LocalDateTime:
import java.time.LocalDateTime;
public class DateTimeExample {
public static void main(String[] args) {
LocalDateTime currentDateTime = LocalDateTime.now();
System.out.println(«Fecha y hora actuales: » + currentDateTime);
}
}
Formatear una fecha
A continuación, te mostramos cómo formatear una fecha usando DateTimeFormatter:
import java.time.LocalDate ;
import java.time.format.DateTimeFormatter;
public class FormatDateExample {
public static void main(String[] args) {
LocalDate date = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(«dd-MM-yyyy»);
String formattedDate = date.format(formatter);
System.out.println(«Fecha formateada: » + formattedDate); } }
Calcular la diferencia entre dos fechas
Aquí, usamos Period para calcular la diferencia en años, meses y días entre dos fechas distintas:
import java.time.LocalDate ;
import java.time.Period;
public class PeriodExample {
public static void main(String[] args) {
LocalDate startDate = LocalDate.of(2020, 1, 1);
LocalDate endDate = LocalDate.now();
Period period = Period.between(startDate, endDate);
System.out.println(«Han pasado » + period.getYears() + » años, «
period.getMonths() + » meses, y » + period.getDays() + » días.»);
}
}
Trabajar con zonas horarias
Para terminar, te dejamos un ejemplo de cómo trabajar con ZonedDateTime para gestionar fechas y horas en diferentes zonas horarias:
import java.time.ZonedDateTime;
import java.time.ZoneId;
public class ZonedDateTimeExample {
public static void main(String[] args) {
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of(«America/New_York»));
System.out.println(«Fecha y hora en Nueva York: » + zonedDateTime);
}
}
Español 
English (UK) 
Français