Método get() de LocalDate en Java: Dominando la Manipulación de Fechas

Introducción

En este laboratorio, aprenderá a usar el método get() de la clase LocalDate en Java para recuperar campos específicos de una fecha. Este método es útil cuando solo necesita recuperar un campo específico, como el día del mes o el día de la semana, de una fecha dada. Puede usar la enumeración ChronoField para especificar qué campo recuperar.

Crear un archivo Java

En este paso, creará un nuevo archivo Java llamado LocalDateGet.java en el directorio de su proyecto. Este archivo contendrá el código para demostrar el método get() de la clase LocalDate.

Abra la terminal en su WebIDE. El directorio predeterminado es ~/project.
Cree el archivo LocalDateGet.java usando el comando touch:
```
touch LocalDateGet.java
```
Este comando crea un archivo vacío en su directorio actual. Puede verificar su creación listando los archivos:
```
ls
```
Debería ver LocalDateGet.java listado en la salida.

Añadir las importaciones necesarias y la estructura de la clase

Ahora, agregará la estructura básica a su archivo LocalDateGet.java, incluyendo las sentencias de importación requeridas y la definición de la clase principal. Estas importaciones son esenciales para trabajar con las APIs de fecha y hora en Java.

Abra el archivo LocalDateGet.java en el editor de código de la WebIDE.
Agregue el siguiente código al archivo:
```
import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;

public class LocalDateGet {

    public static void main(String[] args) {
        // Aquí es donde llamaremos a nuestros métodos más tarde
    }
}
```
- java.time.LocalDate: Esta clase representa una fecha sin una zona horaria.
- java.time.temporal.ChronoField: Esta enumeración proporciona un conjunto estándar de campos para fecha y hora, como DAY_OF_MONTH, DAY_OF_WEEK, DAY_OF_YEAR, etc.
- java.time.temporal.TemporalAccessor: Esta interfaz proporciona acceso de solo lectura a un objeto temporal, como LocalDate. El método get() está definido en esta interfaz.
- java.time.temporal.TemporalField: Esta interfaz representa un campo de fecha-hora, como el año, el mes o el día del mes. ChronoField implementa esta interfaz.
Guarde el archivo LocalDateGet.java después de agregar el código.

Recuperar el día del mes

En este paso, agregará un método a su clase LocalDateGet que demuestra cómo recuperar el día del mes de un objeto LocalDate usando el método get() y ChronoField.DAY_OF_MONTH.

Abra el archivo LocalDateGet.java en el editor de código de la WebIDE.

Agregue el método getDayOfMonth() dentro de la clase LocalDateGet, pero fuera del método main:

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;

public class LocalDateGet {

    public static void getDayOfMonth() {
        // Define el campo a recuperar: DAY_OF_MONTH
        TemporalField field = ChronoField.DAY_OF_MONTH;
        // Crea un objeto LocalDate para el 17 de mayo de 2021
        TemporalAccessor date = LocalDate.of(2021, 5, 17);

        // Muestra la fecha original
        System.out.println("Date : " + date);

        // Recupera el día del mes usando el método get()
        int val = date.get(field);

        // Muestra el día del mes recuperado
        System.out.println("Day of the month: " + val);
        System.out.println(); // Agrega una línea en blanco para una mejor legibilidad
    }

    public static void main(String[] args) {
        // Aquí es donde llamaremos a nuestros métodos más tarde
    }
}

LocalDate.of(2021, 5, 17): Crea un objeto LocalDate que representa el 17 de mayo de 2021.
ChronoField.DAY_OF_MONTH: Especifica que queremos recuperar el día del mes.
date.get(field): Este es el núcleo de la operación. Llama al método get() en el objeto date, pasando el field (que es ChronoField.DAY_OF_MONTH) para extraer el valor entero correspondiente.

Guarde el archivo LocalDateGet.java.

Ahora, llamemos a este método desde main para verlo en acción. Modifique su método main de la siguiente manera:

public static void main(String[] args) {
    getDayOfMonth();
    // Otros métodos se llamarán aquí más tarde
}

Guarde el archivo nuevamente.
Abra la terminal y compile su código Java:
```
javac LocalDateGet.java
```
Si no hay errores, la compilación se completará silenciosamente.
Ejecute el programa Java compilado:
```
java LocalDateGet
```
Debería ver una salida similar a esta:
```
Date : 2021-05-17
Day of the month: 17
```
Esto confirma que el método getDayOfMonth() extrae correctamente el día del mes.

Recuperar el día de la semana

A continuación, agregará otro método para recuperar el día de la semana. El campo ChronoField.DAY_OF_WEEK representa el día de la semana, donde 1 es lunes, 2 es martes, y así sucesivamente, hasta 7 para el domingo.

Abra el archivo LocalDateGet.java en el editor de código de la WebIDE.

Agregue el método getDayOfWeek() dentro de la clase LocalDateGet, debajo del método getDayOfMonth():

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;

public class LocalDateGet {

    // ... (método getDayOfMonth como se definió previamente) ...

    public static void getDayOfWeek() {
        // Define el campo a recuperar: DAY_OF_WEEK
        TemporalField field = ChronoField.DAY_OF_WEEK;
        // Crea un objeto LocalDate para el 17 de mayo de 2021 (que fue un lunes)
        TemporalAccessor date = LocalDate.of(2021, 5, 17);

        // Muestra la fecha original
        System.out.println("Date : " + date);

        // Recupera el día de la semana usando el método get()
        int val = date.get(field);

        // Muestra el día de la semana recuperado
        System.out.println("Day of the week: " + val);
        System.out.println(); // Agrega una línea en blanco para una mejor legibilidad
    }

    public static void main(String[] args) {
        // ... (método main como se definió previamente) ...
    }
}

Guarde el archivo LocalDateGet.java.

Ahora, llame a este nuevo método desde su método main. Actualice el método main de la siguiente manera:

public static void main(String[] args) {
    getDayOfMonth();
    getDayOfWeek(); // Llama al nuevo método
    // Otros métodos se llamarán aquí más tarde
}

Guarde el archivo nuevamente.
Compile su código Java desde la terminal:
```
javac LocalDateGet.java
```
Ejecute el programa Java compilado:
```
java LocalDateGet
```
Debería ver una salida similar a esta:
```
Date : 2021-05-17
Day of the month: 17

Date : 2021-05-17
Day of the week: 1
```
Dado que el 17 de mayo de 2021 fue un lunes, y ChronoField.DAY_OF_WEEK representa el lunes como 1, la salida Day of the week: 1 es correcta.

Recuperar el día del año

Finalmente, agregará un método para recuperar el día del año. El campo ChronoField.DAY_OF_YEAR representa el día del año, donde 1 es el 1 de enero, y así sucesivamente.

Abra el archivo LocalDateGet.java en el editor de código de la WebIDE.

Agregue el método getDayOfYear() dentro de la clase LocalDateGet, debajo del método getDayOfWeek():

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;

public class LocalDateGet {

    // ... (métodos getDayOfMonth y getDayOfWeek como se definieron previamente) ...

    public static void getDayOfYear() {
        // Define el campo a recuperar: DAY_OF_YEAR
        TemporalField field = ChronoField.DAY_OF_YEAR;
        // Crea un objeto LocalDate para el 17 de mayo de 2021
        TemporalAccessor date = LocalDate.of(2021, 5, 17);

        // Muestra la fecha original
        System.out.println("Date : " + date);

        // Recupera el día del año usando el método get()
        int val = date.get(field);

        // Muestra el día del año recuperado
        System.out.println("Day of the year: " + val);
        System.out.println(); // Agrega una línea en blanco para una mejor legibilidad
    }

    public static void main(String[] args) {
        // ... (método main como se definió previamente) ...
    }
}

Guarde el archivo LocalDateGet.java.

Ahora, llame a este método final desde su método main. Actualice el método main de la siguiente manera:

public static void main(String[] args) {
    getDayOfMonth();
    getDayOfWeek();
    getDayOfYear(); // Llama al nuevo método
}

Guarde el archivo nuevamente.
Compile su código Java desde la terminal:
```
javac LocalDateGet.java
```
Ejecute el programa Java compilado:
```
java LocalDateGet
```
Debería ver la salida completa, incluyendo el día del año:
```
Date : 2021-05-17
Day of the month: 17

Date : 2021-05-17
Day of the week: 1

Date : 2021-05-17
Day of the year: 137
```
El 17 de mayo de 2021 fue el día 137 del año, por lo que la salida Day of the year: 137 es correcta.

Resumen

En este laboratorio, aprendió a usar el método get() de la clase LocalDate de Java para recuperar campos específicos de las fechas. Creó un programa que recuperó el día del mes, el día de la semana y el día del año para la misma fecha (17 de mayo de 2021). Al usar el método get() junto con el enum ChronoField, puede extraer eficientemente componentes de fecha específicos, haciendo que sus programas Java sean más precisos al trabajar con datos temporales.