Los de la vieja escuela sabemos que no era fácil trabajar con horas en Java, porque teníamos que usar clases como Date o Calentar (era lo que había) y todo se volvía un caos: el código no era muy legible que digamos, los métodos eran confusos y aparecían errores por doquier. Hoy en día ya es más sencillo con java.time.LocalTime, porque te deja crear, ajustar y comparar horas de forma sencilla y sin tantas complicaciones. Como no quiero que atravieses por los caminos difíciles al aprender a programar con Java, hoy te explicaré cómo crear y manipular horas con esta clase, que muy sabiamente introdujeron en Java 8.

¿Qué encontrarás en este post?

¿Qué es java.time.LocalTime?

java.time.LocalTime es una clase que representa una hora específica sin información de zona horaria, por eso es tan buena para trabajar con tiempos locales como horarios de apertura de una tienda o el inicio de una reunión. Además, es inmutable y thread-safe, lo que significa que puedes usarla sin preocuparte por problemas de concurrencia o cambios inesperados en su valor.

Características principales de LocalTime

Representa el tiempo como hora:minuto:segundo:nanosegundo.
Te da métodos para ajustar, comparar y formatear tiempos.
Es fácil de usar y leer gracias a su diseño claro.

Cómo crear instancias de java.time.LocalTime

Obtener la hora actual

Quiero que veas que, para obtener la hora actual del sistema, lo mejor es usar el método estático LocalTime.now().

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime now = LocalTime.now();
        System.out.println("Hora actual: " + now);
    }
}

Crear un tiempo específico

Ahora, si lo que necesitas es un tiempo fijo, te aconsejo usar el método LocalTime.of() de esta manera:

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime fixedTime = LocalTime.of(14, 30); // 14:30
        System.out.println("Hora específica: " + fixedTime);
    }
}

Crear desde nanos o segundos del día

Observa cómo con ofNanoOfDay() o ofSecondOfDay() puedes construir tiempos usando valores numéricos.

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime fromNanos = LocalTime.ofNanoOfDay(1_000_000_000L); // 00:00:01
        LocalTime fromSeconds = LocalTime.ofSecondOfDay(3600); // 01:00:00
        System.out.println("Desde nanos: " + fromNanos);
        System.out.println("Desde segundos: " + fromSeconds);
    }
}

Cómo funciona la manipulación de tiempos con java.time.LocalTime

Sumar o restar tiempo

Como te decía, puedes sumar o restar horas, minutos, segundos o nanosegundos. Aquí te muestro cómo:

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime now = LocalTime.now();
        LocalTime plusHours = now.plusHours(2); // Sumar 2 horas
        LocalTime minusMinutes = now.minusMinutes(30); // Restar 30 minutos
        System.out.println("Hora actual: " + now);
        System.out.println("Más 2 horas: " + plusHours);
        System.out.println("Menos 30 minutos: " + minusMinutes);
    }
}

Comparar tiempos

Cuando vayas a comparar tiempos, es mejor usar isBefore() y isAfter() como te muestro aquí:

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime time1 = LocalTime.of(10, 0);
        LocalTime time2 = LocalTime.of(12, 30);
        System.out.println("¿time1 es antes de time2? " + time1.isBefore(time2));
        System.out.println("¿time1 es después de time2? " + time1.isAfter(time2));
    }
}

Ajustar valores

Algo sorprendente es que, con métodos como withHour() o withMinute() puedes cambiar partes específicas del tiempo. Te explico cómo:

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime time = LocalTime.of(10, 0);
        LocalTime adjustedTime = time.withHour(15).withMinute(45); // Cambiar a 15:45
        System.out.println("Hora ajustada: " + adjustedTime);
    }
}

Cómo formatear y parsear tiempos

Esto es algo que seguramente tendrás que hacer, así que préstale mucha atención. Para convertir un LocalTime en un formato legible, usa DateTimeFormatter.

Recuerda que también puedes parsear cadenas con el método parse().

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        LocalTime time = LocalTime.of(16, 30);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        String formattedTime = time.format(formatter);
        System.out.println("Hora formateada: " + formattedTime);

        LocalTime parsedTime = LocalTime.parse("18:45", DateTimeFormatter.ofPattern("HH:mm"));
        System.out.println("Hora parseada: " + parsedTime);
    }
}

Algunas mejoras para implementar en tus proyectos reales

Aparte de lo que te expliqué anteriormente, también quiero dejarte 3 consejos que a mí me sirvieron bastante cuando empecé a usar esta clase:

Evita Timezones: Lo que yo te aconsejo es que uses LocalTime solo para tiempos locales. Si necesitas zonas horarias, lo mejor es que combines con otras clases como ZonedDateTime.
Thread-safety: Como te dije, LocalTime es inmutable, por eso es perfecto para aplicaciones multi-hilo.
Formateo claro: No olvides que lo mejor es usar formatos estándar, porque así aseguras la compatibilidad entre sistemas.

Espero que hayas aprendido que java.time.LocalTime es una herramienta imprescindible en Java para trabajar con horas de manera simple y efectiva. ¿Te gustaría dominar más trucos y aprender cómo implementar estas técnicas en aplicaciones reales? Apúntate al Bootcamp de Java Full Stack de KeepCoding y transforma tu carrera en IT en tiempo récord. ¡El momento de mejorar tu futuro es ahora!