Introducción

Ya vimos cómo sumar y restar fechas con JavaScript sin importar si eran años, meses o días, pues convertíamos todo a milisegundos.

Hoy toca el turno de Java, que no tiene nada que ver con JavaScript por cierto.

Veamos entonces cómo sumar y restar fechas en Java con las API’s recientes.

Sabremos cómo sumar y restar lo siguiente:

• Años
• Meses
• Semanas
• Días
• Horas
• Minutos
• Segundos
• Nanosegundos

Vamos allá.

Sumar y restar fechas con Java

Vamos a ver múltiples ejemplos que supongo son los más comunes. También veremos cómo operar con nanosegundos, aunque casi no es necesario pues la API proporciona todo.

Sobre los formatos

Lo que haremos para operar con fechas en Java será convertir una cadena representada por una fecha a un objeto de tipo LocalDateTime (si sólo quieres operar fechas sin horas, usa el objeto LocalDate)

Para que quede claro esto, si únicamente trabajas con fechas (no horas ni segundos ni minutos) usa LocalDate, y si quieres trabajar con medidas más pequeñas usa LocalDateTime. Los métodos que veremos son compatibles con ambas clases, o al menos la mayoría.

Cosas que importar

Si decides trabajar con LocalDateTime importa java.time.LocalDateTime, y si prefieres a LocalDate importa java.time.LocalDate.

Para el formateador (que nos permitirá convertir cadenas a fechas y viceversa) importa a java.time.format.DateTimeFormatter

De manera que a primera vista nuestros imports pueden lucir así:

import java.time.LocalDateTime; // O también LocalDate
import java.time.format.DateTimeFormatter;

Ahora sí vamos al código

Sumar años con Java y LocalDateTime

He hecho una función estática, puedes quitarle el static si la pones en otra clase que no sea Main. El punto es que es la siguiente:

public static String sumarAnios(String fechaYHora, long anios) {
    // Crear un formateador como 2018-10-16 15:00:00
    DateTimeFormatter formateador = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss");

    // Lo convertimos a objeto para poder trabajar con él
    LocalDateTime fechaYHoraLocal = LocalDateTime.parse(fechaYHora, formateador);

    // Sumar los años indicados
    fechaYHoraLocal = fechaYHoraLocal.plusYears(anios);

    //Formatear de nuevo y regresar como cadena
    return fechaYHoraLocal.format(formateador);
}

Recibe una cadena como “2018-10-16 20:15:22” y devuelve una cadena en el mismo formato pero con los años sumados. Su uso puede ser así:

String fechaParaOperar = "2018-10-16 00:00:00";
String dentroDeDiezAnios = sumarAnios(fechaParaOperar, 10);
System.out.println("Dentro de diez años: " + dentroDeDiezAnios);

Sumar años con Java y LocalDate

Sólo pondré este ejemplo con los años, para ver cómo funcionan ambas cosas. La función queda así:

public static String sumarAnios(String fechaYHora, long anios) {
        // Crear un formateador como 2018-10-16
        DateTimeFormatter formateador = DateTimeFormatter.ofPattern("uuuu-MM-dd");

        // Lo convertimos a objeto para poder trabajar con él
        LocalDate fechaLocal = LocalDate.parse(fechaYHora, formateador);

        // Sumar los años indicados
        fechaLocal = fechaLocal.plusYears(anios);

        //Formatear de nuevo y regresar como cadena
        return fechaLocal.format(formateador);
    }

Lo que cambia es el formateador y el objeto, que ahora será de tipo LocalDate. Por cierto, ahora recibe una cadena de forma “2018-10-16”; es decir, sin hora.

Ahora sí vamos a ver más funciones. Recuerda que puedes cambiarlas según el código mostrado arriba.

Restar años con Java

public static String restarAnios(String fechaYHora, long anios) {
    // Crear un formateador como 2018-10-16 15:00:00
    DateTimeFormatter formateador = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss");

    // Lo convertimos a objeto para poder trabajar con él
    LocalDateTime fechaYHoraLocal = LocalDateTime.parse(fechaYHora, formateador);

    // Restar los años indicados
    fechaYHoraLocal = fechaYHoraLocal.minusYears(anios);

    //Formatear de nuevo y regresar como cadena
    return fechaYHoraLocal.format(formateador);
}

Exactamente lo mismo que la otra función pero ahora llamamos a minusYears en lugar de plusYears.

Operar con meses, semanas, días, horas, minutos, segundos y nanosegundos

Con los ejemplos de arriba podemos darnos cuenta de que lo único que cambia es el método que llamamos.

Aquí una lista de métodos que soportan ambas clases:

• minusYears y plusYears: sumar y restar años
• Para los meses se usan minusMonths y plusMonths
• En caso de querer sumar o restar días usa minusDays y plusDays para días
• Si queremos trabajar con semanas de 7 días usamos a plusWeeks y minusWeeks

Por otro lado, como LocalDateTime es más preciso, soporta más métodos. Son los siguientes:

• En el caso de trabajar con horas, tenemos a plusHours y minusHours
• Claramente podemos sumar y restar minutos con plusMinutes y minusMinutes
• Si queremos trabajar con segundos usamos plusSeconds y minusSeconds
• Y el último método, el más preciso, es el de plusNanos y minusNanos, que opera con nanosegundos.

Conclusión

Digan lo que digan, preferiré a JavaScript. Tal vez no tiene tantos métodos como Java, pero vamos, con JavaScript no tengo que adivinar qué cosas importar, preocuparme por funciones estáticas, clases, ni nada de eso.

En fin, este post no pretendía comparar, sólo daba mi punto de vista, además de que Java es un buen lenguaje.

Finalmente aquí dejo algunas referencias a las clases usadas:

LocalDate

LocalDateTime

DateTimeFormatter