Cómo comparar fechas en Java (LocalDate, DateTime, mejores prácticas)

1. Lo que aprenderás en este artículo (Conclusión primero)

• La mejor manera de comparar fechas en Java usando la API moderna java.time
• Qué clase de fecha/hora de Java debes usar según tu situación
• Cómo realizar de manera segura verificaciones de antes / después / igual
• Por qué java.util.Date causa confusión y cómo manejarlo correctamente
• Errores comunes que cometen los principiantes al comparar fechas en Java
• Mejores prácticas usadas en aplicaciones Java del mundo real

Respuesta corta: Si quieres comparar fechas en Java correctamente, usa LocalDate, LocalDateTime o Instant de java.time, no Date crudo ni comparación de cadenas.

• Principiantes en Java que se sienten confundidos por la comparación de fechas
• Desarrolladores que mantienen código heredado
• Ingenieros que quieren código Java limpio, sin errores y a prueba de futuro

1.1 El problema principal con la comparación de fechas en Java

• Comparar cadenas de fechas en lugar de objetos de fecha
• Usar java.util.Date sin entender los componentes de tiempo
• Mezclar lógica solo de fecha con lógica de fecha-hora
• Ignorar las zonas horarias
• Asumir que “mismo día” significa “mismo sello de tiempo”

1.2 Una regla que resuelve la mayoría de los problemas

¿Estoy comparando una fecha o una fecha-hora?

1.3 Los casos de uso más comunes

• ¿Está la fecha A antes que la fecha B?
• ¿Está la fecha A después que la fecha B?
• ¿Son dos fechas iguales?
• ¿Está una fecha dentro de un rango?
• ¿Cuántos días u horas hay entre dos fechas?

• isBefore()
• isAfter()
• isEqual()
• compareTo()

1.4 Por qué debes evitar la comparación de fechas basada en cadenas

"2026-1-9".compareTo("2026-01-10");

Regla: Si tus fechas son cadenas, analízalas en objetos de fecha primero — siempre.

1.5 En qué se enfoca esta guía (y en qué no)

• Comparación práctica de fechas en Java
• Patrones de codificación del mundo real
• Explicaciones claras para principiantes
• Mejores prácticas para Java moderno (Java 8+)

• Peculiaridades históricas de las API anteriores a Java 8 (a menos que sea necesario)
• Matemáticas de calendario de bajo nivel
• Explicaciones excesivamente teóricas

2. Entendiendo las clases de fecha y hora en Java (Antes de comparar)

2.1 Dos generaciones de API de fecha en Java

API heredada (Antigua, propensa a errores)

• java.util.Date
• java.util.Calendar

API moderna (Recomendada)

• java.time.LocalDate
• java.time.LocalDateTime
• java.time.ZonedDateTime
• java.time.Instant

Mejor práctica: Siempre prefiera java.time. Use las APIs heredadas solo cuando no pueda evitarlas.

2.2 LocalDate: Cuando solo necesita la fecha

• Cumpleaños
• Fechas límite
• Días festivos
• Fechas de vencimiento

  LocalDate today = LocalDate.now();
  LocalDate deadline = LocalDate.of(2026, 1, 31);
  

• Almacena año, mes y día
• Sin hora, sin zona horaria
• Ideal para comparación de fechas

2.3 LocalDateTime: Cuando la hora importa

• Horas de reserva
• Programas de eventos
• Marcas de tiempo de registro (sin zona horaria)

  LocalDateTime meeting =
      LocalDateTime.of(2026, 1, 9, 18, 30);
  

• Incluye fecha y hora
• Sin información de zona horaria
• Preciso pero solo en contexto local

2.4 ZonedDateTime: Cuando la ubicación importa

ZonedDateTime tokyo =
    ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));

• Almacena fecha, hora y zona horaria
• Maneja el horario de verano correctamente
• Es lo mejor para mostrar fecha-hora a los usuarios

2.5 Instant: La mejor opción para comparación y almacenamiento

Instant now = Instant.now();

• Independiente de la zona horaria
• Perfecto para comparación
• Ideal para bases de datos y registros

Mejor práctica usada en sistemas de producción: Almacene y compare fechas como Instant, convierta a ZonedDateTime solo para mostrar.

2.6 Resumen: Elija la clase correcta primero

3. Comparación de fechas en Java con java.time (Sección más importante)

3.1 Comparación básica de fechas: isBefore, isAfter, isEqual

Ejemplo con LocalDate

LocalDate date1 = LocalDate.of(2026, 1, 9);
LocalDate date2 = LocalDate.of(2026, 1, 10);

System.out.println(date1.isBefore(date2)); // true
System.out.println(date1.isAfter(date2));  // false
System.out.println(date1.isEqual(date2));  // false

• isBefore() → verifica si una fecha es anterior
• isAfter() → verifica si una fecha es posterior
• isEqual() → verifica si ambas fechas representan el mismo día

3.2 Comparación de fecha y hora con LocalDateTime

LocalDateTime t1 =
    LocalDateTime.of(2026, 1, 9, 18, 30);
LocalDateTime t2 =
    LocalDateTime.of(2026, 1, 9, 19, 0);

System.out.println(t1.isBefore(t2)); // true

• Dos valores en la misma fecha pero con horas diferentes no son iguales
• isEqual() verifica tanto la fecha como la hora

3.3 Cómo verificar “Mismo Día” correctamente

boolean sameDay =
    t1.toLocalDate().isEqual(t2.toLocalDate());

• Los componentes de hora se eliminan
• La comparación se vuelve solo de fecha
• La intención es cristalina en el código

Comprobación del mismo día = convertir a LocalDate primero.

3.4 Uso de compareTo() para ordenar y clasificar

int result = date1.compareTo(date2);

if (result < 0) {
    System.out.println("date1 is before date2");
}

• Negativo → anterior
• Cero → igual
• Positivo → posterior

List<LocalDate> dates = List.of(
    LocalDate.of(2026, 1, 10),
    LocalDate.of(2026, 1, 8),
    LocalDate.of(2026, 1, 9)
);

dates.stream()
     .sorted()
     .forEach(System.out::println);

3.5 equals() vs isEqual(): ¿Cuál deberías usar?

date1.equals(date2);
date1.isEqual(date2);

• isEqual() → comparación semántica de fechas (recomendado en lógica)
• equals() → igualdad de objetos (comúnmente usado en colecciones)

3.6 Manejo seguro de null en la comparación de fechas

LocalDate date = null;
date.isBefore(LocalDate.now()); // throws exception

• Define siempre qué significa null en tu sistema
• Verifica null antes de comparar
• Considera encapsular la lógica en métodos auxiliares

boolean isBefore(LocalDate a, LocalDate b) {
    if (a == null || b == null) {
        return false;
    }
    return a.isBefore(b);
}

3.7 Puntos clave para la comparación de fechas con java.time

• Usa isBefore, isAfter, isEqual para mayor claridad
• Usa compareTo para ordenar y lógica numérica
• Convierte a LocalDate para comprobaciones del mismo día
• Maneja null de forma intencional

4. Comparación de fechas con java.util.Date (código heredado)

4.1 Comparación básica con before() y after()

Date d1 = new Date();
Date d2 = new Date(System.currentTimeMillis() + 1000);

System.out.println(d1.before(d2)); // true
System.out.println(d1.after(d2));  // false

• Date siempre incluye tiempo hasta milisegundos
• No existe el concepto de “solo fecha”

4.2 La mayor trampa: “Mismo día” no existe en Date

• 2026-01-09 00:00
• 2026-01-09 12:00

  d1.equals(d2); // false
  

4.3 Convertir Date a java.time inmediatamente (recomendado)

Date legacyDate = new Date();

Instant instant = legacyDate.toInstant();
LocalDate localDate =
    instant.atZone(ZoneId.systemDefault()).toLocalDate();

4.4 Mejores prácticas para sistemas heredados

• Acepta Date solo en los límites del sistema
• Convierte a Instant o LocalDate
• Realiza todas las comparaciones usando java.time

Regla usada en sistemas Java profesionales: APIs heredadas en los bordes, APIs modernas en el núcleo.

5. Comparación de cadenas de fecha en Java (la forma correcta)

5.1 Por qué nunca debes comparar cadenas de fecha directamente

"2026-1-9".compareTo("2026-01-10");

• Los diferentes formatos rompen el orden
• La falta de ceros iniciales causa resultados incorrectos
• Las diferencias de configuración regional y formato introducen errores silenciosos

Regla: Nunca compares directamente cadenas de fechas. Siempre conviértelas a objetos de fecha.

5.2 El flujo de trabajo correcto: Analizar → Comparar

1. Analiza la cadena a un objeto de fecha/hora
2. Compara usando java.time

Ejemplo de formato ISO (yyyy-MM-dd)

String s1 = "2026-01-09";
String s2 = "2026-01-10";

LocalDate d1 = LocalDate.parse(s1);
LocalDate d2 = LocalDate.parse(s2);

System.out.println(d1.isBefore(d2)); // true

• Legible
• Seguro
• Totalmente soportado por Java

5.3 Manejo de formatos de fecha personalizados con DateTimeFormatter

• 2026/01/09
• 01-09-2026
• 2026-01-09 18:30

DateTimeFormatter formatter =
    DateTimeFormatter.ofPattern("yyyy/MM/dd");

LocalDate date =
    LocalDate.parse("2026/01/09", formatter);

DateTimeFormatter formatter =
    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");

LocalDateTime dateTime =
    LocalDateTime.parse("2026-01-09 18:30", formatter);

5.4 Manejo de múltiples formatos posibles (Validación de entrada)

• Intenta los formatos conocidos en orden
• Falla rápidamente si ninguno coincide

  List<DateTimeFormatter> formatters = List.of(
      DateTimeFormatter.ofPattern("yyyy-MM-dd"),
      DateTimeFormatter.ofPattern("yyyy/MM/dd")
  );
  
  LocalDate parseDate(String text) {
      for (DateTimeFormatter f : formatters) {
          try {
              return LocalDate.parse(text, f);
          } catch (Exception ignored) {}
      }
      throw new IllegalArgumentException("Invalid date format");
  }
  

5.5 Manejo de excepciones y estrategia de validación

LocalDate.parse("2026-99-99"); // throws exception

• Trata las fechas inválidas como errores de validación
• Registra los fallos de parseo
• Nunca ignores silenciosamente la entrada inválida

5.6 Puntos clave para la comparación de fechas basada en cadenas

• La comparación de cadenas es poco fiable
• Siempre analiza las cadenas a LocalDate o LocalDateTime
• Usa DateTimeFormatter explícitamente
• Valida y maneja los errores de forma intencional

6. Comprobaciones de rangos de fechas en Java (Lógica de período / plazo)

• Sistemas de reservas
• Periodos de campaña
• Control de acceso
• Verificaciones de validez de contratos

6.1 Define claramente los límites inclusivos vs exclusivos

• ¿Se incluye la fecha de inicio?
• ¿Se incluye la fecha de fin?

Ejemplo de rango inclusivo (inicio ≤ objetivo ≤ fin)

boolean inRange =
    !target.isBefore(start) && !target.isAfter(end);

• No antes del inicio
• No después del fin

6.2 Fecha de fin exclusiva (Muy común en la práctica)

boolean valid =
    !target.isBefore(start) && target.isBefore(end);

• El inicio es inclusivo
• El fin es exclusivo

6.3 Comprobaciones de rango con LocalDateTime

boolean active =
    !now.isBefore(startTime) && now.isBefore(endTime);

• Sistemas de reservas
• Lógica de expiración de sesiones
• Toggles de características

6.4 Manejo de Rangos Abiertos (null Values)

• Inicio null → válido desde el principio de los tiempos
• Fin null → válido indefinidamente

  boolean isWithin(
      LocalDate target,
      LocalDate start,
      LocalDate end
  ) {
      if (start != null && target.isBefore(start)) {
          return false;
      }
      if (end != null && target.isAfter(end)) {
          return false;
      }
      return true;
  }
  

6.5 Conciencia de Zona Horaria en Verificaciones de Rangos

LocalDate today =
    LocalDate.now(ZoneId.of("Asia/Tokyo"));

• Los usuarios están en diferentes regiones
• Los servidores se ejecutan en diferentes entornos

6.6 Mejores Prácticas para la Lógica de Rangos de Fechas

• Decide los límites antes de codificar
• Prefiere métodos auxiliares
• Evita condiciones complejas en línea
• Documenta las reglas de negocio claramente

7. Cálculo de Diferencias de Fecha y Hora en Java (Period / Duration)

7.1 Diferencias Basadas en Fechas: Period (Años, Meses, Días)

LocalDate start = LocalDate.of(2026, 1, 1);
LocalDate end   = LocalDate.of(2026, 1, 31);

Period period = Period.between(start, end);

System.out.println(period.getYears());  // 0
System.out.println(period.getMonths()); // 0
System.out.println(period.getDays());   // 30

• Expresa diferencias en años, meses y días
• Respeta los límites del calendario
• Ideal para diferencias legibles por humanos

• Cálculo de edad
• Períodos de suscripción
• Duraciones de contratos

7.2 Obtener Días Totales Entre Fechas

long days =
    ChronoUnit.DAYS.between(start, end);

• Un valor numérico único
• Independiente de meses o años

7.3 Diferencias Basadas en Tiempo: Duration (Horas, Minutos, Segundos)

LocalDateTime t1 =
    LocalDateTime.of(2026, 1, 9, 18, 0);
LocalDateTime t2 =
    LocalDateTime.of(2026, 1, 9, 20, 30);

Duration duration = Duration.between(t1, t2);

System.out.println(duration.toHours());   // 2
System.out.println(duration.toMinutes()); // 150

• Mide el tiempo en segundos y nanosegundos
• Ignora los límites del calendario
• Siempre trata un día como 24 horas

7.4 Trampa Importante: Hora de Verano

• Un día puede tener 23 o 25 horas
• Duration aún asume 24 horas

Duration duration =
    Duration.between(
        zonedDateTime1.toInstant(),
        zonedDateTime2.toInstant()
    );

7.5 Elegir la Herramienta Correcta para Diferencias

8. Trampas de Zona Horaria en la Comparación de Fechas en Java

8.1 Por Qué LocalDateTime Puede Ser Engañoso

LocalDateTime now = LocalDateTime.now();

• Depende de la zona horaria predeterminada del sistema
• No tiene información de ubicación
• Puede cambiar de comportamiento entre entornos

8.2 ZonedDateTime: Cuando la Ubicación Importa

ZonedDateTime tokyo =
    ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
ZonedDateTime newYork =
    ZonedDateTime.now(ZoneId.of("America/New_York"));

• Pantallas orientadas al usuario
• Programación específica por región

8.3 Instant: La opción más segura para comparación y almacenamiento

Instant a = Instant.now();
Instant b = Instant.now();

System.out.println(a.isBefore(b));

• Independiente de la zona horaria
• Perfecto para comparaciones
• Ideal para bases de datos y registros

Mejor práctica de la industria: Almacene y compare el tiempo como Instant, convierta a ZonedDateTime solo para la visualización.

8.4 Patrón de arquitectura recomendado

1. Entrada → ZonedDateTime
2. Lógica interna y almacenamiento → Instant
3. Salida → ZonedDateTime

9. Resumen: Guía rápida de comparación de fechas en Java

9.1 ¿Qué clase debería usar?

9.2 Métodos de comparación para recordar

• Antes / Después → isBefore() / isAfter()
• Igualdad → isEqual()
• Orden → compareTo()

9.3 Errores comunes a evitar

• Comparar cadenas de fecha
• Usar Date para lógica de negocio
• Ignorar zonas horarias
• Mezclar lógica de solo fecha y de fecha y hora
• Límites de rango ambiguos

Preguntas frecuentes

P1. ¿Cuál es la mejor manera de comparar fechas en Java?

P2. ¿Cómo verifico si dos fechas están en el mismo día?

P3. ¿Puedo comparar cadenas de fecha directamente en Java?

P4. ¿Cómo manejo correctamente las zonas horarias?

P5. ¿Está java.util.Date obsoleto?

Reflexión final