Tutorial Java: API java.time

Clases principales: LocalDate, LocalTime, LocalDateTime

La API java.time, introducida en Java 8, proporciona un conjunto de clases inmutables para trabajar con fechas y horas de manera consistente. Esta API reemplaza las clases antiguas como Date y Calendar. Las tres clases fundamentales que se utilizan para representar fechas y horas sin zona horaria son LocalDate, LocalTime y LocalDateTime.

LocalDate

La clase LocalDate representa una fecha sin hora ni zona horaria, siguiendo el calendario ISO-8601. Se utiliza cuando solo se necesita trabajar con fechas sin considerar la hora del día.

Para crear una instancia de LocalDate, se pueden utilizar varios métodos estáticos:

// Obtener la fecha actual del sistema
LocalDate hoy = LocalDate.now();

// Crear una fecha específica (año, mes, día)
LocalDate fechaNacimiento = LocalDate.of(1990, 5, 15);

// También se puede usar Month para mayor legibilidad
LocalDate navidad = LocalDate.of(2023, Month.DECEMBER, 25);

// Crear a partir de un String en formato ISO (YYYY-MM-DD)
LocalDate fechaIso = LocalDate.parse("2023-10-20");

La clase LocalDate ofrece varios métodos para manipular y extraer información:

LocalDate fecha = LocalDate.of(2023, 3, 15);

// Obtener componentes individuales
int año = fecha.getYear();          // 2023
int mes = fecha.getMonthValue();    // 3
Month mesEnum = fecha.getMonth();   // MARCH
int dia = fecha.getDayOfMonth();    // 15
DayOfWeek diaSemana = fecha.getDayOfWeek();  // WEDNESDAY
int diaAño = fecha.getDayOfYear();  // 74
boolean esBisiesto = fecha.isLeapYear(); // false

Para modificar fechas, se utilizan métodos que devuelven nuevas instancias (recordemos que son inmutables):

LocalDate fecha = LocalDate.of(2023, 3, 15);

// Operaciones de suma
LocalDate mañana = fecha.plusDays(1);
LocalDate siguienteSemana = fecha.plusWeeks(1);
LocalDate siguienteMes = fecha.plusMonths(1);
LocalDate siguienteAño = fecha.plusYears(1);

// Operaciones de resta
LocalDate ayer = fecha.minusDays(1);
LocalDate semanaAnterior = fecha.minusWeeks(1);

// Ajustes temporales
LocalDate primerDiaMes = fecha.withDayOfMonth(1);
LocalDate finDeAño = fecha.withMonth(12).withDayOfMonth(31);

// Usando TemporalAdjusters para ajustes más complejos
LocalDate siguienteLunes = fecha.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
LocalDate ultimoDiaMes = fecha.with(TemporalAdjusters.lastDayOfMonth());

También se pueden realizar comparaciones entre fechas:

LocalDate fecha1 = LocalDate.of(2023, 3, 15);
LocalDate fecha2 = LocalDate.of(2023, 5, 20);

boolean esAntes = fecha1.isBefore(fecha2);      // true
boolean esDespues = fecha1.isAfter(fecha2);     // false
boolean esIgual = fecha1.isEqual(fecha2);       // false
int comparacion = fecha1.compareTo(fecha2);     // valor negativo

LocalTime

La clase LocalTime representa una hora del día sin fecha ni zona horaria. Se utiliza cuando solo se necesita trabajar con la hora sin considerar la fecha.

Para crear instancias de LocalTime:

// Obtener la hora actual del sistema
LocalTime ahora = LocalTime.now();

// Crear una hora específica (hora, minuto, segundo, nanosegundo)
LocalTime mediodía = LocalTime.of(12, 0);
LocalTime horaEspecífica = LocalTime.of(15, 30, 45);
LocalTime precisa = LocalTime.of(10, 20, 30, 400000000);

// Crear a partir de un String en formato ISO (HH:MM:SS)
LocalTime horaIso = LocalTime.parse("13:45:30");

Al igual que LocalDate, LocalTime ofrece métodos para extraer componentes:

LocalTime hora = LocalTime.of(13, 45, 30);

int h = hora.getHour();         // 13
int m = hora.getMinute();       // 45
int s = hora.getSecond();       // 30
int n = hora.getNano();         // 0

Para manipular horas:

LocalTime hora = LocalTime.of(13, 45, 30);

// Operaciones de suma
LocalTime unaHoraDespues = hora.plusHours(1);
LocalTime cincoMinutosDespues = hora.plusMinutes(5);
LocalTime diezSegundosDespues = hora.plusSeconds(10);

// Operaciones de resta
LocalTime dosHorasAntes = hora.minusHours(2);
LocalTime treintaMinutosAntes = hora.minusMinutes(30);

// Ajustes directos
LocalTime cambiarHora = hora.withHour(10);
LocalTime cambiarMinuto = hora.withMinute(0);
LocalTime cambiarSegundo = hora.withSecond(0);

También se pueden realizar comparaciones:

LocalTime hora1 = LocalTime.of(9, 30);
LocalTime hora2 = LocalTime.of(14, 15);

boolean esAntes = hora1.isBefore(hora2);    // true
boolean esDespues = hora1.isAfter(hora2);   // false
int comparacion = hora1.compareTo(hora2);   // valor negativo

LocalDateTime

La clase LocalDateTime combina fecha y hora sin zona horaria. Se utiliza cuando se necesita trabajar con fecha y hora de manera conjunta.

Para crear instancias de LocalDateTime:

// Obtener la fecha y hora actuales del sistema
LocalDateTime ahora = LocalDateTime.now();

// Crear a partir de componentes individuales
LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);
LocalDateTime conSegundos = LocalDateTime.of(2023, 10, 15, 14, 30, 45);

// Crear combinando LocalDate y LocalTime
LocalDate fecha = LocalDate.of(2023, 10, 15);
LocalTime hora = LocalTime.of(14, 30);
LocalDateTime combinado = LocalDateTime.of(fecha, hora);

// Crear a partir de un String en formato ISO
LocalDateTime fechaHoraIso = LocalDateTime.parse("2023-10-15T14:30:45");

Se puede extraer información tanto de la fecha como de la hora:

LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);

// Obtener componentes de fecha
int año = fechaHora.getYear();           // 2023
Month mes = fechaHora.getMonth();        // OCTOBER
int dia = fechaHora.getDayOfMonth();     // 15
DayOfWeek diaSemana = fechaHora.getDayOfWeek();  // SUNDAY

// Obtener componentes de hora
int hora = fechaHora.getHour();          // 14
int minuto = fechaHora.getMinute();      // 30
int segundo = fechaHora.getSecond();     // 0

// Convertir a LocalDate o LocalTime
LocalDate soloFecha = fechaHora.toLocalDate();
LocalTime soloHora = fechaHora.toLocalTime();

Para manipular fechas y horas:

LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);

// Operaciones de suma
LocalDateTime tresDiasDespues = fechaHora.plusDays(3);
LocalDateTime dosMesesDespues = fechaHora.plusMonths(2);
LocalDateTime dosHorasDespues = fechaHora.plusHours(2);

// Operaciones de resta
LocalDateTime unAñoAntes = fechaHora.minusYears(1);
LocalDateTime treintaMinutosAntes = fechaHora.minusMinutes(30);

// Ajustes directos
LocalDateTime cambiarAño = fechaHora.withYear(2024);
LocalDateTime cambiarMes = fechaHora.withMonth(12);
LocalDateTime cambiarHora = fechaHora.withHour(10);

// Usando TemporalAdjusters
LocalDateTime siguienteViernes = fechaHora.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));

Operaciones comunes entre clases temporales

Las tres clases comparten algunas operaciones comunes que facilitan su uso:

// Verificar si dos instancias representan el mismo punto en el tiempo
boolean sonIguales = fecha1.isEqual(fecha2);

// Calcular el período entre dos fechas
Period periodo = Period.between(fecha1, fecha2);

// Obtener la representación en String con formato ISO
String fechaComoString = fecha.toString();  // "2023-10-15"
String horaComoString = hora.toString();    // "14:30:45"
String fechaHoraComoString = fechaHora.toString();  // "2023-10-15T14:30:45"

Ejemplo práctico

A continuación, se muestra un ejemplo que utiliza las tres clases para gestionar eventos en un calendario:

public class GestorEventos {
    public static void main(String[] args) {
        // Crear un evento para una reunión
        LocalDate fechaReunion = LocalDate.of(2023, 11, 15);
        LocalTime horaInicio = LocalTime.of(10, 0);
        LocalTime horaFin = LocalTime.of(11, 30);
        
        LocalDateTime inicioReunion = LocalDateTime.of(fechaReunion, horaInicio);
        LocalDateTime finReunion = LocalDateTime.of(fechaReunion, horaFin);
        
        // Verificar si la reunión es hoy
        boolean esHoy = fechaReunion.isEqual(LocalDate.now());
        
        // Calcular duración de la reunión
        long duracionMinutos = ChronoUnit.MINUTES.between(horaInicio, horaFin);
        
        // Programar recordatorio 15 minutos antes
        LocalDateTime recordatorio = inicioReunion.minusMinutes(15);
        
        System.out.println("Detalles de la reunión:");
        System.out.println("Fecha: " + fechaReunion);
        System.out.println("Hora de inicio: " + horaInicio);
        System.out.println("Hora de fin: " + horaFin);
        System.out.println("Duración: " + duracionMinutos + " minutos");
        System.out.println("Recordatorio: " + recordatorio);
        
        // Verificar si la reunión ya pasó
        boolean reunionPasada = inicioReunion.isBefore(LocalDateTime.now());
        System.out.println("¿La reunión ya pasó? " + reunionPasada);
    }
}

Este ejemplo muestra cómo se pueden utilizar las clases LocalDate, LocalTime y LocalDateTime para gestionar eventos en un calendario, calculando duraciones, programando recordatorios y verificando si un evento ya ha ocurrido.

Las clases de fecha y hora de java.time son thread-safe e inmutables, lo que significa que se pueden utilizar de manera segura en entornos concurrentes sin preocuparse por efectos secundarios inesperados. Cada operación que modifica una fecha o hora devuelve una nueva instancia, dejando la original sin cambios.

Duraciones y períodos

Cuando se trabaja con fechas y horas en Java, a menudo se necesita representar y manipular intervalos de tiempo. La API java.time proporciona dos clases principales para este propósito: Duration y Period.

Duration

La clase Duration representa una cantidad de tiempo en términos de segundos y nanosegundos. Se utiliza principalmente para medir intervalos de tiempo entre instantes o para representar duraciones precisas, especialmente cuando se trabaja con horas.

Para crear una instancia de Duration, se pueden utilizar varios métodos estáticos:

// Crear duraciones a partir de unidades específicas
Duration unMinuto = Duration.ofMinutes(1);
Duration dosHoras = Duration.ofHours(2);
Duration medioSegundo = Duration.ofMillis(500);
Duration microsDuracion = Duration.ofNanos(2_000_000);

// Crear a partir de un número total de segundos
Duration treintaSegundos = Duration.ofSeconds(30);
Duration unMinutoYMedio = Duration.ofSeconds(90);

// Crear a partir de un String en formato ISO-8601
Duration duracionIso = Duration.parse("PT1H30M"); // 1 hora y 30 minutos

La clase Duration ofrece métodos para extraer componentes de tiempo:

Duration duracion = Duration.ofHours(2).plusMinutes(30).plusSeconds(45);

long segundos = duracion.getSeconds();  // Total de segundos (9045)
int nano = duracion.getNano();          // Parte de nanosegundos (0)

// Convertir a unidades específicas
long horas = duracion.toHours();        // 2
long minutos = duracion.toMinutes();    // 150
long milisegundos = duracion.toMillis(); // 9045000

Para manipular duraciones:

Duration duracion = Duration.ofMinutes(30);

// Operaciones de suma
Duration masTiempo = duracion.plus(Duration.ofMinutes(15));
Duration masHoras = duracion.plusHours(1);
Duration masMinutos = duracion.plusMinutes(10);
Duration masSegundos = duracion.plusSeconds(30);

// Operaciones de resta
Duration menosTiempo = duracion.minus(Duration.ofMinutes(5));
Duration menosSegundos = duracion.minusSeconds(60);

// Multiplicación y división
Duration doble = duracion.multipliedBy(2);  // 1 hora
Duration mitad = duracion.dividedBy(2);     // 15 minutos

// Negación
Duration negativa = duracion.negated();     // -30 minutos
Duration absoluta = duracion.abs();         // 30 minutos (siempre positiva)

Un caso de uso común es calcular la duración entre dos instantes temporales:

LocalTime inicio = LocalTime.of(9, 0);
LocalTime fin = LocalTime.of(10, 30);

// Calcular duración entre dos horas
Duration duracionClase = Duration.between(inicio, fin);
System.out.println("La clase dura: " + duracionClase.toMinutes() + " minutos");

// Entre dos fechas-horas
LocalDateTime inicioEvento = LocalDateTime.of(2023, 11, 10, 8, 0);
LocalDateTime finEvento = LocalDateTime.of(2023, 11, 10, 16, 30);

Duration duracionEvento = Duration.between(inicioEvento, finEvento);
System.out.println("El evento dura: " + duracionEvento.toHours() + " horas y " 
                  + duracionEvento.toMinutesPart() + " minutos");

Period

La clase Period representa una cantidad de tiempo en términos de años, meses y días. Se utiliza para trabajar con intervalos basados en fechas, como la edad de una persona o el tiempo hasta un evento futuro.

Para crear una instancia de Period:

// Crear períodos a partir de unidades específicas
Period unDia = Period.ofDays(1);
Period dosSemanas = Period.ofWeeks(2);  // 14 días
Period tresMeses = Period.ofMonths(3);
Period cincoAños = Period.ofYears(5);

// Crear combinando unidades
Period personalizado = Period.of(1, 6, 15);  // 1 año, 6 meses, 15 días

// Crear a partir de un String en formato ISO-8601
Period periodoIso = Period.parse("P2Y3M15D");  // 2 años, 3 meses, 15 días

Para extraer componentes de un período:

Period periodo = Period.of(2, 5, 10);  // 2 años, 5 meses, 10 días

int años = periodo.getYears();    // 2
int meses = periodo.getMonths();  // 5
int días = periodo.getDays();     // 10

// Convertir a total de meses o días no es directo debido a la variabilidad
// de la duración de meses y años (años bisiestos, meses con diferente número de días)

Para manipular períodos:

Period periodo = Period.ofMonths(6);

// Operaciones de suma
Period masTiempo = periodo.plus(Period.ofMonths(3));
Period masAños = periodo.plusYears(1);
Period masMeses = periodo.plusMonths(2);
Period masDias = periodo.plusDays(15);

// Operaciones de resta
Period menosTiempo = periodo.minus(Period.ofDays(10));
Period menosMeses = periodo.minusMonths(1);

// Multiplicación
Period doble = periodo.multipliedBy(2);  // 1 año

// Normalización (no siempre funciona como se espera debido a la variabilidad de meses)
Period normalizado = periodo.normalized();  // Convierte 12 meses en 1 año, etc.

Un caso de uso común es calcular el período entre dos fechas:

LocalDate fechaNacimiento = LocalDate.of(1990, 5, 15);
LocalDate fechaActual = LocalDate.now();

// Calcular edad
Period edad = Period.between(fechaNacimiento, fechaActual);
System.out.println("Edad: " + edad.getYears() + " años, " 
                  + edad.getMonths() + " meses y " 
                  + edad.getDays() + " días");

// Calcular tiempo hasta un evento futuro
LocalDate fechaEvento = LocalDate.of(2024, 12, 31);
Period hastaEvento = Period.between(fechaActual, fechaEvento);
System.out.println("Faltan: " + hastaEvento.getYears() + " años, " 
                  + hastaEvento.getMonths() + " meses y " 
                  + hastaEvento.getDays() + " días para el evento");

Diferencias clave entre Duration y Period

Es importante entender cuándo usar cada clase:

• Duration: Se utiliza para cantidades de tiempo basadas en horas, minutos, segundos y fracciones de segundo. Es precisa y constante (un día siempre tiene 24 horas).
• Period: Se utiliza para cantidades de tiempo basadas en fechas (años, meses, días). No es constante debido a la variabilidad de los calendarios (meses con diferente número de días, años bisiestos).

// Duration es adecuada para tiempos exactos
Duration tiempoEjecucion = Duration.ofMillis(1500);  // 1.5 segundos

// Period es adecuado para intervalos de calendario
Period tiempoContrato = Period.ofMonths(6);  // 6 meses, independiente de cuántos días tengan

Combinando Duration y Period con clases temporales

Tanto Duration como Period se pueden utilizar para modificar instancias de las clases temporales:

LocalDate hoy = LocalDate.now();
LocalDate dentroDeSeisMeses = hoy.plus(Period.ofMonths(6));

LocalTime ahora = LocalTime.now();
LocalTime dentroDeDosHoras = ahora.plus(Duration.ofHours(2));

LocalDateTime fechaHoraActual = LocalDateTime.now();
LocalDateTime reunionFutura = fechaHoraActual.plus(Period.ofWeeks(2))
                                            .plus(Duration.ofHours(3));

ChronoUnit: una alternativa para cálculos simples

Para cálculos simples de tiempo, la enumeración ChronoUnit ofrece una alternativa concisa:

// Calcular días entre fechas
LocalDate inicio = LocalDate.of(2023, 1, 1);
LocalDate fin = LocalDate.of(2023, 12, 31);
long diasEntre = ChronoUnit.DAYS.between(inicio, fin);  // 364

// Calcular horas entre instantes de tiempo
LocalDateTime inicioEvento = LocalDateTime.of(2023, 11, 10, 9, 0);
LocalDateTime finEvento = LocalDateTime.of(2023, 11, 10, 17, 30);
long horasEvento = ChronoUnit.HOURS.between(inicioEvento, finEvento);  // 8

// Añadir unidades de tiempo
LocalDate fechaFutura = LocalDate.now().plus(2, ChronoUnit.WEEKS);
LocalTime horaFutura = LocalTime.now().plus(90, ChronoUnit.MINUTES);

Ejemplo práctico: sistema de reservas

Veamos un ejemplo que utiliza Duration y Period para gestionar reservas en un sistema hotelero:

public class SistemaReservas {
    public static void main(String[] args) {
        // Fechas de la reserva
        LocalDate checkIn = LocalDate.of(2023, 12, 20);
        LocalDate checkOut = LocalDate.of(2023, 12, 27);
        
        // Calcular duración de la estancia
        Period duracionEstancia = Period.between(checkIn, checkOut);
        long noches = ChronoUnit.DAYS.between(checkIn, checkOut);
        
        // Horarios de entrada y salida
        LocalTime horaCheckIn = LocalTime.of(15, 0);  // 15:00
        LocalTime horaCheckOut = LocalTime.of(11, 0); // 11:00
        
        // Calcular tiempo total de estancia (desde check-in hasta check-out)
        LocalDateTime inicioEstancia = LocalDateTime.of(checkIn, horaCheckIn);
        LocalDateTime finEstancia = LocalDateTime.of(checkOut, horaCheckOut);
        Duration tiempoTotal = Duration.between(inicioEstancia, finEstancia);
        
        // Calcular precio (100€ por noche)
        double precioPorNoche = 100.0;
        double precioTotal = precioPorNoche * noches;
        
        // Mostrar información de la reserva
        System.out.println("Detalles de la reserva:");
        System.out.println("Check-in: " + checkIn + " a las " + horaCheckIn);
        System.out.println("Check-out: " + checkOut + " a las " + horaCheckOut);
        System.out.println("Duración: " + duracionEstancia.getDays() + " días (" + noches + " noches)");
        System.out.println("Tiempo total: " + tiempoTotal.toDays() + " días, " 
                          + tiempoTotal.toHoursPart() + " horas");
        System.out.println("Precio total: " + precioTotal + "€");
        
        // Verificar si la reserva es para el próximo mes
        boolean esProximoMes = checkIn.isAfter(LocalDate.now()) && 
                              checkIn.isBefore(LocalDate.now().plusMonths(1));
        System.out.println("¿Reserva para el próximo mes? " + esProximoMes);
        
        // Calcular tiempo restante hasta el check-in
        Period tiempoHastaCheckIn = Period.between(LocalDate.now(), checkIn);
        System.out.println("Tiempo hasta check-in: " + tiempoHastaCheckIn.getMonths() + 
                          " meses y " + tiempoHastaCheckIn.getDays() + " días");
    }
}

Este ejemplo muestra cómo se pueden utilizar Duration y Period junto con las clases temporales para gestionar reservas, calcular duraciones de estancia y determinar precios en un sistema hotelero.

Formateo y parsing con DateTimeFormatter

Cuando se trabaja con fechas y horas en aplicaciones Java, es fundamental poder convertir estos valores entre objetos temporales y representaciones de texto legibles. La API java.time proporciona la clase DateTimeFormatter para realizar estas operaciones de manera flexible y robusta, permitiendo personalizar cómo se muestran y se interpretan las fechas y horas.

Conceptos básicos de DateTimeFormatter

DateTimeFormatter es una clase inmutable y thread-safe que define cómo se formatean y analizan los valores de fecha y hora. Se puede utilizar para convertir objetos temporales como LocalDate, LocalTime y LocalDateTime en cadenas de texto y viceversa.

Para empezar a utilizar esta clase, se puede recurrir a los formateadores predefinidos:

// Formateadores predefinidos
DateTimeFormatter formatoBasico = DateTimeFormatter.ISO_LOCAL_DATE;
DateTimeFormatter formatoHora = DateTimeFormatter.ISO_LOCAL_TIME;
DateTimeFormatter formatoCompleto = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

// Aplicando los formateadores
LocalDate fecha = LocalDate.now();
String fechaTexto = fecha.format(formatoBasico);  // Ejemplo: "2023-11-15"

LocalTime hora = LocalTime.now();
String horaTexto = hora.format(formatoHora);      // Ejemplo: "14:30:45.123"

LocalDateTime fechaHora = LocalDateTime.now();
String fechaHoraTexto = fechaHora.format(formatoCompleto);  // Ejemplo: "2023-11-15T14:30:45.123"

Creación de formateadores personalizados

Aunque los formateadores predefinidos son útiles, a menudo se necesita personalizar el formato según requisitos específicos. Para esto, se utiliza el método ofPattern():

// Formateadores personalizados con patrones
DateTimeFormatter formatoFechaPersonalizado = DateTimeFormatter.ofPattern("dd/MM/yyyy");
DateTimeFormatter formatoHoraPersonalizado = DateTimeFormatter.ofPattern("HH:mm");
DateTimeFormatter formatoCompleto = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");

// Aplicando los formateadores personalizados
LocalDate fecha = LocalDate.of(2023, 11, 15);
String fechaFormateada = fecha.format(formatoFechaPersonalizado);  // "15/11/2023"

LocalTime hora = LocalTime.of(14, 30);
String horaFormateada = hora.format(formatoHoraPersonalizado);     // "14:30"

LocalDateTime fechaHora = LocalDateTime.of(2023, 11, 15, 14, 30, 45);
String fechaHoraFormateada = fechaHora.format(formatoCompleto);    // "15/11/2023 14:30:45"

Patrones de formato comunes

Los patrones de formato se componen de letras de símbolo que representan diferentes componentes de fecha y hora. Algunos de los símbolos más utilizados son:

• y: Año (yy: 23, yyyy: 2023)
• M: Mes (M: 1, MM: 01, MMM: Ene, MMMM: Enero)
• d: Día del mes (d: 1, dd: 01)
• E: Día de la semana (E: Lun, EEEE: Lunes)
• H: Hora en formato 24h (H: 9, HH: 09)
• h: Hora en formato 12h (h: 9, hh: 09)
• m: Minutos (m: 5, mm: 05)
• s: Segundos (s: 5, ss: 05)
• a: Marcador AM/PM

Ejemplos de patrones comunes:

// Diferentes patrones para diferentes necesidades
DateTimeFormatter formatoFechaCorta = DateTimeFormatter.ofPattern("d/M/yy");
DateTimeFormatter formatoFechaLarga = DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'de' yyyy");
DateTimeFormatter formatoHora12h = DateTimeFormatter.ofPattern("h:mm a");
DateTimeFormatter formatoPersonalizado = DateTimeFormatter.ofPattern("yyyy-MM-dd (HH:mm)");

LocalDate fecha = LocalDate.of(2023, 11, 15);
LocalTime hora = LocalTime.of(14, 30);
LocalDateTime fechaHora = LocalDateTime.of(fecha, hora);

System.out.println(fecha.format(formatoFechaCorta));      // "15/11/23"
System.out.println(fecha.format(formatoFechaLarga));      // "miércoles, 15 de noviembre de 2023"
System.out.println(hora.format(formatoHora12h));          // "2:30 PM"
System.out.println(fechaHora.format(formatoPersonalizado)); // "2023-11-15 (14:30)"

Localización de formatos

Para adaptar los formatos a diferentes idiomas y convenciones regionales, se puede utilizar la localización:

// Formateadores con localización
DateTimeFormatter formatoEspañol = DateTimeFormatter
    .ofPattern("EEEE, d 'de' MMMM 'de' yyyy")
    .withLocale(new Locale("es", "ES"));

DateTimeFormatter formatoFrancés = DateTimeFormatter
    .ofPattern("EEEE d MMMM yyyy")
    .withLocale(Locale.FRANCE);

LocalDate fecha = LocalDate.of(2023, 11, 15);

System.out.println(fecha.format(formatoEspañol));  // "miércoles, 15 de noviembre de 2023"
System.out.println(fecha.format(formatoFrancés));  // "mercredi 15 novembre 2023"

Estilos predefinidos

Además de los patrones personalizados, DateTimeFormatter ofrece estilos predefinidos que se adaptan automáticamente a la localización:

// Formateadores con estilos predefinidos
DateTimeFormatter formatoFechaCorta = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT);
DateTimeFormatter formatoFechaMedia = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
DateTimeFormatter formatoFechaLarga = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG);
DateTimeFormatter formatoFechaCompleta = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);

LocalDate fecha = LocalDate.of(2023, 11, 15);

// Ejemplos con localización española
Locale localeEspañol = new Locale("es", "ES");
System.out.println(fecha.format(formatoFechaCorta.withLocale(localeEspañol)));   // "15/11/23"
System.out.println(fecha.format(formatoFechaMedia.withLocale(localeEspañol)));   // "15 nov 2023"
System.out.println(fecha.format(formatoFechaLarga.withLocale(localeEspañol)));   // "15 de noviembre de 2023"
System.out.println(fecha.format(formatoFechaCompleta.withLocale(localeEspañol))); // "miércoles, 15 de noviembre de 2023"

También existen formateadores para hora y fecha-hora:

// Formateadores de hora y fecha-hora con estilos
DateTimeFormatter formatoHoraCorta = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT);
DateTimeFormatter formatoFechaHoraMedia = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);

LocalTime hora = LocalTime.of(14, 30);
LocalDateTime fechaHora = LocalDateTime.of(2023, 11, 15, 14, 30);

System.out.println(hora.format(formatoHoraCorta));           // "14:30"
System.out.println(fechaHora.format(formatoFechaHoraMedia)); // "15 nov 2023 14:30:00"

Parsing (análisis) de fechas y horas

El proceso inverso al formateo es el parsing, que consiste en convertir cadenas de texto en objetos temporales. Se utiliza el mismo DateTimeFormatter para ambas operaciones:

// Parsing básico con formateadores
DateTimeFormatter formato = DateTimeFormatter.ofPattern("dd/MM/yyyy");

// Convertir String a LocalDate
String textoFecha = "15/11/2023";
LocalDate fecha = LocalDate.parse(textoFecha, formato);

// Convertir String a LocalTime
DateTimeFormatter formatoHora = DateTimeFormatter.ofPattern("HH:mm");
String textoHora = "14:30";
LocalTime hora = LocalTime.parse(textoHora, formatoHora);

// Convertir String a LocalDateTime
DateTimeFormatter formatoCompleto = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
String textoFechaHora = "15/11/2023 14:30";
LocalDateTime fechaHora = LocalDateTime.parse(textoFechaHora, formatoCompleto);

Manejo de errores en el parsing

El parsing puede fallar si la cadena de texto no coincide con el formato esperado. Es importante manejar estas excepciones adecuadamente:

try {
    String textoInvalido = "2023/15/11"; // Formato incorrecto (año/día/mes)
    DateTimeFormatter formato = DateTimeFormatter.ofPattern("dd/MM/yyyy");
    LocalDate fecha = LocalDate.parse(textoInvalido, formato);
} catch (DateTimeParseException e) {
    System.err.println("Error al analizar la fecha: " + e.getMessage());
    // Manejar el error apropiadamente
}

Personalización avanzada de formateadores

Para casos más complejos, se puede construir un formateador utilizando DateTimeFormatterBuilder:

// Formateador avanzado con DateTimeFormatterBuilder
DateTimeFormatter formateadorComplejo = new DateTimeFormatterBuilder()
    .appendText(ChronoField.DAY_OF_WEEK)
    .appendLiteral(", ")
    .appendValue(ChronoField.DAY_OF_MONTH)
    .appendLiteral(" de ")
    .appendText(ChronoField.MONTH_OF_YEAR)
    .appendLiteral(" de ")
    .appendValue(ChronoField.YEAR)
    .appendLiteral(" a las ")
    .appendValue(ChronoField.HOUR_OF_DAY)
    .appendLiteral(":")
    .appendValue(ChronoField.MINUTE_OF_HOUR, 2)
    .toFormatter(new Locale("es", "ES"));

LocalDateTime fechaHora = LocalDateTime.of(2023, 11, 15, 14, 30);
String resultado = fechaHora.format(formateadorComplejo);
// "miércoles, 15 de noviembre de 2023 a las 14:30"

Ejemplo práctico: sistema de registro de eventos

Veamos un ejemplo completo que utiliza DateTimeFormatter para gestionar fechas y horas en un sistema de registro de eventos:

public class SistemaEventos {
    // Formateadores para diferentes propósitos
    private static final DateTimeFormatter FORMATO_FECHA = DateTimeFormatter.ofPattern("dd/MM/yyyy");
    private static final DateTimeFormatter FORMATO_HORA = DateTimeFormatter.ofPattern("HH:mm");
    private static final DateTimeFormatter FORMATO_COMPLETO = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");
    private static final DateTimeFormatter FORMATO_VISUALIZACION = 
        DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'de' yyyy 'a las' HH:mm")
                         .withLocale(new Locale("es", "ES"));
    
    public static void main(String[] args) {
        // Registro de un nuevo evento
        try {
            String fechaTexto = "20/12/2023";
            String horaTexto = "18:30";
            
            // Parsing de la fecha y hora
            LocalDate fecha = LocalDate.parse(fechaTexto, FORMATO_FECHA);
            LocalTime hora = LocalTime.parse(horaTexto, FORMATO_HORA);
            LocalDateTime fechaHoraEvento = LocalDateTime.of(fecha, hora);
            
            // Registro del evento
            registrarEvento("Conferencia de Java", fechaHoraEvento);
            
            // Mostrar detalles del evento
            mostrarDetallesEvento("Conferencia de Java", fechaHoraEvento);
            
            // Verificar si el evento está próximo
            verificarProximidad(fechaHoraEvento);
            
        } catch (DateTimeParseException e) {
            System.err.println("Error en el formato de fecha u hora: " + e.getMessage());
        }
    }
    
    private static void registrarEvento(String nombre, LocalDateTime fechaHora) {
        System.out.println("Evento registrado: " + nombre);
        System.out.println("Fecha y hora: " + fechaHora.format(FORMATO_COMPLETO));
        System.out.println("Registro completado a las: " + 
                          LocalDateTime.now().format(FORMATO_COMPLETO));
    }
    
    private static void mostrarDetallesEvento(String nombre, LocalDateTime fechaHora) {
        System.out.println("\nDetalles del evento:");
        System.out.println("Nombre: " + nombre);
        System.out.println("Se celebrará el: " + fechaHora.format(FORMATO_VISUALIZACION));
        
        // Calcular tiempo restante
        Period periodoHasta = Period.between(LocalDate.now(), fechaHora.toLocalDate());
        long diasHasta = ChronoUnit.DAYS.between(LocalDate.now(), fechaHora.toLocalDate());
        
        System.out.println("Faltan: " + periodoHasta.getMonths() + " meses y " + 
                          periodoHasta.getDays() + " días (" + diasHasta + " días en total)");
    }
    
    private static void verificarProximidad(LocalDateTime fechaHora) {
        LocalDateTime ahora = LocalDateTime.now();
        LocalDateTime limiteCercano = ahora.plusDays(7); // Próximos 7 días
        
        if (fechaHora.isBefore(ahora)) {
            System.out.println("\nEl evento ya ha pasado.");
        } else if (fechaHora.isBefore(limiteCercano)) {
            System.out.println("\n¡ATENCIÓN! El evento está próximo a celebrarse.");
            long horasHasta = ChronoUnit.HOURS.between(ahora, fechaHora);
            System.out.println("Faltan aproximadamente " + horasHasta + " horas.");
        } else {
            System.out.println("\nEl evento se celebrará en el futuro.");
        }
    }
}

Este ejemplo muestra cómo utilizar diferentes formateadores para distintos propósitos en un sistema de gestión de eventos: uno para entrada de datos, otro para visualización en pantalla y otro para registro interno.

Buenas prácticas con DateTimeFormatter

Para utilizar DateTimeFormatter de manera efectiva, se recomienda seguir estas prácticas:

• Definir formateadores como constantes: Mejora el rendimiento y la consistencia.
• Usar patrones claros y explícitos: Facilita la comprensión y el mantenimiento.
• Considerar la localización: Adaptar los formatos según el idioma y región del usuario.
• Manejar excepciones de parsing: Proporcionar mensajes de error claros cuando el formato no coincide.
• Documentar los formatos esperados: Especialmente en interfaces de usuario o APIs.

// Ejemplo de buenas prácticas
public class GestorFechas {
    // Formateadores definidos como constantes
    private static final DateTimeFormatter FORMATO_ENTRADA = 
        DateTimeFormatter.ofPattern("dd/MM/yyyy");
    
    private static final DateTimeFormatter FORMATO_SALIDA = 
        DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'de' yyyy")
                         .withLocale(new Locale("es", "ES"));
    
    public LocalDate convertirFecha(String textoFecha) {
        try {
            return LocalDate.parse(textoFecha, FORMATO_ENTRADA);
        } catch (DateTimeParseException e) {
            throw new IllegalArgumentException(
                "Formato de fecha inválido. Use dd/MM/yyyy (ejemplo: 15/11/2023)", e);
        }
    }
    
    public String formatearFecha(LocalDate fecha) {
        return fecha.format(FORMATO_SALIDA);
    }
}

Zonas horarias y conversiones

La gestión de zonas horarias es un aspecto fundamental cuando se desarrollan aplicaciones que operan a nivel global o que necesitan coordinar eventos entre diferentes regiones geográficas. La API java.time proporciona un conjunto de clases robustas para trabajar con zonas horarias y realizar conversiones temporales de manera precisa y confiable.

Conceptos básicos de zonas horarias

Una zona horaria representa una región del mundo que utiliza el mismo tiempo estándar. Java modela este concepto a través de la clase ZoneId, que identifica una zona horaria específica:

// Obtener la zona horaria del sistema
ZoneId zonaLocal = ZoneId.systemDefault();
System.out.println("Zona horaria del sistema: " + zonaLocal);

// Crear una zona horaria específica por su ID
ZoneId madrid = ZoneId.of("Europe/Madrid");
ZoneId tokio = ZoneId.of("Asia/Tokyo");
ZoneId nuevaYork = ZoneId.of("America/New_York");

Se puede obtener una lista de todos los identificadores de zona horaria disponibles:

// Listar todas las zonas horarias disponibles
Set<String> zonasDisponibles = ZoneId.getAvailableZoneIds();
System.out.println("Número de zonas horarias: " + zonasDisponibles.size());

// Mostrar algunas zonas horarias de ejemplo
zonasDisponibles.stream()
    .filter(id -> id.startsWith("Europe"))
    .sorted()
    .limit(5)
    .forEach(System.out::println);

Clases con conciencia de zona horaria

La API java.time proporciona clases específicas que incorporan información de zona horaria:

• ZonedDateTime: Combina fecha, hora y zona horaria
• OffsetDateTime: Combina fecha, hora y desplazamiento respecto a UTC
• OffsetTime: Combina hora y desplazamiento respecto a UTC

ZonedDateTime

La clase ZonedDateTime es la más completa, ya que representa un momento específico en el tiempo con una zona horaria asociada:

// Crear ZonedDateTime para la fecha y hora actuales en la zona horaria del sistema
ZonedDateTime ahora = ZonedDateTime.now();

// Crear ZonedDateTime para una fecha y hora específicas en una zona horaria concreta
LocalDateTime fechaHora = LocalDateTime.of(2023, 12, 15, 10, 30);
ZonedDateTime reunionMadrid = ZonedDateTime.of(fechaHora, ZoneId.of("Europe/Madrid"));

// Crear a partir de un instante (tiempo desde epoch) y una zona horaria
Instant instante = Instant.now();
ZonedDateTime momentoTokio = ZonedDateTime.ofInstant(instante, ZoneId.of("Asia/Tokyo"));

Conversión entre zonas horarias

Una de las operaciones más comunes es convertir un momento temporal de una zona horaria a otra:

// Crear un momento en Madrid
ZonedDateTime reunionMadrid = ZonedDateTime.of(
    LocalDateTime.of(2023, 12, 15, 10, 0), 
    ZoneId.of("Europe/Madrid")
);

// Convertir a otras zonas horarias
ZonedDateTime reunionNY = reunionMadrid.withZoneSameInstant(ZoneId.of("America/New_York"));
ZonedDateTime reunionTokio = reunionMadrid.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));

System.out.println("Reunión en Madrid: " + reunionMadrid);
System.out.println("Mismo instante en Nueva York: " + reunionNY);
System.out.println("Mismo instante en Tokio: " + reunionTokio);

Es importante entender la diferencia entre withZoneSameInstant() y withZoneSameLocal():

// withZoneSameInstant: mantiene el mismo instante (ajusta la hora)
ZonedDateTime madridInstante = reunionMadrid.withZoneSameInstant(ZoneId.of("America/New_York"));
// Ejemplo: 10:00 Madrid -> 04:00 Nueva York (mismo momento, diferente hora local)

// withZoneSameLocal: mantiene la misma hora local (cambia el instante)
ZonedDateTime madridLocal = reunionMadrid.withZoneSameLocal(ZoneId.of("America/New_York"));
// Ejemplo: 10:00 Madrid -> 10:00 Nueva York (diferente momento, misma hora local)

Trabajando con Instant

La clase Instant representa un punto específico en la línea de tiempo, independiente de cualquier zona horaria. Es útil para registrar marcas de tiempo precisas:

// Obtener el instante actual
Instant ahora = Instant.now();

// Crear un instante a partir de segundos desde epoch (1 de enero de 1970 UTC)
Instant momento = Instant.ofEpochSecond(1700000000);

// Convertir un instante a ZonedDateTime
ZonedDateTime momentoMadrid = momento.atZone(ZoneId.of("Europe/Madrid"));

// Convertir ZonedDateTime a Instant
Instant instanteDesdeZoned = momentoMadrid.toInstant();

La clase Instant es útil para:

• Almacenar marcas de tiempo en bases de datos
• Medir intervalos de tiempo con precisión
• Coordinar eventos entre sistemas distribuidos

// Medir el tiempo de ejecución de una operación
Instant inicio = Instant.now();

// Simulación de una operación que toma tiempo
try {
    Thread.sleep(1500);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

Instant fin = Instant.now();
Duration duracion = Duration.between(inicio, fin);
System.out.println("La operación tomó: " + duracion.toMillis() + " ms");

OffsetDateTime y OffsetTime

Estas clases representan fechas y horas con un desplazamiento respecto a UTC, sin información completa de zona horaria:

// Crear OffsetDateTime con el desplazamiento actual
OffsetDateTime ahora = OffsetDateTime.now();

// Crear con un desplazamiento específico
OffsetDateTime momento = OffsetDateTime.of(
    LocalDateTime.of(2023, 12, 15, 10, 0),
    ZoneOffset.ofHours(2)  // UTC+2
);

// OffsetTime para representar solo la hora con desplazamiento
OffsetTime hora = OffsetTime.of(
    LocalTime.of(10, 0),
    ZoneOffset.ofHours(-5)  // UTC-5
);

OffsetDateTime es útil cuando se necesita precisión temporal sin las reglas complejas de las zonas horarias (como cambios por horario de verano):

// Convertir entre OffsetDateTime y ZonedDateTime
OffsetDateTime odt = OffsetDateTime.now();
ZonedDateTime zdt = odt.atZoneSameInstant(ZoneId.of("Europe/Madrid"));

// Y viceversa
OffsetDateTime odtDeVuelta = zdt.toOffsetDateTime();

Manejo del horario de verano (DST)

Uno de los aspectos más complejos de las zonas horarias es el cambio de horario de verano. La API java.time maneja estos cambios automáticamente:

// Crear fechas antes y después del cambio de horario en Europa
ZonedDateTime antesCambio = ZonedDateTime.of(
    LocalDateTime.of(2023, 3, 26, 1, 30),
    ZoneId.of("Europe/Madrid")
);

ZonedDateTime despuesCambio = antesCambio.plusHours(1);

System.out.println("Antes del cambio: " + antesCambio);
System.out.println("Después del cambio: " + despuesCambio);
System.out.println("Diferencia en horas: " + 
    ChronoUnit.HOURS.between(antesCambio, despuesCambio));

Al trabajar con horarios de verano, se debe tener cuidado con:

• Horas ambiguas: Cuando se retrocede el reloj, una hora puede ocurrir dos veces
• Horas inexistentes: Cuando se adelanta el reloj, hay horas que no existen

// Intentar crear un momento en una hora inexistente (durante el salto adelante)
try {
    ZonedDateTime horaInexistente = ZonedDateTime.of(
        LocalDateTime.of(2023, 3, 26, 2, 30),  // Esta hora no existe en Madrid ese día
        ZoneId.of("Europe/Madrid")
    );
} catch (Exception e) {
    System.out.println("Error: " + e.getMessage());
    // Java ajustará automáticamente a la hora válida más cercana
}

Cálculos con zonas horarias

Al realizar cálculos temporales con zonas horarias, es importante considerar cómo afectan los cambios de horario:

// Añadir un día a una fecha cerca del cambio de horario
ZonedDateTime antesDelCambio = ZonedDateTime.of(
    LocalDateTime.of(2023, 10, 28, 12, 0),
    ZoneId.of("Europe/Madrid")
);

ZonedDateTime unDiaDespues = antesDelCambio.plusDays(1);

// Verificar la diferencia real en horas
long horasReales = ChronoUnit.HOURS.between(antesDelCambio, unDiaDespues);
System.out.println("Horas entre las fechas: " + horasReales);  // 25 horas debido al cambio

Ejemplo práctico: sistema de programación de reuniones internacionales

Veamos un ejemplo completo que utiliza zonas horarias para coordinar reuniones entre participantes de diferentes países:

public class ProgramadorReuniones {
    public static void main(String[] args) {
        // Definir zonas horarias de los participantes
        ZoneId zonaMadrid = ZoneId.of("Europe/Madrid");
        ZoneId zonaNuevaYork = ZoneId.of("America/New_York");
        ZoneId zonaTokio = ZoneId.of("Asia/Tokyo");
        
        // Programar una reunión en Madrid a las 10:00
        LocalDateTime fechaHoraLocal = LocalDateTime.of(2023, 12, 15, 10, 0);
        ZonedDateTime reunionMadrid = ZonedDateTime.of(fechaHoraLocal, zonaMadrid);
        
        // Convertir a las zonas horarias de los otros participantes
        ZonedDateTime reunionNY = reunionMadrid.withZoneSameInstant(zonaNuevaYork);
        ZonedDateTime reunionTokio = reunionMadrid.withZoneSameInstant(zonaTokio);
        
        // Formatear para mostrar de manera amigable
        DateTimeFormatter formato = DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'a las' HH:mm (z)");
        
        System.out.println("Detalles de la reunión internacional:");
        System.out.println("Madrid: " + reunionMadrid.format(formato));
        System.out.println("Nueva York: " + reunionNY.format(formato));
        System.out.println("Tokio: " + reunionTokio.format(formato));
        
        // Verificar si es horario laboral para todos (9:00-18:00)
        System.out.println("\nVerificación de horario laboral:");
        verificarHorarioLaboral("Madrid", reunionMadrid);
        verificarHorarioLaboral("Nueva York", reunionNY);
        verificarHorarioLaboral("Tokio", reunionTokio);
        
        // Sugerir horarios alternativos si es necesario
        if (!esHorarioLaboral(reunionNY) || !esHorarioLaboral(reunionTokio)) {
            System.out.println("\nSugerencias de horarios alternativos:");
            sugerirHorariosAlternativos(zonaMadrid, zonaNuevaYork, zonaTokio);
        }
    }
    
    private static void verificarHorarioLaboral(String ubicacion, ZonedDateTime momento) {
        boolean esLaboral = esHorarioLaboral(momento);
        System.out.println(ubicacion + ": " + (esLaboral ? 
            "Dentro del horario laboral" : 
            "Fuera del horario laboral"));
    }
    
    private static boolean esHorarioLaboral(ZonedDateTime momento) {
        int hora = momento.getHour();
        return hora >= 9 && hora < 18;
    }
    
    private static void sugerirHorariosAlternativos(ZoneId zona1, ZoneId zona2, ZoneId zona3) {
        // Buscar un horario que funcione para todos
        LocalDate fechaBase = LocalDate.now().plusDays(1);
        
        // Probar diferentes horas en la primera zona
        for (int hora = 9; hora < 16; hora++) {
            LocalDateTime propuesta = LocalDateTime.of(fechaBase, LocalTime.of(hora, 0));
            ZonedDateTime momento1 = ZonedDateTime.of(propuesta, zona1);
            ZonedDateTime momento2 = momento1.withZoneSameInstant(zona2);
            ZonedDateTime momento3 = momento1.withZoneSameInstant(zona3);
            
            if (esHorarioLaboral(momento1) && esHorarioLaboral(momento2) && esHorarioLaboral(momento3)) {
                DateTimeFormatter formato = DateTimeFormatter.ofPattern("HH:mm (z)");
                System.out.println("Propuesta: " + propuesta.toLocalTime());
                System.out.println("  - " + zona1 + ": " + momento1.format(formato));
                System.out.println("  - " + zona2 + ": " + momento2.format(formato));
                System.out.println("  - " + zona3 + ": " + momento3.format(formato));
                return;  // Encontramos una buena opción
            }
        }
        
        System.out.println("No se encontró un horario que funcione para todos.");
    }
}

Integración con bases de datos y APIs

Al trabajar con bases de datos o APIs externas, es importante entender cómo se almacenan y transmiten los datos temporales:

// Almacenar en base de datos (normalmente se usa UTC)
ZonedDateTime eventoLocal = ZonedDateTime.now();
Instant instanteUTC = eventoLocal.toInstant();
long timestampMilis = instanteUTC.toEpochMilli();

// Recuperar de base de datos
Instant instanteRecuperado = Instant.ofEpochMilli(timestampMilis);
ZonedDateTime eventoRecuperado = instanteRecuperado.atZone(ZoneId.systemDefault());

Para APIs REST, se suele utilizar el formato ISO-8601 con información de zona horaria:

// Serializar para API
ZonedDateTime evento = ZonedDateTime.now();
String isoDateTime = evento.format(DateTimeFormatter.ISO_ZONED_DATE_TIME);
// Ejemplo: "2023-11-15T14:30:45.123+01:00[Europe/Madrid]"

// Deserializar desde API
ZonedDateTime eventoRecibido = ZonedDateTime.parse(isoDateTime);

Consideraciones sobre rendimiento y memoria

Al trabajar con zonas horarias, se debe tener en cuenta:

• Las operaciones con zonas horarias son más costosas que las operaciones sin zona horaria
• La información de zonas horarias ocupa más memoria
• Para operaciones masivas, puede ser más eficiente trabajar con Instant y convertir a zona horaria solo cuando sea necesario

// Enfoque eficiente para procesamiento masivo
List<Instant> momentos = obtenerMomentos();  // Lista de instantes UTC

// Procesar en UTC para mayor eficiencia
momentos.stream()
    .filter(instant -> instant.isAfter(Instant.now().minus(1, ChronoUnit.DAYS)))
    .sorted()
    .forEach(instant -> {
        // Convertir a zona horaria solo para visualización
        ZonedDateTime local = instant.atZone(ZoneId.systemDefault());
        System.out.println(local.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    });

Buenas prácticas para trabajar con zonas horarias

Para manejar zonas horarias de manera efectiva, se recomienda:

• Almacenar en UTC: Guardar fechas y horas en UTC en bases de datos y sistemas de persistencia
• Convertir en la capa de presentación: Transformar a la zona horaria del usuario solo al mostrar la información
• Ser explícito: Especificar siempre la zona horaria al crear objetos temporales
• Usar Instant para timestamps: Para marcas de tiempo precisas y comparaciones
• Considerar el contexto cultural: Adaptar formatos de visualización según la región del usuario

// Ejemplo de buenas prácticas
public class GestorEventos {
    // Almacenar en UTC
    private final Map<String, Instant> eventos = new HashMap<>();
    
    public void programarEvento(String nombre, LocalDateTime fechaHoraLocal, ZoneId zonaUsuario) {
        // Convertir a UTC para almacenamiento
        ZonedDateTime fechaHoraZona = ZonedDateTime.of(fechaHoraLocal, zonaUsuario);
        Instant momentoUTC = fechaHoraZona.toInstant();
        eventos.put(nombre, momentoUTC);
    }
    
    public String obtenerDetallesEvento(String nombre, ZoneId zonaUsuario) {
        Instant momentoUTC = eventos.get(nombre);
        if (momentoUTC == null) {
            return "Evento no encontrado";
        }
        
        // Convertir a la zona horaria del usuario para visualización
        ZonedDateTime fechaHoraLocal = momentoUTC.atZone(zonaUsuario);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm (z)")
                                                      .withLocale(Locale.getDefault());
        
        return "Evento: " + nombre + " - Fecha: " + fechaHoraLocal.format(formatter);
    }
}