Java

Tutorial Java: LocalDateTime

Aprende a usar LocalDateTime en Java para crear, manipular y formatear fechas y horas con precisión y seguridad en tus aplicaciones.

Aprende Java y certifícate

Conceptos básicos y creación de objetos LocalDateTime

La clase LocalDateTime forma parte del paquete java.time introducido en Java 8, y representa una fecha con hora sin referencia a una zona horaria específica. Esta clase combina la funcionalidad de LocalDate (fecha) y LocalTime (hora) en un único objeto, permitiéndonos trabajar con puntos específicos en el tiempo con precisión de nanosegundos.

LocalDateTime es inmutable y thread-safe, lo que significa que una vez creado un objeto, no puede modificarse. Cualquier operación que parezca modificar un LocalDateTime en realidad devuelve una nueva instancia con los cambios aplicados, manteniendo el objeto original intacto.

Creación de objetos LocalDateTime

Existen varias formas de crear instancias de LocalDateTime, dependiendo de nuestras necesidades:

  • Obtener la fecha y hora actual:
// Obtiene la fecha y hora actual del sistema
LocalDateTime ahora = LocalDateTime.now();
System.out.println("Fecha y hora actual: " + ahora);
  • Crear a partir de valores específicos:
// Crear a partir de año, mes, día, hora, minutos
LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);
System.out.println("Fecha y hora específica: " + fechaHora);

// Con segundos y nanosegundos
LocalDateTime fechaHoraPrecisa = LocalDateTime.of(2023, 10, 15, 14, 30, 45, 500000000);
System.out.println("Con precisión de nanosegundos: " + fechaHoraPrecisa);
  • Usando constantes de Month:
// Usando la enumeración Month para mayor legibilidad
LocalDateTime navidad = LocalDateTime.of(2023, Month.DECEMBER, 25, 0, 0);
System.out.println("Navidad: " + navidad);
  • A partir de LocalDate y LocalTime:
// Combinando objetos LocalDate y LocalTime existentes
LocalDate fecha = LocalDate.of(2023, 10, 15);
LocalTime hora = LocalTime.of(14, 30);
LocalDateTime fechaHoraCombinada = LocalDateTime.of(fecha, hora);
System.out.println("Combinando fecha y hora: " + fechaHoraCombinada);
  • Desde un texto (parsing):
// Crear desde una cadena de texto con formato ISO
LocalDateTime fechaHoraTexto = LocalDateTime.parse("2023-10-15T14:30:00");
System.out.println("Desde texto ISO: " + fechaHoraTexto);

Obtención de componentes

Podemos extraer los diferentes componentes de un objeto LocalDateTime mediante métodos getter:

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

// Obtener componentes individuales
int año = fechaHora.getYear();           // 2023
int mes = fechaHora.getMonthValue();     // 10
Month mesEnum = fechaHora.getMonth();    // OCTOBER
int dia = fechaHora.getDayOfMonth();     // 15
DayOfWeek diaSemana = fechaHora.getDayOfWeek();  // SUNDAY
int hora = fechaHora.getHour();          // 14
int minutos = fechaHora.getMinute();     // 30
int segundos = fechaHora.getSecond();    // 45

System.out.println("Año: " + año);
System.out.println("Mes (número): " + mes);
System.out.println("Mes (enum): " + mesEnum);
System.out.println("Día del mes: " + dia);
System.out.println("Día de la semana: " + diaSemana);
System.out.println("Hora: " + hora);
System.out.println("Minutos: " + minutos);
System.out.println("Segundos: " + segundos);

Métodos de conversión básicos

LocalDateTime proporciona métodos para convertir entre diferentes representaciones temporales:

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

// Convertir a LocalDate (solo fecha)
LocalDate soloFecha = fechaHora.toLocalDate();
System.out.println("Solo fecha: " + soloFecha);

// Convertir a LocalTime (solo hora)
LocalTime soloHora = fechaHora.toLocalTime();
System.out.println("Solo hora: " + soloHora);

Comparación de objetos LocalDateTime

Para comparar objetos LocalDateTime, podemos usar los métodos de comparación incorporados:

LocalDateTime fechaHora1 = LocalDateTime.of(2023, 10, 15, 14, 30);
LocalDateTime fechaHora2 = LocalDateTime.of(2023, 11, 20, 10, 15);

// Comparaciones
boolean esAnterior = fechaHora1.isBefore(fechaHora2);  // true
boolean esPosterior = fechaHora1.isAfter(fechaHora2);  // false
boolean esIgual = fechaHora1.isEqual(fechaHora2);      // false

System.out.println("¿Fecha1 es anterior a Fecha2? " + esAnterior);
System.out.println("¿Fecha1 es posterior a Fecha2? " + esPosterior);
System.out.println("¿Son iguales? " + esIgual);

// También podemos usar compareTo (implementa Comparable)
int comparacion = fechaHora1.compareTo(fechaHora2);
System.out.println("Resultado de compareTo: " + comparacion); // Negativo si fechaHora1 < fechaHora2

Truncamiento de precisión

Podemos truncar un LocalDateTime a una unidad de tiempo específica:

LocalDateTime fechaHoraPrecisa = LocalDateTime.of(2023, 10, 15, 14, 30, 45, 123456789);

// Truncar a diferentes unidades de tiempo
LocalDateTime soloHoras = fechaHoraPrecisa.truncatedTo(ChronoUnit.HOURS);
LocalDateTime soloMinutos = fechaHoraPrecisa.truncatedTo(ChronoUnit.MINUTES);
LocalDateTime soloDias = fechaHoraPrecisa.truncatedTo(ChronoUnit.DAYS);

System.out.println("Original: " + fechaHoraPrecisa);
System.out.println("Truncado a horas: " + soloHoras);
System.out.println("Truncado a minutos: " + soloMinutos);
System.out.println("Truncado a días: " + soloDias);

Ejemplo práctico: Registro de eventos

Un caso de uso común para LocalDateTime es el registro de eventos en una aplicación:

public class EventoRegistro {
    private String descripcion;
    private LocalDateTime timestamp;
    
    public EventoRegistro(String descripcion) {
        this.descripcion = descripcion;
        this.timestamp = LocalDateTime.now(); // Captura el momento exacto
    }
    
    @Override
    public String toString() {
        return "[" + timestamp + "] " + descripcion;
    }
    
    public static void main(String[] args) {
        List<EventoRegistro> registros = new ArrayList<>();
        
        // Simulamos algunos eventos
        registros.add(new EventoRegistro("Inicio de sesión de usuario"));
        
        try {
            Thread.sleep(1500); // Simulamos el paso del tiempo
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        registros.add(new EventoRegistro("Consulta a base de datos"));
        
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        registros.add(new EventoRegistro("Cierre de sesión"));
        
        // Mostramos el registro de eventos
        System.out.println("REGISTRO DE EVENTOS:");
        for (EventoRegistro evento : registros) {
            System.out.println(evento);
        }
    }
}

Este ejemplo muestra cómo LocalDateTime puede utilizarse para registrar con precisión cuándo ocurren eventos en una aplicación, capturando automáticamente la fecha y hora actual en el momento de la creación del objeto.

Manipulación y conversión entre tipos de fecha-hora

La clase LocalDateTime ofrece un conjunto de métodos para manipular fechas y horas, así como para convertir entre diferentes tipos de representaciones temporales. Estas operaciones son fundamentales para el desarrollo de aplicaciones que requieren cálculos con fechas y horas.

Manipulación de objetos LocalDateTime

Una característica clave de LocalDateTime es su inmutabilidad, lo que significa que cada operación de manipulación devuelve una nueva instancia. Esto garantiza la seguridad en entornos concurrentes y evita efectos secundarios inesperados.

  • Adición y sustracción de unidades temporales:
LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);

// Añadir unidades de tiempo
LocalDateTime masDias = fechaHora.plusDays(5);
LocalDateTime masMeses = fechaHora.plusMonths(2);
LocalDateTime masHoras = fechaHora.plusHours(3);

System.out.println("Original: " + fechaHora);
System.out.println("Después de añadir 5 días: " + masDias);
System.out.println("Después de añadir 2 meses: " + masMeses);
System.out.println("Después de añadir 3 horas: " + masHoras);

// Restar unidades de tiempo
LocalDateTime menosDias = fechaHora.minusDays(10);
LocalDateTime menosMinutos = fechaHora.minusMinutes(45);

System.out.println("Después de restar 10 días: " + menosDias);
System.out.println("Después de restar 45 minutos: " + menosMinutos);
  • Uso de ChronoUnit para manipulaciones más flexibles:
import java.time.temporal.ChronoUnit;

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

// Manipulación con ChronoUnit
LocalDateTime masSemanas = fechaHora.plus(3, ChronoUnit.WEEKS);
LocalDateTime menosAnios = fechaHora.minus(1, ChronoUnit.YEARS);

System.out.println("Después de añadir 3 semanas: " + masSemanas);
System.out.println("Después de restar 1 año: " + menosAnios);
  • Modificación de componentes específicos:
LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);

// Cambiar componentes individuales
LocalDateTime nuevoAnio = fechaHora.withYear(2024);
LocalDateTime nuevoDia = fechaHora.withDayOfMonth(20);
LocalDateTime nuevaHora = fechaHora.withHour(9);

System.out.println("Con año cambiado: " + nuevoAnio);
System.out.println("Con día cambiado: " + nuevoDia);
System.out.println("Con hora cambiada: " + nuevaHora);

// Cambiar a un momento específico del día
LocalDateTime inicioDia = fechaHora.with(LocalTime.MIN); // 00:00:00
LocalDateTime finDia = fechaHora.with(LocalTime.MAX);    // 23:59:59.999999999

System.out.println("Inicio del día: " + inicioDia);
System.out.println("Fin del día: " + finDia);
  • Ajustadores temporales (TemporalAdjusters):
import java.time.temporal.TemporalAdjusters;

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

// Ajustar a días específicos
LocalDateTime primerDiaMes = fechaHora.with(TemporalAdjusters.firstDayOfMonth());
LocalDateTime ultimoDiaMes = fechaHora.with(TemporalAdjusters.lastDayOfMonth());
LocalDateTime proximoLunes = fechaHora.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
LocalDateTime ultimoJuevesMes = fechaHora.with(TemporalAdjusters.lastInMonth(DayOfWeek.THURSDAY));

System.out.println("Primer día del mes: " + primerDiaMes);
System.out.println("Último día del mes: " + ultimoDiaMes);
System.out.println("Próximo lunes: " + proximoLunes);
System.out.println("Último jueves del mes: " + ultimoJuevesMes);

Cálculo de períodos y duraciones

Para calcular la diferencia entre dos instantes de tiempo, Java ofrece las clases Period (para períodos basados en fecha) y Duration (para duraciones basadas en tiempo):

  • Cálculo de Period (años, meses, días):
LocalDateTime inicio = LocalDateTime.of(2022, 5, 10, 8, 0);
LocalDateTime fin = LocalDateTime.of(2023, 8, 20, 16, 30);

// Convertimos a LocalDate para calcular el Period
LocalDate fechaInicio = inicio.toLocalDate();
LocalDate fechaFin = fin.toLocalDate();

Period periodo = Period.between(fechaInicio, fechaFin);

System.out.println("Período entre fechas: " + 
                   periodo.getYears() + " años, " + 
                   periodo.getMonths() + " meses, " + 
                   periodo.getDays() + " días");
  • Cálculo de Duration (horas, minutos, segundos):
LocalDateTime inicio = LocalDateTime.of(2023, 10, 15, 8, 30);
LocalDateTime fin = LocalDateTime.of(2023, 10, 15, 14, 45);

Duration duracion = Duration.between(inicio, fin);

System.out.println("Duración en horas: " + duracion.toHours());
System.out.println("Duración en minutos: " + duracion.toMinutes());
System.out.println("Duración en segundos: " + duracion.getSeconds());
System.out.println("Duración en milisegundos: " + duracion.toMillis());
  • Cálculo de unidades específicas con ChronoUnit:
LocalDateTime inicio = LocalDateTime.of(2023, 1, 1, 0, 0);
LocalDateTime fin = LocalDateTime.of(2023, 12, 31, 23, 59);

long dias = ChronoUnit.DAYS.between(inicio, fin);
long horas = ChronoUnit.HOURS.between(inicio, fin);
long minutos = ChronoUnit.MINUTES.between(inicio, fin);

System.out.println("Días entre fechas: " + dias);
System.out.println("Horas entre fechas: " + horas);
System.out.println("Minutos entre fechas: " + minutos);

Conversión entre tipos de fecha-hora

Java ofrece varias formas de convertir entre los diferentes tipos de fecha y hora:

  • Conversión entre LocalDateTime y ZonedDateTime:
// De LocalDateTime a ZonedDateTime
LocalDateTime fechaHoraLocal = LocalDateTime.of(2023, 10, 15, 14, 30);
ZoneId zonaHoraria = ZoneId.of("Europe/Madrid");
ZonedDateTime fechaHoraZona = fechaHoraLocal.atZone(zonaHoraria);

System.out.println("LocalDateTime: " + fechaHoraLocal);
System.out.println("ZonedDateTime: " + fechaHoraZona);

// De ZonedDateTime a LocalDateTime
LocalDateTime convertidoALocal = fechaHoraZona.toLocalDateTime();
System.out.println("Convertido de nuevo a LocalDateTime: " + convertidoALocal);
  • Conversión a Instant (punto en el tiempo UTC):
LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);
ZoneId zonaHoraria = ZoneId.of("Europe/Madrid");

// LocalDateTime a Instant (requiere información de zona horaria)
Instant instante = fechaHora.atZone(zonaHoraria).toInstant();
System.out.println("Instant: " + instante);

// Instant a LocalDateTime (requiere información de zona horaria)
LocalDateTime convertido = LocalDateTime.ofInstant(instante, zonaHoraria);
System.out.println("Convertido de nuevo a LocalDateTime: " + convertido);
  • Conversión a OffsetDateTime (con desplazamiento horario):
LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);
ZoneOffset offset = ZoneOffset.of("+02:00");

// LocalDateTime a OffsetDateTime
OffsetDateTime fechaHoraOffset = fechaHora.atOffset(offset);
System.out.println("OffsetDateTime: " + fechaHoraOffset);

// OffsetDateTime a LocalDateTime
LocalDateTime convertido = fechaHoraOffset.toLocalDateTime();
System.out.println("Convertido de nuevo a LocalDateTime: " + convertido);
  • Conversión entre tipos antiguos y nuevos de fecha-hora:
// De java.util.Date a LocalDateTime
Date fechaAntigua = new Date();
Instant instante = fechaAntigua.toInstant();
LocalDateTime fechaNueva = LocalDateTime.ofInstant(instante, ZoneId.systemDefault());
System.out.println("De Date a LocalDateTime: " + fechaNueva);

// De LocalDateTime a java.util.Date
LocalDateTime ahora = LocalDateTime.now();
Instant instanteAhora = ahora.atZone(ZoneId.systemDefault()).toInstant();
Date fechaAntiguaConvertida = Date.from(instanteAhora);
System.out.println("De LocalDateTime a Date: " + fechaAntiguaConvertida);

Ejemplo práctico: Planificador de eventos

Este ejemplo muestra cómo utilizar las capacidades de manipulación y conversión de LocalDateTime en un planificador de eventos:

public class PlanificadorEventos {
    public static void main(String[] args) {
        // Crear un evento que comienza ahora
        LocalDateTime inicio = LocalDateTime.now();
        
        // La duración del evento es de 2 horas
        LocalDateTime fin = inicio.plusHours(2);
        
        // Mostrar detalles del evento
        System.out.println("Evento programado:");
        System.out.println("Inicio: " + inicio);
        System.out.println("Fin: " + fin);
        
        // Calcular la duración
        Duration duracion = Duration.between(inicio, fin);
        System.out.println("Duración: " + duracion.toMinutes() + " minutos");
        
        // Programar una notificación 30 minutos antes
        LocalDateTime notificacion = inicio.minusMinutes(30);
        System.out.println("Notificación programada para: " + notificacion);
        
        // Verificar si el evento ya ha comenzado
        boolean yaComenzo = LocalDateTime.now().isAfter(inicio);
        System.out.println("¿El evento ya comenzó? " + yaComenzo);
        
        // Programar el mismo evento para la próxima semana
        LocalDateTime proximaSemana = inicio.plusWeeks(1);
        System.out.println("Mismo evento la próxima semana: " + proximaSemana);
        
        // Convertir a diferentes zonas horarias para participantes internacionales
        ZoneId madrid = ZoneId.of("Europe/Madrid");
        ZoneId newYork = ZoneId.of("America/New_York");
        ZoneId tokyo = ZoneId.of("Asia/Tokyo");
        
        ZonedDateTime inicioMadrid = inicio.atZone(madrid);
        ZonedDateTime inicioNY = inicioMadrid.withZoneSameInstant(newYork);
        ZonedDateTime inicioTokyo = inicioMadrid.withZoneSameInstant(tokyo);
        
        System.out.println("\nHorarios internacionales:");
        System.out.println("Madrid: " + inicioMadrid);
        System.out.println("Nueva York: " + inicioNY);
        System.out.println("Tokyo: " + inicioTokyo);
    }
}

Este ejemplo demuestra cómo manipular objetos LocalDateTime para gestionar eventos, calcular duraciones, programar notificaciones y convertir entre zonas horarias para participantes internacionales.

Formateo

El formateo de fechas y horas es una operación fundamental cuando trabajamos con objetos LocalDateTime en Java. Nos permite convertir estos objetos en representaciones textuales legibles para los usuarios y, a la inversa, analizar textos para convertirlos en objetos LocalDateTime. Java proporciona un sistema de formateo flexible y potente a través de la clase DateTimeFormatter.

Formateo básico con DateTimeFormatter

La clase DateTimeFormatter es el componente principal para dar formato a las fechas y horas en Java. Ofrece varios formateadores predefinidos y también permite crear formatos personalizados:

LocalDateTime ahora = LocalDateTime.now();

// Usando formateadores predefinidos
String formatoISO = ahora.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
String formatoBasico = ahora.format(DateTimeFormatter.BASIC_ISO_DATE);

System.out.println("Formato ISO: " + formatoISO);         // 2023-10-15T14:30:45.123
System.out.println("Formato básico: " + formatoBasico);   // 20231015

Los formateadores predefinidos más comunes incluyen:

  • ISO_LOCAL_DATE_TIME: Formato estándar ISO (2023-10-15T14:30:45)
  • ISO_LOCAL_DATE: Solo la parte de fecha (2023-10-15)
  • ISO_LOCAL_TIME: Solo la parte de hora (14:30:45)
  • BASIC_ISO_DATE: Fecha compacta sin separadores (20231015)

Creación de formatos personalizados

Para casos donde necesitamos un formato específico, podemos crear nuestros propios patrones de formato:

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

// Crear formateadores personalizados
DateTimeFormatter formatoCompleto = DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'de' yyyy 'a las' HH:mm:ss");
DateTimeFormatter formatoCorto = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
DateTimeFormatter formatoPersonalizado = DateTimeFormatter.ofPattern("yyyy-MM-dd (HH:mm)");

// Aplicar los formatos
String textoCompleto = fechaHora.format(formatoCompleto);
String textoCorto = fechaHora.format(formatoCorto);
String textoPersonalizado = fechaHora.format(formatoPersonalizado);

System.out.println("Formato completo: " + textoCompleto);         // domingo, 15 de octubre de 2023 a las 14:30:45
System.out.println("Formato corto: " + textoCorto);               // 15/10/2023 14:30
System.out.println("Formato personalizado: " + textoPersonalizado); // 2023-10-15 (14:30)

Patrones de formato más utilizados

Los patrones de formato se construyen utilizando letras de patrón que representan diferentes componentes de fecha y hora:

  • Año: y (23), yy (23), yyyy (2023)
  • Mes: M (10), MM (10), MMM (oct.), MMMM (octubre)
  • Día del mes: d (5), dd (05)
  • Día de la semana: E (dom), EEEE (domingo)
  • Hora (0-23): H (14), HH (14)
  • Hora (1-12): h (2), hh (02)
  • AM/PM: a (PM)
  • Minutos: m (30), mm (30)
  • Segundos: s (45), ss (45)
  • Nanosegundos: n (123456789), nnnnnnnnn (123456789)
  • Milisegundos: S (1), SSS (123)

Ejemplo con varios patrones:

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

// Diferentes patrones de formato
String[] patrones = {
    "dd/MM/yyyy",                    // 05/10/2023
    "d 'de' MMMM 'de' yyyy",         // 5 de octubre de 2023
    "EEEE, d MMMM yyyy",             // jueves, 5 octubre 2023
    "HH:mm:ss",                       // 14:05:30
    "h:mm a",                         // 2:05 PM
    "yyyy-MM-dd'T'HH:mm:ss.SSS",      // 2023-10-05T14:05:30.123
    "hh:mm:ss.nnnnnnnnn a"            // 02:05:30.123456789 PM
};

for (String patron : patrones) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(patron);
    System.out.println(patron + " -> " + fechaHora.format(formatter));
}

Formateo con localización

Para adaptar el formato a diferentes idiomas y regiones, podemos especificar un Locale al crear el formateador:

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

// Crear formateadores con diferentes locales
DateTimeFormatter formateadorES = DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'de' yyyy", new Locale("es", "ES"));
DateTimeFormatter formateadorEN = DateTimeFormatter.ofPattern("EEEE, MMMM d, yyyy", Locale.US);
DateTimeFormatter formateadorFR = DateTimeFormatter.ofPattern("EEEE d MMMM yyyy", Locale.FRANCE);

// Aplicar los formatos
String textoES = fechaHora.format(formateadorES);
String textoEN = fechaHora.format(formateadorEN);
String textoFR = fechaHora.format(formateadorFR);

System.out.println("Español: " + textoES);   // Español: domingo, 15 de octubre de 2023
System.out.println("Inglés: " + textoEN);    // Inglés: Sunday, October 15, 2023
System.out.println("Francés: " + textoFR);   // Francés: dimanche 15 octobre 2023

Estilos de formato predefinidos

Java también ofrece estilos de formato predefinidos que se adaptan automáticamente al locale del sistema:

LocalDateTime fechaHora = LocalDateTime.of(2023, 10, 15, 14, 30);
Locale locale = new Locale("es", "ES");

// Formateadores con estilos predefinidos
DateTimeFormatter formatoCorto = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT).withLocale(locale);
DateTimeFormatter formatoMedio = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM).withLocale(locale);
DateTimeFormatter formatoLargo = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG).withLocale(locale);
DateTimeFormatter formatoCompleto = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).withLocale(locale);

// Aplicar los formatos
System.out.println("Formato CORTO: " + fechaHora.format(formatoCorto));       // 15/10/23 14:30
System.out.println("Formato MEDIO: " + fechaHora.format(formatoMedio));       // 15 oct 2023 14:30:00
System.out.println("Formato LARGO: " + fechaHora.format(formatoLargo));       // 15 de octubre de 2023, 14:30:00
System.out.println("Formato COMPLETO: " + fechaHora.format(formatoCompleto)); // domingo, 15 de octubre de 2023, 14:30:00 (hora estándar de Europa central)

También podemos formatear solo la fecha o solo la hora:

DateTimeFormatter formatoSoloFechaLarga = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG).withLocale(locale);
DateTimeFormatter formatoSoloHoraCorta = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale);

System.out.println("Solo fecha (LARGO): " + fechaHora.format(formatoSoloFechaLarga)); // 15 de octubre de 2023
System.out.println("Solo hora (CORTO): " + fechaHora.format(formatoSoloHoraCorta));   // 14:30

Análisis (parsing) de texto a LocalDateTime

El proceso inverso al formateo es el análisis o parsing, que convierte una cadena de texto en un objeto LocalDateTime:

// Parsing con formateador predefinido
String textoISO = "2023-10-15T14:30:45";
LocalDateTime fechaHoraISO = LocalDateTime.parse(textoISO); // Usa ISO_LOCAL_DATE_TIME por defecto
System.out.println("Parseado desde ISO: " + fechaHoraISO);

// Parsing con formateador personalizado
String textoPersonalizado = "15/10/2023 14:30";
DateTimeFormatter formateador = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
LocalDateTime fechaHoraPersonalizada = LocalDateTime.parse(textoPersonalizado, formateador);
System.out.println("Parseado desde formato personalizado: " + fechaHoraPersonalizada);

Manejo de errores en el parsing

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

try {
    String textoInvalido = "2023/10/15 14:30";
    DateTimeFormatter formateador = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
    LocalDateTime fechaHora = LocalDateTime.parse(textoInvalido, formateador);
    System.out.println("Fecha parseada: " + fechaHora);
} catch (DateTimeParseException e) {
    System.err.println("Error al parsear la fecha: " + e.getMessage());
    System.err.println("Formato esperado: dd/MM/yyyy HH:mm");
}

Formateo con zonas horarias

Aunque LocalDateTime no tiene información de zona horaria, podemos incluirla en el formato si primero convertimos a ZonedDateTime:

LocalDateTime fechaHoraLocal = LocalDateTime.of(2023, 10, 15, 14, 30);
ZoneId madrid = ZoneId.of("Europe/Madrid");
ZonedDateTime fechaHoraMadrid = fechaHoraLocal.atZone(madrid);

// Formatear incluyendo información de zona horaria
DateTimeFormatter formateadorZona = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss z");
String textoConZona = fechaHoraMadrid.format(formateadorZona);
System.out.println("Con zona horaria: " + textoConZona); // 15/10/2023 14:30:00 CEST

// Formato con offset numérico
DateTimeFormatter formateadorOffset = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss ZZZZ");
String textoConOffset = fechaHoraMadrid.format(formateadorOffset);
System.out.println("Con offset: " + textoConOffset); // 2023-10-15 14:30:00 GMT+02:00

Ejemplo práctico: Aplicación de reservas

Este ejemplo muestra cómo utilizar el formateo de fechas en una aplicación de reservas:

public class SistemaReservas {
    private static final DateTimeFormatter FORMATO_ENTRADA = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
    private static final DateTimeFormatter FORMATO_VISUALIZACION = DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'a las' HH:mm");
    private static final DateTimeFormatter FORMATO_SISTEMA = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    
    public static void main(String[] args) {
        // Simulamos entrada de usuario
        String fechaReservaTexto = "25/12/2023 20:30";
        
        try {
            // Convertimos la entrada a LocalDateTime
            LocalDateTime fechaReserva = LocalDateTime.parse(fechaReservaTexto, FORMATO_ENTRADA);
            
            // Validamos que la reserva sea en el futuro
            if (fechaReserva.isBefore(LocalDateTime.now())) {
                System.out.println("Error: La fecha de reserva debe ser futura");
                return;
            }
            
            // Almacenamos en formato ISO para la base de datos
            String fechaParaBaseDatos = fechaReserva.format(FORMATO_SISTEMA);
            
            // Mostramos confirmación al usuario en formato amigable
            String confirmacion = fechaReserva.format(FORMATO_VISUALIZACION);
            
            System.out.println("¡Reserva confirmada!");
            System.out.println("Su reserva está programada para el " + confirmacion);
            System.out.println("ID de reserva: RES-" + System.currentTimeMillis());
            System.out.println("(Datos almacenados: " + fechaParaBaseDatos + ")");
            
            // Calculamos recordatorio (1 día antes)
            LocalDateTime recordatorio = fechaReserva.minusDays(1);
            System.out.println("Le enviaremos un recordatorio el " + 
                              recordatorio.format(DateTimeFormatter.ofPattern("d 'de' MMMM 'a las' HH:mm")));
            
        } catch (DateTimeParseException e) {
            System.out.println("Error: Formato de fecha incorrecto. Use dd/MM/yyyy HH:mm");
        }
    }
}

Este ejemplo demuestra un caso de uso real donde:

  1. Analizamos una fecha introducida por el usuario con un formato específico
  2. Validamos que la fecha sea correcta y futura
  3. Almacenamos la fecha en un formato estándar (ISO) para persistencia
  4. Mostramos la fecha al usuario en un formato amigable y localizado
  5. Calculamos fechas relacionadas (recordatorio) y las formateamos adecuadamente

El formateo adecuado de fechas y horas es esencial para crear interfaces de usuario intuitivas y asegurar la correcta interpretación de los datos temporales en aplicaciones Java.

CONSTRUYE TU CARRERA EN IA Y PROGRAMACIÓN SOFTWARE

Accede a +1000 lecciones y cursos con certificado. Mejora tu portfolio con certificados de superación para tu CV.

30 % DE DESCUENTO

Plan mensual

19.00 /mes

13.30 € /mes

Precio normal mensual: 19 €
63 % DE DESCUENTO

Plan anual

10.00 /mes

7.00 € /mes

Ahorras 144 € al año
Precio normal anual: 120 €
Aprende Java online

Ejercicios de esta lección LocalDateTime

Evalúa tus conocimientos de esta lección LocalDateTime con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Streams: match

Test

Gestión de errores y excepciones

Código

CRUD en Java de modelo Customer sobre un ArrayList

Proyecto

Clases abstractas

Test

Listas

Código

Métodos de la clase String

Código

Streams: reduce()

Test

API java.nio 2

Puzzle

Polimorfismo

Código

Pattern Matching

Código

Streams: flatMap()

Test

Llamada y sobrecarga de funciones

Puzzle

Métodos referenciados

Test

Métodos de la clase String

Código

Representación de Fecha

Puzzle

Operadores lógicos

Test

Inferencia de tipos con var

Código

Tipos de datos

Código

Estructuras de iteración

Puzzle

Streams: forEach()

Test

Objetos

Puzzle

Funciones lambda

Test

Uso de Scanner

Puzzle

Tipos de variables

Puzzle

Streams: collect()

Puzzle

Operadores aritméticos

Puzzle

Arrays y matrices

Código

Clases y objetos

Código

Interfaz funcional Consumer

Test

CRUD en Java de modelo Customer sobre un HashMap

Proyecto

Interfaces

Código

Enumeraciones Enums

Código

API Optional

Test

Interfaz funcional Function

Test

Encapsulación

Test

Interfaces

Código

Uso de API Optional

Puzzle

Representación de Hora

Test

Herencia básica

Test

Clases y objetos

Código

Interfaz funcional Supplier

Puzzle

HashMap

Puzzle

Sobrecarga de métodos

Test

Polimorfismo de tiempo de ejecución

Puzzle

OOP en Java

Proyecto

Sobrecarga de métodos

Código

CRUD de productos en Java

Proyecto

Clases sealed

Código

Creación de Streams

Test

Records

Código

Encapsulación

Código

Streams: min max

Puzzle

Herencia

Código

Métodos avanzados de la clase String

Puzzle

Funciones

Código

Polimorfismo de tiempo de compilación

Test

Reto sintaxis Java

Proyecto

Conjuntos

Código

Estructuras de control

Código

Recursión

Código

Excepciones

Puzzle

Herencia avanzada

Puzzle

Estructuras de selección

Test

Uso de interfaces

Test

Operadores

Código

Variables

Código

HashSet

Test

Objeto Scanner

Test

Streams: filter()

Puzzle

Operaciones de Streams

Puzzle

Interfaz funcional Predicate

Puzzle

Streams: sorted()

Test

Configuración de entorno

Test

Uso de variables

Test

Clases

Test

Streams: distinct()

Puzzle

Streams: count()

Test

ArrayList

Test

Mapas

Código

Datos de referencia

Test

Interfaces funcionales

Puzzle

Métodos básicos de la clase String

Test

Tipos de datos

Código

Clases abstractas

Código

Instalación

Test

Funciones

Código

Excepciones

Código

Estructuras de control

Código

Herencia de clases

Código

La clase Scanner

Código

Generics

Código

Streams: map()

Puzzle

Funciones y encapsulamiento

Test

Todas las lecciones de Java

Accede a todas las lecciones de Java y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.

Instalación De Java

Introducción Y Entorno

Configuración De Entorno Java

Introducción Y Entorno

Tipos De Datos

Sintaxis

Variables

Sintaxis

Operadores

Sintaxis

Estructuras De Control

Sintaxis

Funciones

Sintaxis

Recursión

Sintaxis

Arrays Y Matrices

Sintaxis

Excepciones

Programación Orientada A Objetos

Clases Y Objetos

Programación Orientada A Objetos

Encapsulación

Programación Orientada A Objetos

Herencia

Programación Orientada A Objetos

Clases Abstractas

Programación Orientada A Objetos

Interfaces

Programación Orientada A Objetos

Sobrecarga De Métodos

Programación Orientada A Objetos

Polimorfismo

Programación Orientada A Objetos

La Clase Scanner

Programación Orientada A Objetos

Métodos De La Clase String

Programación Orientada A Objetos

Excepciones

Programación Orientada A Objetos

Records

Programación Orientada A Objetos

Pattern Matching

Programación Orientada A Objetos

Inferencia De Tipos Con Var

Programación Orientada A Objetos

Enumeraciones Enums

Programación Orientada A Objetos

Generics

Programación Orientada A Objetos

Clases Sealed

Programación Orientada A Objetos

Listas

Framework Collections

Conjuntos

Framework Collections

Mapas

Framework Collections

Funciones Lambda

Programación Funcional

Interfaz Funcional Consumer

Programación Funcional

Interfaz Funcional Predicate

Programación Funcional

Interfaz Funcional Supplier

Programación Funcional

Interfaz Funcional Function

Programación Funcional

Métodos Referenciados

Programación Funcional

Creación De Streams

Programación Funcional

Operaciones Intermedias Con Streams: Map()

Programación Funcional

Operaciones Intermedias Con Streams: Filter()

Programación Funcional

Operaciones Intermedias Con Streams: Distinct()

Programación Funcional

Operaciones Finales Con Streams: Collect()

Programación Funcional

Operaciones Finales Con Streams: Min Max

Programación Funcional

Operaciones Intermedias Con Streams: Flatmap()

Programación Funcional

Operaciones Intermedias Con Streams: Sorted()

Programación Funcional

Operaciones Finales Con Streams: Reduce()

Programación Funcional

Operaciones Finales Con Streams: Foreach()

Programación Funcional

Operaciones Finales Con Streams: Count()

Programación Funcional

Operaciones Finales Con Streams: Match

Programación Funcional

Api Optional

Programación Funcional

Transformación

Programación Funcional

Reducción Y Acumulación

Programación Funcional

Mapeo

Programación Funcional

Streams Paralelos

Programación Funcional

Agrupación Y Partición

Programación Funcional

Filtrado Y Búsqueda

Programación Funcional

Api Java.nio 2

Entrada Y Salida Io

Fundamentos De Io

Entrada Y Salida Io

Leer Y Escribir Archivos

Entrada Y Salida Io

Httpclient Moderno

Entrada Y Salida Io

Clases De Nio2

Entrada Y Salida Io

Api Java.time

Api Java.time

Localtime

Api Java.time

Localdatetime

Api Java.time

Localdate

Api Java.time

Executorservice

Concurrencia

Virtual Threads (Project Loom)

Concurrencia

Future Y Completablefuture

Concurrencia

Spring Framework

Frameworks Para Java

Micronaut

Frameworks Para Java

Maven

Frameworks Para Java

Gradle

Frameworks Para Java

Lombok Para Java

Frameworks Para Java

Quarkus

Frameworks Para Java

Ecosistema Jakarta Ee De Java

Frameworks Para Java

Introducción A Junit 5

Testing

Accede GRATIS a Java y certifícate

Certificados de superación de Java

Supera todos los ejercicios de programación del curso de Java y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.

En esta lección

Objetivos de aprendizaje de esta lección

  • Comprender la naturaleza inmutable y thread-safe de LocalDateTime.
  • Crear y manipular objetos LocalDateTime mediante métodos y ajustes temporales.
  • Realizar conversiones entre LocalDateTime y otros tipos de fecha-hora, incluyendo zonas horarias.
  • Aplicar formateo y parsing de fechas con DateTimeFormatter, incluyendo formatos personalizados y localización.
  • Implementar ejemplos prácticos de uso en registro de eventos, planificación y sistemas de reservas.