Datos tipo fecha/hora – JAVA SIN IA

Correspondencia en Python —>

Un tipo de datos que se utiliza con mucha frecuencia es el tipo de fecha y/o hora. La mejor forma de manejar este tipo de datos es mediante el paquete java.time. Dentro de este paquete, encontramos la clase LocalDate. Este clase permite almacenar un dato tipo fecha (sin hora).

LocalDate.now( ) Este método nos da la fecha actual.

import java.time.LocalDate;
public class Main {
    public static void main(String[] args) {
        LocalDate hoy = LocalDate.now();
        System.out.println("Fecha actual: "+hoy);
    }
}

Resultado:
Fecha actual: 2026-07-18

LocalDate.of (año,mes,dia). Con el método .of, podemos crear un dato tipo fecha. Debemos de facilitar los parámetros en el orden indicado, y la fecha debe de ser válida.

import java.time.LocalDate;
public class Main {
    public static void main(String[] args) {
        LocalDate mi_aniversario = LocalDate.of(2026,11,16);
        System.out.println("Mi cumpleaños es: "+mi_aniversario);
    }
}

Resultado:
Mi cumpleaños es: 2026-11-16

La clase LocalTime hace posible la creación y manipulación de datos tipo hora.

LocalTime.now( ). Nos facilita la hora actual.

import java.time.LocalTime;
public class Main {
    public static void main(String[] args) {
        LocalTime hora = LocalTime.now();
        System.out.println("La hora actual es: "+hora);
    }
}

Resultado (ahora mismo)
La hora actual es: 15:49:38.265568600

LocalTime.of (hora, minutos, segundos). Nos facilita la creación de un dato tipo hora.

import java.time.LocalTime;
public class Main {
    public static void main(String[] args) {
        LocalTime mundial = LocalTime.of(20,30,0);
        System.out.println("La hora del partido de hoy es: "+mundial);
    }
}

Resultado,
La hora del partido de hoy es: 20:30

Con LocalDateTime podemos manejar fecha y hora a la vez.

LocalDateTime.now( ) Nos facilita la fecha y hora actuales.

import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) {
        LocalDateTime ahora=LocalDateTime.now();
        System.out.println("Fecha y hora actuales: "+ahora);
    }
}

En estos momentos daría:
Fecha y hora actuales: 2026-07-18T18:27:20.935166796

Después de la fecha incluye la letra T y a continuación inserta la hora.

LocalDateTime.of(año,mes,dia,hora,minutos,segundos). Este método permite crear una fecha y hora.

import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) {
        LocalDateTime mi_fecha=LocalDateTime.of(2026,11,16,14,30,15);
        System.out.println("Me gusta esta fecha: "+mi_fecha);
    }
}

Resultado:
Me gusta esta fecha: 2026-11-16T14:30:15

Gracias a la clase DateTimeFormatter, podemos convertir un objeto LocalDate a un objeto String. El método es DateTimeFormatter.ofPattern(«dd/MM/yyyy») que permite definir el formato que va a tener la cadena (en este caso «formato»), que se aplicará a un objeto LocalDate con el método .format(formato)

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        String mi_cadena;
        DateTimeFormatter formato =DateTimeFormatter.ofPattern("dd/MM/yyyy");
        LocalDate hoy = LocalDate.now();
        mi_cadena="Fecha actual: "+hoy.format(formato);
        System.out.println(mi_cadena);
    }
}

Resultado:
Fecha actual: 18/07/2026

También se puede efectuar la operación inversa. A partir de un dato String que tendrá un formato determinado, podemos obtener un dato de tipo DateTime. El método en este caso será LocalDate.parse(texto, formato), texto será el objeto String que tendrá el formato declarado como segundo parámetro.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        String mi_cadena="16-11-1965";
        DateTimeFormatter formato =DateTimeFormatter.ofPattern("dd-MM-yyyy");
        LocalDate cumple = LocalDate.parse(mi_cadena,formato);
        System.out.println(cumple);
    }
}

Resultado (en formato LocalDate):
1965-11-16

A un dato tipo fecha, podemos sumar o restar días, meses o años, utilizando el método adecuado:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        LocalDate sumando_dias, restando_dias, sumando_mes,restando_mes;
        LocalDate sumando_año,restando_año;
        LocalDate mi_fecha=LocalDate.now();
        sumando_dias=mi_fecha.plusDays(7);
        restando_dias=mi_fecha.minusDays(7);
        sumando_mes=mi_fecha.plusMonths(1);
        restando_mes=mi_fecha.minusMonths(1);
        sumando_año=mi_fecha.plusYears(10);
        restando_año=mi_fecha.minusYears(10);

        System.out.println("Hoy es: "+mi_fecha);
        System.out.println("Próxima semana: "+sumando_dias);
        System.out.println("Semana pasada: "+restando_dias);
        System.out.println("Próximo mes: "+sumando_mes);
        System.out.println("Mes pasado: "+restando_mes);
        System.out.println("Próximo decenio: "+sumando_año);
        System.out.println("Decenio pasado: "+restando_año);
    }
}

Nos resulta:

Hoy es: 2026-07-19
Próxima semana: 2026-07-26
Semana pasada: 2026-07-12
Próximo mes: 2026-08-19
Mes pasado: 2026-06-19
Próximo decenio: 2036-07-19
Decenio pasado: 2016-07-19

De forma idéntica a un dato tipo hora, podemos sumar o restar, horas, minutos o segundos.

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime sumando_horas, restando_horas, sumando_minutos,restando_minutos;
        LocalTime sumando_segundos,restando_segundos;
        LocalTime mi_hora=LocalTime.now();
        sumando_horas=mi_hora.plusHours(12);
        restando_horas=mi_hora.minusHours(12);
        sumando_minutos=mi_hora.plusMinutes(30);
        restando_minutos=mi_hora.minusMinutes(30);
        sumando_segundos=mi_hora.plusSeconds(30);
        restando_segundos=mi_hora.minusSeconds(30);

        System.out.println("Hora actual: "+mi_hora);
        System.out.println("Dentro de 12 horas serán las: "+sumando_horas);
        System.out.println("Hacen 12 horas eran las: "+restando_horas);
        System.out.println("Dentro de 30 minutos serán las: "+sumando_minutos);
        System.out.println("Hacen 30 minutos eran las: "+restando_minutos);
        System.out.println("Dentro de 30 segundos eran las: "+sumando_segundos);
        System.out.println("Hacen 30 segundos eran las: "+restando_segundos);
    }
}

Resultado:

Hora actual: 17:56:58.918151300
Dentro de 12 horas serán las: 05:56:58.918151300
Hacen 12 horas eran las: 05:56:58.918151300
Dentro de 30 minutos serán las: 18:26:58.918151300
Hacen 30 minutos eran las: 17:26:58.918151300
Dentro de 30 segundos eran las: 17:57:28.918151300
Hacen 30 segundos eran las: 17:56:28.918151300

Podemos saber los días que existen entre una fecha y otra utilizando para ello el método ChronoUnit.DAYS.between(fecha_menor, fecha_mayor)

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) {
        LocalDate hoy= LocalDate.now();
        LocalDate mi_cumple=LocalDate.of(2026,11,16);
        long dias=ChronoUnit.DAYS.between(hoy,mi_cumple);
        System.out.println("Hoy es: "+hoy);
        System.out.println("Mi cumple es :"+mi_cumple);
        System.out.println("Faltan: "+dias+" dias para mi cumpleaños.");
    }
}

Resultado:

Hoy es: 2026-07-19
Mi cumple es :2026-11-16
Faltan: 120 dias para mi cumpleaños.

Si sustituimos DAYS por MONTHS o YEARS, obtendremos los meses o años completos que existen entre las dos fechas. Si la primera fecha es menor que la segunda, los datos serán positivos. En caso de que la fecha primera sea menor, los resultados serán negativos.

También podemos saber los segundos que faltan para llegar a una hora. El método es ChronoUnit.SECONDS.between(ahora,después)

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) {
        LocalTime ahora= LocalTime.now();
        LocalTime cena=LocalTime.of(22,30);
        long falta=ChronoUnit.SECONDS.between(ahora,cena);
        System.out.println("Ahora son "+ahora);
        System.out.println("La cena es a las "+cena);
        System.out.println("Faltan: "+falta+" segundos para la cena.");
    }
}

Resultado:

Ahora son 19:45:22.519013200
La cena es a las 22:30
Faltan: 9877 segundos para la cena.

También si sustituimos SECONS por MINUTES o HOURS obtenemos los minutos y las horas completas respectivamente que faltan para la segunda hora. Si la segunda hora es menor que la primera, el resultado será negativo.

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) {
        LocalTime ahora= LocalTime.now();
        LocalTime cena=LocalTime.of(22,30);
        long falta=ChronoUnit.SECONDS.between(ahora,cena);
        long horas=ChronoUnit.HOURS.between(ahora,cena);
        long minutos=ChronoUnit.MINUTES.between(ahora,cena);
        minutos=minutos-(horas*60);
        long segundos=falta-(horas*3600+minutos*60);
        System.out.println("Ahora son las: "+ahora);
        System.out.println("La cena es a las: "+cena);
        System.out.println("Faltan "+horas+" horas "+minutos+" minutos "
            +segundos+" segundos para la cena.");
    }
}

Ahora son las: 14:11:16.839463800
La cena es a las: 22:30
Faltan 8 horas 18 minutos 43 segundos para la cena.

También nos puede resultar muy útil comprobar si dos fechas son iguales, o si una es anterior a la otra. Según sea la primera fecha igual, anterior, o posterior a la segunda, los métodos son .isEqual, is.Before o is.After

import java.time.LocalDate;

class  Comparar{

    public static void main(String[] args) {
        LocalDate mi_cumple = LocalDate.of(2026, 11, 16);
        LocalDate tu_cumple = LocalDate.of(2026, 11, 16);
        LocalDate navidad= LocalDate.of(2026,12,25);
        LocalDate hoy=LocalDate.now();

        comparar(mi_cumple,tu_cumple);
        comparar(mi_cumple,navidad);
        comparar(tu_cumple,hoy);
    }

    static void comparar (LocalDate primera, LocalDate segunda){
        System.out.println("Fecha 1: "+primera);
        System.out.println("Fecha 2: "+segunda);
        if (primera.isEqual(segunda)){
            System.out.println("Coinciden las fechas."+"\n");
        }
        if (primera.isBefore(segunda)){
            System.out.println("La Fecha 1 es anterior a Fecha 2"+"\n");
        }
        if (primera.isAfter(segunda)){
            System.out.println("La Fecha 1 es posterior a Fecha 2"+"\n");
        }
    }
}

Resultado:

Fecha 1: 2026-11-16
Fecha 2: 2026-11-16
Coinciden las fechas.

Fecha 1: 2026-11-16
Fecha 2: 2026-12-25
La Fecha 1 es anterior a Fecha 2

Fecha 1: 2026-11-16
Fecha 2: 2026-07-20
La Fecha 1 es posterior a Fecha 2

Inicio	Comandos Java	Bloques de código.
Comentar código	System.out.print	Scanner (System.in)
Captura de errores	String	Datos Numéricos
Elementos aleatorios	Datos Fecha/hora	Constantes
Bucles for	Bucles while	Bloque if
Arrays	ArrayList	switch case
HashSet	HashMap	Métodos.
Clases	Archivos	Entorno gráfico Swing
JFrame (Ventanas)	Componentes básicos.